Ada95 Reference Manual

Table of Contents

Foreword

  1. ISO (the International Organization for Standardization) and IEC (the International Electrotechnical Commission) form the specialized system for worldwide standardization. National bodies that are members of ISO or IEC participate in the development of International Standards through technical committees established by the respective organization to deal with particular fields of technical activity. ISO and IEC technical committees collaborate in fields of mutual interest. Other international organizations, governmental and non-governmental, in liaison with ISO and IEC, also take part in the work.
  2. In the field of information technology, ISO and IEC have established a joint technical committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical committee are circulated to national bodies for voting. Publication as an International Standard requires approval by at least 75 % of the national bodies casting a vote.
  3. International Standard ISO/IEC 8652 was prepared by Joint Technical Committee ISO/IEC JTC 1, Information Technology.
  4. This second edition cancels and replaces the first edition (ISO 8652:1987), of which it constitutes a technical revision.
  5. Annexes A to J form an integral part of this International Standard. Annexes K to P are for information only.

Introduction

  1. This is the Ada Reference Manual.
  2. Other available Ada documents include:
    1. Rationale for the Ada Programming Language -- 1995 edition, which gives an introduction to the new features of Ada, and explains the rationale behind them. Programmers should read this first.
    2. Changes to Ada -- 1987 to 1995. This document lists in detail the changes made to the 1987 edition of the standard.
    3. The Annotated Ada Reference Manual (AARM). The AARM contains all of the text in the RM95, plus various annotations. It is intended primarily for compiler writers, validation test writers, and others who wish to study the fine details. The annotations include detailed rationale for individual rules and explanations of some of the more arcane interactions among the rules.

Design Goals

  1. Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. This revision to the language was designed to provide greater flexibility and extensibility, additional control over storage management and synchronization, and standardized packages oriented toward supporting important application areas, while at the same time retaining the original emphasis on reliability, maintainability, and efficiency.
  2. The need for languages that promote reliability and simplify maintenance is well established. Hence emphasis was placed on program readability over ease of writing. For example, the rules of the language require that program variables be explicitly declared and that their type be specified. Since the type of a variable is invariant, compilers can ensure that operations on variables are compatible with the properties intended for objects of the type. Furthermore, error-prone notations have been avoided, and the syntax of the language avoids the use of encoded forms in favor of more English-like constructs. Finally, the language offers support for separate compilation of program units in a way that facilitates program development and maintenance, and which provides the same degree of checking between units as within a unit.
  3. Concern for the human programmer was also stressed during the design. Above all, an attempt was made to keep to a relatively small number of underlying concepts integrated in a consistent and systematic way while continuing to avoid the pitfalls of excessive involution. The design especially aims to provide language constructs that correspond intuitively to the normal expectations of users.
  4. Like many other human activities, the development of programs is becoming ever more decentralized and distributed. Consequently, the ability to assemble a program from independently produced software components continues to be a central idea in the design. The concepts of packages, of private types, and of generic units are directly related to this idea, which has ramifications in many other aspects of the language. An allied concern is the maintenance of programs to match changing requirements; type extension and the hierarchical library enable a program to be modified while minimizing disturbance to existing tested and trusted components.
  5. No language can avoid the problem of efficiency. Languages that require over-elaborate compilers, or that lead to the inefficient use of storage or execution time, force these inefficiencies on all machines and on all programs. Every construct of the language was examined in the light of present implementation techniques. Any proposed construct whose implementation was unclear or that required excessive machine resources was rejected.

Language Summary

  1. An Ada program is composed of one or more program units. Program units may be subprograms (which define executable algorithms), packages (which define collections of entities), task units (which define concurrent computations), protected units (which define operations for the coordinated sharing of data between tasks), or generic units (which define parameterized forms of packages and subprograms). Each program unit normally consists of two parts: a specification, containing the information that must be visible to other units, and a body, containing the implementation details, which need not be visible to other units. Most program units can be compiled separately.
  2. This distinction of the specification and body, and the ability to compile units separately, allows a program to be designed, written, and tested as a set of largely independent software components.
  3. An Ada program will normally make use of a library of program units of general utility. The language provides means whereby individual organizations can construct their own libraries. All libraries are structured in a hierarchical manner; this enables the logical decomposition of a subsystem into individual components. The text of a separately compiled program unit must name the library units it requires.

Program Units

  1. A subprogram is the basic unit for expressing an algorithm. There are two kinds of subprograms: procedures and functions. A procedure is the means of invoking a series of actions. For example, it may read data, update variables, or produce some output. It may have parameters, to provide a controlled means of passing information between the procedure and the point of call. A function is the means of invoking the computation of a value. It is similar to a procedure, but in addition will return a result.
  2. A package is the basic unit for defining a collection of logically related entities. For example, a package can be used to define a set of type declarations and associated operations. Portions of a package can be hidden from the user, thus allowing access only to the logical properties expressed by the package specification.
  3. Subprogram and package units may be compiled separately and arranged in hierarchies of parent and child units giving fine control over visibility of the logical properties and their detailed implementation.
  4. A task unit is the basic unit for defining a task whose sequence of actions may be executed concurrently with those of other tasks. Such tasks may be implemented on multicomputers, multiprocessors, or with interleaved execution on a single processor. A task unit may define either a single executing task or a task type permitting the creation of any number of similar tasks.
  5. A protected unit is the basic unit for defining protected operations for the coordinated use of data shared between tasks. Simple mutual exclusion is provided automatically, and more elaborate sharing protocols can be defined. A protected operation can either be a subprogram or an entry. A protected entry specifies a Boolean expression (an entry barrier) that must be true before the body of the entry is executed. A protected unit may define a single protected object or a protected type permitting the creation of several similar objects.

Declarations and Statements

  1. The body of a program unit generally contains two parts: a declarative part, which defines the logical entities to be used in the program unit, and a sequence of statements, which defines the execution of the program unit.
  2. The declarative part associates names with declared entities. For example, a name may denote a type, a constant, a variable, or an exception. A declarative part also introduces the names and parameters of other nested subprograms, packages, task units, protected units, and generic units to be used in the program unit.
  3. The sequence of statements describes a sequence of actions that are to be performed. The statements are executed in succession (unless a transfer of control causes execution to continue from another place).
  4. An assignment statement changes the value of a variable. A procedure call invokes execution of a procedure after associating any actual parameters provided at the call with the corresponding formal parameters.
  5. Case statements and if statements allow the selection of an enclosed sequence of statements based on the value of an expression or on the value of a condition.
  6. The loop statement provides the basic iterative mechanism in the language. A loop statement specifies that a sequence of statements is to be executed repeatedly as directed by an iteration scheme, or until an exit statement is encountered.
  7. A block statement comprises a sequence of statements preceded by the declaration of local entities used by the statements.
  8. Certain statements are associated with concurrent execution. A delay statement delays the execution of a task for a specified duration or until a specified time. An entry call statement is written as a procedure call statement; it requests an operation on a task or on a protected object, blocking the caller until the operation can be performed. A called task may accept an entry call by executing a corresponding accept statement, which specifies the actions then to be performed as part of the rendezvous with the calling task. An entry call on a protected object is processed when the corresponding entry barrier evaluates to true, whereupon the body of the entry is executed. The requeue statement permits the provision of a service as a number of related activities with preference control. One form of the select statement allows a selective wait for one of several alternative rendezvous. Other forms of the select statement allow conditional or timed entry calls and the asynchronous transfer of control in response to some triggering event.
  9. Execution of a program unit may encounter error situations in which normal program execution cannot continue. For example, an arithmetic computation may exceed the maximum allowed value of a number, or an attempt may be made to access an array component by using an incorrect index value. To deal with such error situations, the statements of a program unit can be textually followed by exception handlers that specify the actions to be taken when the error situation arises. Exceptions can be raised explicitly by a raise statement.

Data Types

  1. Every object in the language has a type, which characterizes a set of values and a set of applicable operations. The main classes of types are elementary types (comprising enumeration, numeric, and access types) and composite types (including array and record types).
  2. An enumeration type defines an ordered set of distinct enumeration literals, for example a list of states or an alphabet of characters. The enumeration types Boolean, Character, and Wide_Character are predefined.
  3. Numeric types provide a means of performing exact or approximate numerical computations. Exact computations use integer types, which denote sets of consecutive integers. Approximate computations use either fixed point types, with absolute bounds on the error, or floating point types, with relative bounds on the error. The numeric types Integer, Float, and Duration are predefined.
  4. Composite types allow definitions of structured objects with related components. The composite types in the language include arrays and records. An array is an object with indexed components of the same type. A record is an object with named components of possibly different types. Task and protected types are also forms of composite types. The array types String and Wide_String are predefined.
  5. Record, task, and protected types may have special components called discriminants which parameterize the type. Variant record structures that depend on the values of discriminants can be defined within a record type.
  6. Access types allow the construction of linked data structures. A value of an access type represents a reference to an object declared as aliased or to an object created by the evaluation of an allocator. Several variables of an access type may designate the same object, and components of one object may designate the same or other objects. Both the elements in such linked data structures and their relation to other elements can be altered during program execution. Access types also permit references to subprograms to be stored, passed as parameters, and ultimately dereferenced as part of an indirect call.
  7. Private types permit restricted views of a type. A private type can be defined in a package so that only the logically necessary properties are made visible to the users of the type. The full structural details that are externally irrelevant are then only available within the package and any child units.
  8. From any type a new type may be defined by derivation. A type, together with its derivatives (both direct and indirect) form a derivation class. Class-wide operations may be defined that accept as a parameter an operand of any type in a derivation class. For record and private types, the derivatives may be extensions of the parent type. Types that support these object-oriented capabilities of class-wide operations and type extension must be tagged, so that the specific type of an operand within a derivation class can be identified at run time. When an operation of a tagged type is applied to an operand whose specific type is not known until run time, implicit dispatching is performed based on the tag of the operand.
  9. The concept of a type is further refined by the concept of a subtype, whereby a user can constrain the set of allowed values of a type. Subtypes can be used to define subranges of scalar types, arrays with a limited set of index values, and records and private types with particular discriminant values.

Other Facilities

  1. Representation clauses can be used to specify the mapping between types and features of an underlying machine. For example, the user can specify that objects of a given type must be represented with a given number of bits, or that the components of a record are to be represented using a given storage layout. Other features allow the controlled use of low level, nonportable, or implementation-dependent aspects, including the direct insertion of machine code.
  2. The predefined environment of the language provides for input-output and other capabilities (such as string manipulation and random number generation) by means of standard library packages. Input-output is supported for values of user-defined as well as of predefined types. Standard means of representing values in display form are also provided. Other standard library packages are defined in annexes of the standard to support systems with specialized requirements.
  3. Finally, the language provides a powerful means of parameterization of program units, called generic program units. The generic parameters can be types and subprograms (as well as objects and packages) and so allow general algorithms and data structures to be defined that are applicable to all types of a given class.

Language Changes

  1. This International Standard replaces the first edition of 1987. In this edition, the following major language changes have been incorporated:
    1. Support for standard 8-bit and 16-bit character sets. See section Lexical Elements, section Character Types, section String Types, section The Package Standard, section Character Handling, and section String Handling.
    2. Object-oriented programming with run-time polymorphism. See the discussions of classes, derived types, tagged types, record extensions, and private extensions in clauses section Derived Types and Classes, section Tagged Types and Type Extensions, and section Private Types and Private Extensions. See also the new forms of generic formal parameters that are allowed by section Formal Private and Derived Types, and section Formal Packages.
    3. Access types have been extended to allow an access value to designate a subprogram or an object declared by an object declaration (as opposed to just a heap-allocated object) (see section Access Types).
    4. Efficient data-oriented synchronization is provided via protected types. See section Tasks and Synchronization.
    5. The library units of a library may be organized into a hierarchy of parent and child units (see section Program Structure and Compilation Issues).
    6. Additional support has been added for interfacing to other languages. See section Interface to Other Languages (normative).
    7. The Specialized Needs Annexes have been added to provide specific support for certain application areas:
      1. Annex C, "Systems Programming"
      2. Annex D, "Real-Time Systems"
      3. Annex E, "Distributed Systems"
      4. Annex F, "Information Systems"
      5. Annex G, "Numerics"
      6. Annex H, "Safety and Security"

Instructions for Comment Submission

  1. Informal comments on this International Standard may be sent via e-mail to ada-comment@sw-eng.falls-church.va.us. If appropriate, the Project Editor will initiate the defect correction procedure.
  2. Comments should use the following format: 
  3. !topic Title summarizing comment
!reference RM95-ss.ss(pp)
!from Author Name yy-mm-dd
!keywords keywords related to topic
!discussion

text of discussion
  4. where ss.ss is the section, clause or subclause number, pp is the paragraph number where applicable, and yy-mm-dd is the date the comment was sent. The date is optional, as is the !keywords line.
  5. Multiple comments per e-mail message are acceptable. Please use a descriptive "Subject" in your e-mail message.
  6. When correcting typographical errors or making minor wording suggestions, please put the correction directly as the topic of the comment; use square brackets [ ] to indicate text to be omitted and curly braces { } to indicate text to be added, and provide enough context to make the nature of the suggestion self-evident or put additional information in the body of the comment, for example: 
  7. !topic [c]{C}haracter
!topic it[']s meaning is not defined
  8. Formal requests for interpretations and for reporting defects in this International Standard may be made in accordance with the ISO/IEC JTC1 Directives and the ISO/IEC JTC1/SC22 policy for interpretations. National Bodies may submit a Defect Report to ISO/IEC JTC1/SC22 for resolution under the JTC1 procedures. A response will be provided and, if appropriate, a Technical Corrigendum will be issued in accordance with the procedures.

Acknowledgements

  1. This International Standard was prepared by the Ada 9X Mapping/Revision Team based at Intermetrics, Inc., which has included: W. Carlson, Program Manager; T. Taft, Technical Director; J. Barnes (consultant); B. Brosgol (consultant); R. Duff (Oak Tree Software); M. Edwards; C. Garrity; R. Hilliard; O. Pazy (consultant); D. Rosenfeld; L. Shafer; W. White; M. Woodger.
  2. The following consultants to the Ada 9X Project contributed to the Specialized Needs Annexes: T. Baker (Real-Time/Systems Programming -- SEI, FSU); K. Dritz (Numerics -- Argonne National Laboratory); A. Gargaro (Distributed Systems -- Computer Sciences); J. Goodenough (Real-Time/Systems Programming -- SEI); J. McHugh (Secure Systems -- consultant); B. Wichmann (Safety-Critical Systems -- NPL: UK).
  3. This work was regularly reviewed by the Ada 9X Distinguished Reviewers and the members of the Ada 9X Rapporteur Group (XRG): E. Ploedereder, Chairman of DRs and XRG (University of Stuttgart: Germany); B. Bardin (Hughes); J. Barnes (consultant: UK); B. Brett (DEC); B. Brosgol (consultant); R. Brukardt (RR Software); N. Cohen (IBM); R. Dewar (NYU); G. Dismukes (TeleSoft); A. Evans (consultant); A. Gargaro (Computer Sciences); M. Gerhardt (ESL); J. Goodenough (SEI); S. Heilbrunner (University of Salzburg: Austria); P. Hilfinger (UC/Berkeley); B. Kaellberg (CelsiusTech: Sweden); M. Kamrad II (Unisys); J. van Katwijk (Delft University of Technology: The Netherlands); V. Kaufman (Russia); P. Kruchten (Rational); R. Landwehr (CCI: Germany); C. Lester (Portsmouth Polytechnic: UK); L. Mansson (TELIA Research: Sweden); S. Michell (Multiprocessor Toolsmiths: Canada); M. Mills (US Air Force); D. Pogge (US Navy); K. Power (Boeing); O. Roubine (Verdix: France); A. Strohmeier (Swiss Fed Inst of Technology: Switzerland); W. Taylor (consultant: UK); J. Tokar (Tartan); E. Vasilescu (Grumman); J. Vladik (Prospeks s.r.o.: Czech Republic); S. Van Vlierberghe (OFFIS: Belgium).
  4. Other valuable feedback influencing the revision process was provided by the Ada 9X Language Precision Team (Odyssey Research Associates), the Ada 9X User/Implementer Teams (AETECH, Tartan, TeleSoft), the Ada 9X Implementation Analysis Team (New York University) and the Ada community-at-large.
  5. Special thanks go to R. Mathis, Convenor of ISO/IEC JTC1/SC22 Working Group 9.
  6. The Ada 9X Project was sponsored by the Ada Joint Program Office. Christine M. Anderson at the Air Force Phillips Laboratory (Kirtland AFB, NM) was the project manager. Changes
  7. The International Standard is the same as this version of the Reference Manual, except:
    1. This list of Changes is not included in the International Standard.
    2. The "Acknowledgements" page is not included in the International Standard.
    3. The text in the running headers and footers on each page is slightly different in the International Standard.
    4. The title page(s) are different in the International Standard.
    5. This document is formatted for 8.5-by-11-inch paper, whereas the International Standard is formatted for A4 paper (210-by-297mm); thus, the page breaks are in different places.

General

  1. Ada is a programming language designed to support the construction of long-lived, highly reliable software systems. The language includes facilities to define packages of related types, objects, and operations. The packages may be parameterized and the types may be extended to support the construction of libraries of reusable, adaptable software components. The operations may be implemented as subprograms using conventional sequential control structures, or as entries that include synchronization of concurrent threads of control as part of their invocation. The language treats modularity in the physical sense as well, with a facility to support separate compilation.
  2. The language includes a complete facility for the support of real-time, concurrent programming. Errors can be signaled as exceptions and handled explicitly. The language also covers systems programming; this requires precise control over the representation of data and access to system-dependent properties. Finally, a predefined environment of standard packages is provided, including facilities for, among others, input-output, string manipulation, numeric elementary functions, and random number generation.

Scope

  1. This International Standard specifies the form and meaning of programs written in Ada. Its purpose is to promote the portability of Ada programs to a variety of data processing systems.

Extent

  1. This International Standard specifies:
    1. The form of a program written in Ada;
    2. The effect of translating and executing such a program;
    3. The manner in which program units may be combined to form Ada programs;
    4. The language-defined library units that a conforming implementation is required to supply;
    5. The permissible variations within the standard, and the manner in which they are to be documented;
    6. Those violations of the standard that a conforming implementation is required to detect, and the effect of attempting to translate or execute a program containing such violations;
    7. Those violations of the standard that a conforming implementation is not required to detect.
  1. This International Standard does not specify:
    1. The means whereby a program written in Ada is transformed into object code executable by a processor;
    2. The means whereby translation or execution of programs is invoked and the executing units are controlled;
    3. The size or speed of the object code, or the relative execution speed of different language constructs; The form or contents of any listings produced by implementations; in particular, the form or contents of error or warning messages;
    4. The effect of unspecified execution.
    5. The size of a program or program unit that will exceed the capacity of a particular conforming implementation.

Structure

  1. This International Standard contains thirteen sections, fourteen annexes, and an index.
  2. The core of the Ada language consists of:
    1. Sections 1 through 13
    2. Annex A, "Predefined Language Environment"
    3. Annex B, "Interface to Other Languages"
    4. Annex J, "Obsolescent Features"
  1. The following Specialized Needs Annexes define features that are needed by certain application areas:
    1. Annex C, "Systems Programming"
    2. Annex D, "Real-Time Systems"
    3. Annex E, "Distributed Systems"
    4. Annex F, "Information Systems"
    5. Annex G, "Numerics"
    6. Annex H, "Safety and Security"
  1. The core language and the Specialized Needs Annexes are normative, except that the material in each of the items listed below is informative:
    1. Text under a NOTES or Examples heading.
    2. Each clause or subclause whose title starts with the word "Example" or "Examples".
  1. All implementations shall conform to the core language. In addition, an implementation may conform separately to one or more Specialized Needs Annexes.
  2. The following Annexes are informative:
    1. Annex K, "Language-Defined Attributes"
    2. Annex L, "Language-Defined Pragmas"
    3. Annex M, "Implementation-Defined Characteristics"
    4. Annex N, "Glossary"
    5. Annex P, "Syntax Summary"
  1. Each section is divided into clauses and subclauses that have a common structure. Each section, clause, and subclause first introduces its subject. After the introductory text, text is labeled with the following headings:

    Syntax

  2. Syntax rules (indented).

    Name Resolution Rules

  3. Compile-time rules that are used in name resolution, including overload resolution.

    Legality Rules

  4. Rules that are enforced at compile time. A construct is legal if it obeys all of the Legality Rules.

    Static Semantics

  5. A definition of the compile-time effect of each construct.

    Post-Compilation Rules

  6. Rules that are enforced before running a partition. A partition is legal if its compilation units are legal and it obeys all of the Post-Compilation Rules.

    Dynamic Semantics

  7. A definition of the run-time effect of each construct.

    Bounded (Run-Time) Errors

  8. Situations that result in bounded (run-time) errors, see section Classification of Errors.

    Erroneous Execution

  9. Situations that result in erroneous execution, see section Classification of Errors.

    Implementation Requirements

  10. Additional requirements for conforming implementations.

    Documentation Requirements

  11. Documentation requirements for conforming implementations.

    Metrics

  12. Metrics that are specified for the time/space properties of the execution of certain language constructs.

    Implementation Permissions

  13. Additional permissions given to the implementer.

    Implementation Advice

  14. Optional advice given to the implementer. The word "should" is used to indicate that the advice is a recommendation, not a requirement. It is implementation defined whether or not a given recommendation is obeyed. NOTES
  15. (1) Notes emphasize consequences of the rules described in the (sub)clause or elsewhere. This material is informative.

    Examples

  16. Examples illustrate the possible forms of the constructs described. This material is informative.

Conformity of an Implementation with the Standard

Implementation Requirements

  1. A conforming implementation shall:
    1. Translate and correctly execute legal programs written in Ada, provided that they are not so large as to exceed the capacity of the implementation;
    2. Identify all programs or program units that are so large as to exceed the capacity of the implementation (or raise an appropriate exception at run time);
    3. Identify all programs or program units that contain errors whose detection is required by this International Standard;
    4. Supply all language-defined library units required by this International Standard;
    5. Contain no variations except those explicitly permitted by this International Standard, or those that are impossible or impractical to avoid given the implementation's execution environment;
    6. Specify all such variations in the manner prescribed by this International Standard.
  1. The external effect of the execution of an Ada program is defined in terms of its interactions with its external environment. The following are defined as external interactions:
    1. Any interaction with an external file, see section External Files and File Objects,
    2. The execution of certain code_statements, see section Machine Code Insertions, which code_statements cause external interactions is implementation defined.
    3. Any call on an imported subprogram, see section Interface to Other Languages (normative), including any parameters passed to it;
    4. Any result returned or exception propagated from a main subprogram (see section Program Execution) or an exported subprogram, see section Interface to Other Languages (normative), to an external caller;
    5. Any read or update of an atomic or volatile object, see section Shared Variable Control,
    6. The values of imported and exported objects, see section Interface to Other Languages (normative), at the time of any other interaction with the external environment.
  1. A conforming implementation of this International Standard shall produce for the execution of a given Ada program a set of interactions with the external environment whose order and timing are consistent with the definitions and requirements of this International Standard for the semantics of the given program.
  2. An implementation that conforms to this Standard shall support each capability required by the core language as specified. In addition, an implementation that conforms to this Standard may conform to one or more Specialized Needs Annexes (or to none). Conformance to a Specialized Needs Annex means that each capability required by the Annex is provided as specified.
  3. An implementation conforming to this International Standard may provide additional attributes, library units, and pragmas. However, it shall not provide any attribute, library unit, or pragma having the same name as an attribute, library unit, or pragma (respectively) specified in a Specialized Needs Annex unless the provided construct is either as specified in the Specialized Needs Annex or is more limited in capability than that required by the Annex. A program that attempts to use an unsupported capability of an Annex shall either be identified by the implementation before run time or shall raise an exception at run time.

    Documentation Requirements

  4. Certain aspects of the semantics are defined to be either implementation defined or unspecified. In such cases, the set of possible effects is specified, and the implementation may choose any effect in the set. Implementations shall document their behavior in implementation-defined situations, but documentation is not required for unspecified situations. The implementation-defined characteristics are summarized in Annex M.
  5. The implementation may choose to document implementation-defined behavior either by documenting what happens in general, or by providing some mechanism for the user to determine what happens in a particular case.

    Implementation Advice

  6. If an implementation detects the use of an unsupported Specialized Needs Annex feature at run time, it should raise Program_Error if feasible.
  7. If an implementation wishes to provide implementation-defined extensions to the functionality of a language-defined library unit, it should normally do so by adding children to the library unit. NOTES
  8. (2) The above requirements imply that an implementation conforming to this Standard may support some of the capabilities required by a Specialized Needs Annex without supporting all required capabilities.

Method of Description and Syntax Notation

  1. The form of an Ada program is described by means of a context-free syntax together with context-dependent requirements expressed by narrative rules.
  2. The meaning of Ada programs is described by means of narrative rules defining both the effects of each construct and the composition rules for constructs.
  3. The context-free syntax of the language is described using a simple variant of Backus-Naur Form. In particular:
    1. Lower case words in a sans-serif font, some containing embedded underlines, are used to denote syntactic categories, for example: 
    2. case_statement
    3. Boldface words are used to denote reserved words, for example: 
    4. array
    5. Square brackets enclose optional items. Thus the two following rules are equivalent. 
    6. return_statement ::= return [expression];
return_statement ::= return; | return expression;
    7. Curly brackets enclose a repeated item. The item may appear zero or more times; the repetitions occur from left to right as with an equivalent left-recursive rule. Thus the two following rules are equivalent. 
    8. term ::= factor {multiplying_operator factor}
term ::= factor | term multiplying_operator factor
    9. A vertical line separates alternative items unless it occurs immediately after an opening curly bracket, in which case it stands for itself: 
    10. constraint ::= scalar_constraint | composite_constraint
discrete_choice_list ::= discrete_choice {| discrete_choice}
    11. If the name of any syntactic category starts with an italicized part, it is equivalent to the category name without the italicized part. The italicized part is intended to convey some semantic information. For example subtype_name and task_name are both equivalent to name alone.
  1. A syntactic category is a nonterminal in the grammar defined in BNF under "Syntax." Names of syntactic categories are set in a different font, like_this.
  2. A construct is a piece of text (explicit or implicit) that is an instance of a syntactic category defined under "Syntax."
  3. A constituent of a construct is the construct itself, or any construct appearing within it.
  4. Whenever the run-time semantics defines certain actions to happen in an arbitrary order, this means that the implementation shall arrange for these actions to occur in a way that is equivalent to some sequential order, following the rules that result from that sequential order. When evaluations are defined to happen in an arbitrary order, with conversion of the results to some subtypes, or with some run-time checks, the evaluations, conversions, and checks may be arbitrarily interspersed, so long as each expression is evaluated before converting or checking its value. Note that the effect of a program can depend on the order chosen by the implementation. This can happen, for example, if two actual parameters of a given call have side effects. NOTES
  5. (3) The syntax rules describing structured constructs are presented in a form that corresponds to the recommended paragraphing. For example, an if_statement is defined as: 
  6. if_statement ::=
   if condition then
      sequence_of_statements
   {elsif condition then
      sequence_of_statements}
   [else
      sequence_of_statements]
   end if;
  7. (4) The line breaks and indentation in the syntax rules indicate the recommended line breaks and indentation in the corresponding constructs. The preferred places for other line breaks are after semicolons.

Classification of Errors

Implementation Requirements

  1. The language definition classifies errors into several different categories:
    1. Errors that are required to be detected prior to run time by every Ada implementation;
      1. These errors correspond to any violation of a rule given in this International Standard, other than those listed below. In particular, violation of any rule that uses the terms shall, allowed, permitted, legal, or illegal belongs to this category. Any program that contains such an error is not a legal Ada program; on the other hand, the fact that a program is legal does not mean, per se, that the program is free from other forms of error.
      2. The rules are further classified as either compile time rules, or post compilation rules, depending on whether a violation has to be detected at the time a compilation unit is submitted to the compiler, or may be postponed until the time a compilation unit is incorporated into a partition of a program.
    1. Errors that are required to be detected at run time by the execution of an Ada program;
      1. The corresponding error situations are associated with the names of the predefined exceptions. Every Ada compiler is required to generate code that raises the corresponding exception if such an error situation arises during program execution. If such an error situation is certain to arise in every execution of a construct, then an implementation is allowed (although not required) to report this fact at compilation time.
    1. Bounded errors;
      1. The language rules define certain kinds of errors that need not be detected either prior to or during run time, but if not detected, the range of possible effects shall be bounded. The errors of this category are called bounded errors. The possible effects of a given bounded error are specified for each such error, but in any case one possible effect of a bounded error is the raising of the exception Program_Error.
    1. Erroneous execution.
      1. In addition to bounded errors, the language rules define certain kinds of errors as leading to erroneous execution. Like bounded errors, the implementation need not detect such errors either prior to or during run time. Unlike bounded errors, there is no language-specified bound on the possible effect of erroneous execution; the effect is in general not predictable.

Implementation Permissions

  1. An implementation may provide nonstandard modes of operation. Typically these modes would be selected by a pragma or by a command line switch when the compiler is invoked. When operating in a nonstandard mode, the implementation may reject compilation_units that do not conform to additional requirements associated with the mode, such as an excessive number of warnings or violation of coding style guidelines. Similarly, in a nonstandard mode, the implementation may apply special optimizations or alternative algorithms that are only meaningful for programs that satisfy certain criteria specified by the implementation. In any case, an implementation shall support a standard mode that conforms to the requirements of this International Standard; in particular, in the standard mode, all legal compilation_units shall be accepted.

    Implementation Advice

  2. If an implementation detects a bounded error or erroneous execution, it should raise Program_Error.

Normative References

  1. The following standards contain provisions which, through reference in this text, constitute provisions of this International Standard. At the time of publication, the editions indicated were valid. All standards are subject to revision, and parties to agreements based on this International Standard are encouraged to investigate the possibility of applying the most recent editions of the standards indicated below. Members of IEC and ISO maintain registers of currently valid International Standards.
  2. ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for information interchange.
  3. ISO/IEC 1539:1991, Information technology -- Programming languages -- FORTRAN.
  4. ISO 1989:1985, Programming languages -- COBOL.
  5. ISO/IEC 6429:1992, Information technology -- Control functions for coded graphic character sets.
  6. ISO/IEC 8859-1:1987, Information processing -- 8-bit single-byte coded character sets -- Part 1: Latin alphabet No. 1.
  7. ISO/IEC 9899:1990, Programming languages -- C.
  8. ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.

Definitions

  1. Terms are defined throughout this International Standard, indicated by italic type. Terms explicitly defined in this International Standard are not to be presumed to refer implicitly to similar terms defined elsewhere. Terms not defined in this International Standard are to be interpreted according to the Webster's Third New International Dictionary of the English Language. Informal descriptions of some terms are also given in Annex N, "Glossary".

Lexical Elements

  1. The text of a program consists of the texts of one or more compilations. The text of a compilation is a sequence of lexical elements, each composed of characters; the rules of composition are given in this section. Pragmas, which provide certain information for the compiler, are also described in this section.

Character Set

  1. The only characters allowed outside of comments are the graphic_characters and format_effectors.

    Syntax 

  2. character ::=
     graphic_character
   | format_effector
   | other_control_function

  3. graphic_character ::=
     identifier_letter
   | digit
   | space_character
   | special_character

    Static Semantics

  4. The character repertoire for the text of an Ada program consists of the collection of characters called the Basic Multilingual Plane (BMP) of the ISO 10646 Universal Multiple-Octet Coded Character Set, plus a set of format_ effectors and, in comments only, a set of other_control_functions; the coded representation for these characters is implementation defined (it need not be a representation defined within ISO-10646-1).
  5. The description of the language definition in this International Standard uses the graphic symbols defined for Row 00: Basic Latin and Row 00: Latin-1 Supplement of the ISO 10646 BMP; these correspond to the graphic symbols of ISO 8859-1 (Latin-1); no graphic symbols are used in this International Standard for characters outside of Row 00 of the BMP. The actual set of graphic symbols used by an implementation for the visual representation of the text of an Ada program is not specified.
  6. The categories of characters are defined as follows:
  7. identifier_letter 
    upper_case_identifier_letter | lower_case_identifier_letter
  8. upper_case_identifier_letter 
    Any character of Row 00 of ISO 10646 BMP whose name begins "Latin
Capital Letter".
  9. lower_case_identifier_letter 
    Any character of Row 00 of ISO 10646 BMP whose name begins
"Latin Small Letter".
  10. digit 
    One of the characters 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9.
  11. space_character 
    The character of ISO 10646 BMP named "Space".
  12. special_character 
    Any character of the ISO 10646 BMP that is not reserved for a
control function, and is not the space_character, an
identifier_letter, or a digit.
  13. format_effector 
    The control functions of ISO 6429 called character tabulation
(HT), line tabulation (VT), carriage return (CR), line feed (LF),
and form feed (FF).
  14. other_control_function 
    Any control function, other than a format_effector, that is
allowed in a comment; the set of other_control_functions allowed
in comments is implementation defined.
  15. The following names are used when referring to certain special_characters: 
    symbol   name                   symbol   name

  "      quotation mark           :      colon
  #      number sign              ;      semicolon
  &      ampersand                <      less-than sign
  '      apostrophe, tick         =      equals sign
  (      left parenthesis         >      greater-than sign
  )      right parenthesis        _      low line, underline
  *      asterisk, multiply       |      vertical line
  +      plus sign                [      left square bracket
  ,      comma                    ]      right square bracket
  -      hyphen-minus, minus      {      left curly bracket
  .      full stop, dot, point    }      right curly bracket
  /      solidus, divide

    Implementation Permissions

  16. In a nonstandard mode, the implementation may support a different character repertoire; in particular, the set of characters that are considered identifier_letters can be extended or changed to conform to local conventions. NOTES
  17. (1) Every code position of ISO 10646 BMP that is not reserved for a control function is defined to be a graphic_character by this International Standard. This includes all code positions other than 0000 - 001F, 007F - 009F, and FFFE - FFFF.
  18. (2) The language does not specify the source representation of programs.

Lexical Elements, Separators, and Delimiters

Static Semantics

  1. The text of a program consists of the texts of one or more compilations. The text of each compilation is a sequence of separate lexical elements. Each lexical element is formed from a sequence of characters, and is either a delimiter, an identifier, a reserved word, a numeric_literal, a character_ literal, a string_literal, or a comment. The meaning of a program depends only on the particular sequences of lexical elements that form its compilations, excluding comments.
  2. The text of a compilation is divided into lines. In general, the representation for an end of line is implementation defined. However, a sequence of one or more format_effectors other than character tabulation (HT) signifies at least one end of line.
  3. In some cases an explicit separator is required to separate adjacent lexical elements. A separator is any of a space character, a format effector, or the end of a line, as follows:
    1. A space character is a separator except within a comment, a string_literal, or a character_literal.
    2. Character tabulation (HT) is a separator except within a comment.
    3. The end of a line is always a separator.
  1. One or more separators are allowed between any two adjacent lexical elements, before the first of each compilation, or after the last. At least one separator is required between an identifier, a reserved word, or a numeric_literal and an adjacent identifier, reserved word, or numeric_literal.
  2. A delimiter is either one of the following special characters 
  3. &    '    (    )    *    +    ,    -
.    /    :    ;    <    =    >    |
  4. or one of the following compound delimiters each composed of two adjacent special characters 
  5. =>    ..    **    :=    /=    >=    <=    <<    >>    <>
  6. Each of the special characters listed for single character delimiters is a single delimiter except if this character is used as a character of a compound delimiter, or as a character of a comment, string_literal, character_literal, or numeric_literal.
  7. The following names are used when referring to compound delimiters: 
  8. delimiter     name

   =>                       arrow
   ..                       double dot
   **                       double star, exponentiate
   :=                       assignment (pronounced: "becomes")
   /=                       inequality (pronounced: "not equal")
   >=                       greater than or equal
   <=                       less than or equal
   <<                       left label bracket
   >>                       right label bracket
   <>                       box

    Implementation Requirements

  9. An implementation shall support lines of at least 200 characters in length, not counting any characters used to signify the end of a line. An implementation shall support lexical elements of at least 200 characters in length. The maximum supported line length and lexical element length are implementation defined.

Identifiers

  1. Identifiers are used as names.

    Syntax 

  2. identifier ::= identifier_letter {[underline] letter_or_digit}

  3. letter_or_digit ::= identifier_letter | digit
    1. An identifier shall not be a reserved word.

Static Semantics

  1. All characters of an identifier are significant, including any underline character. Identifiers differing only in the use of corresponding upper and lower case letters are considered the same.

    Implementation Permissions

  2. In a nonstandard mode, an implementation may support other upper/lower case equivalence rules for identifiers, to accommodate local conventions.

    Examples

  3. Examples of identifiers: 
  4. Count      X    Get_Symbol   Ethelyn   Marion

Snobol_4   X1   Page_Count    Store_Next_Item

Numeric Literals

  1. There are two kinds of numeric_literals, real literals and integer literals. A real literal is a numeric_literal that includes a point; an integer literal is a numeric_literal without a point.

    Syntax 

  2. numeric_literal ::= decimal_literal | based_literal
    NOTES
  3. (3) The type of an integer literal is universal_integer. The type of a real literal is universal_real.

Decimal Literals

  1. A decimal_literal is a numeric_literal in the conventional decimal notation (that is, the base is ten).

    Syntax 

  2. decimal_literal ::= numeral [.numeral] [exponent]

  3. numeral ::= digit {[underline] digit}

  4. exponent ::= E [+] numeral | E - numeral
    1. An exponent for an integer literal shall not have a minus sign.

Static Semantics

  1. An underline character in a numeric_literal does not affect its meaning. The letter E of an exponent can be written either in lower case or in upper case, with the same meaning.
  2. An exponent indicates the power of ten by which the value of the decimal_literal without the exponent is to be multiplied to obtain the value of the decimal_literal with the exponent.

    Examples

  3. Examples of decimal literals: 
  4. 12        0      1E6    123_456           --  integer literals

12.0      0.0    0.456  3.14159_26        --  real literals

Based Literals

  1. A based_literal is a numeric_literal expressed in a form that specifies the base explicitly.

    Syntax 

  2. based_literal ::= base # based_numeral [.based_numeral] # [exponent]

  3. base ::= numeral

  4. based_numeral ::=
   extended_digit {[underline] extended_digit}

  5. extended_digit ::= digit | A | B | C | D | E | F

    Legality Rules

  6. The base (the numeric value of the decimal numeral preceding the first #) shall be at least two and at most sixteen. The extended_digits A through F represent the digits ten through fifteen, respectively. The value of each extended_digit of a based_literal shall be less than the base.

    Static Semantics

  7. The conventional meaning of based notation is assumed. An exponent indicates the power of the base by which the value of the based_literal without the exponent is to be multiplied to obtain the value of the based_literal with the exponent. The base and the exponent, if any, are in decimal notation.
  8. The extended_digits A through F can be written either in lower case or in upper case, with the same meaning.

    Examples

  9. Examples of based literals: 
  10. 2#1111_1111#   16#FF#       016#0ff#
--  integer literals of value 255

16#E#E1        2#1110_0000#
--  integer literals of value 224

16#F.FF#E+2    2#1.1111_1111_1110#E11
--  real literals of value 4095.0

Character Literals

  1. A character_literal is formed by enclosing a graphic character between two apostrophe characters.

    Syntax 

  2. character_literal ::= 'graphic_character'
    NOTES
  3. (4) A character_literal is an enumeration literal of a character type. (see section Character Types).

    Examples

  4. Examples of character literals: 
  5. 'A'     '*'     "'     ' '

String Literals

  1. A string_literal is formed by a sequence of graphic characters (possibly none) enclosed between two quotation marks used as string brackets. They are used to represent operator_symbols (see section Subprogram Declarations) values of a string type (see section Literals) and array subaggregates (see section Array Aggregates).

    Syntax 

  2. string_literal ::= "{string_element}"

  3. string_element ::= "" | non_quotation_mark_graphic_character
    1. A string_element is either a pair of quotation marks (""), or a single graphic_character other than a quotation mark.

Static Semantics

  1. The sequence of characters of a string_literal is formed from the sequence of string_elements between the bracketing quotation marks, in the given order, with a string_element that is "" becoming a single quotation mark in the sequence of characters, and any other string_element being reproduced in the sequence.
  2. A null string literal is a string_literal with no string_elements between the quotation marks. NOTES
  3. (5) An end of line cannot appear in a string_literal.

    Examples

  4. Examples of string literals: 
  5. 
"Message of the day:"

""                           --  a null string literal
" "   "A"   """"             --  three string literals of length 1

"Characters such as $, %, and } are allowed in string literals"

Comments

  1. A comment starts with two adjacent hyphens and extends up to the end of the line.

    Syntax 

  2. comment ::= --{non_end_of_line_character}
    1. A comment may appear on any line of a program.

Static Semantics

  1. The presence or absence of comments has no influence on whether a program is legal or illegal. Furthermore, comments do not influence the meaning of a program; their sole purpose is the enlightenment of the human reader.

    Examples

  2. Examples of comments: 
  3. --  the last sentence above echoes the Algol 68 report

end;  --  processing of Line is complete

--  a long comment may be split onto
--  two or more consecutive lines

----------------  the first two hyphens start the comment

Pragmas

  1. A pragma is a compiler directive. There are language-defined pragmas that give instructions for optimization, listing control, etc. An implementation may support additional (implementation-defined) pragmas.

    Syntax 

  2. pragma ::=
   pragma identifier [(pragma_argument_association
      {, pragma_argument_association})];

  3. pragma_argument_association ::=
     [pragma_argument_identifier =>] name
   | [pragma_argument_identifier =>] expression
    1. In a pragma, any pragma_argument_associations without a pragma_argument_identifier shall precede any associations with a pragma_argument_identifier.
    2. Pragmas are only allowed at the following places in a program:
      1. After a semicolon delimiter, but not within a formal_part or discriminant_part.
      2. At any place where the syntax rules allow a construct defined by a syntactic category whose name ends with "declaration", "statement", "clause", or "alternative", or one of the syntactic categories variant or exception_handler; but not in place of such a construct. Also at any place where a compilation_unit would be allowed.
    1. Additional syntax rules and placement restrictions exist for specific pragmas.
  1. The name of a pragma is the identifier following the reserved word pragma. The name or expression of a pragma_argument_association is a pragma argument.
  2. An identifier specific to a pragma is an identifier that is used in a pragma argument with special meaning for that pragma.

    Static Semantics

  3. If an implementation does not recognize the name of a pragma, then it has no effect on the semantics of the program. Inside such a pragma, the only rules that apply are the Syntax Rules.

    Dynamic Semantics

  4. Any pragma that appears at the place of an executable construct is executed. Unless otherwise specified for a particular pragma, this execution consists of the evaluation of each evaluable pragma argument in an arbitrary order.

    Implementation Requirements

  5. The implementation shall give a warning message for an unrecognized pragma name.

    Implementation Permissions

  6. An implementation may provide implementation-defined pragmas; the name of an implementation-defined pragma shall differ from those of the language-defined pragmas.
  7. An implementation may ignore an unrecognized pragma even if it violates some of the Syntax Rules, if detecting the syntax error is too complex.

    Implementation Advice

  8. Normally, implementation-defined pragmas should have no semantic effect for error-free programs; that is, if the implementation-defined pragmas are removed from a working program, the program should still be legal, and should still have the same semantics.
  9. Normally, an implementation should not define pragmas that can make an illegal program legal, except as follows:
    1. A pragma used to complete a declaration, such as a pragma Import;
    2. A pragma used to configure the environment by adding, removing, or replacing library_items.

Syntax

  1. The forms of List, Page, and Optimize pragmas are as follows:
  2. pragma List(identifier);
  3. pragma Page;
  4. pragma Optimize(identifier);
    1. Other pragmas are defined throughout this International Standard, and are summarized in Annex L.

Static Semantics

  1. A pragma List takes one of the identifiers On or Off as the single argument. This pragma is allowed anywhere a pragma is allowed. It specifies that listing of the compilation is to be continued or suspended until a List pragma with the opposite argument is given within the same compilation. The pragma itself is always listed if the compiler is producing a listing.
  2. A pragma Page is allowed anywhere a pragma is allowed. It specifies that the program text which follows the pragma should start on a new page (if the compiler is currently producing a listing).
  3. A pragma Optimize takes one of the identifiers Time, Space, or Off as the single argument. This pragma is allowed anywhere a pragma is allowed, and it applies until the end of the immediately enclosing declarative region, or for a pragma at the place of a compilation_unit, to the end of the compilation. It gives advice to the implementation as to whether time or space is the primary optimization criterion, or that optional optimizations should be turned off. It is implementation defined how this advice is followed.

    Examples

  4. Examples of pragmas: 
  5. pragma List(Off);         -- turn off listing generation
pragma Optimize(Off);     -- turn off optional optimizations
pragma Inline(Set_Mask);  -- generate code for Set_Mask inline

pragma Suppress(Range_Check, On => Index);
-- turn off range checking on Index

Reserved Words

Syntax

    1. The following are the reserved words (ignoring upper/lower case distinctions): 
      abort          else           new            return
abs            elsif          not            reverse
abstract       end            null
accept         entry                         select
access         exception                     separate
aliased        exit           of             subtype
all                           or
and            for            others         tagged
array          function       out            task
at                                           terminate
               generic        package        then
begin          goto           pragma         type
body                          private
               if             procedure
case           in             protected      until
constant       is                            use
                              raise
declare                       range          when
delay          limited        record         while
delta          loop           rem            with
digits                        renames
do             mod            requeue        xor
    NOTES
  1. (6) The reserved words appear in lower case boldface in this International Standard, except when used in the designator of an attribute (see section Attributes). Lower case boldface is also used for a reserved word in a string_literal used as an operator_symbol. This is merely a convention -- programs may be written in whatever typeface is desired and available.

Declarations and Types

  1. This section describes the types in the language and the rules for declaring constants, variables, and named numbers.

Declarations

  1. The language defines several kinds of named entities that are declared by declarations. The entity's name is defined by the declaration, usually by a defining_identifier, but sometimes by a defining_character_literal or defining_operator_symbol.
  2. There are several forms of declaration. A basic_declaration is a form of declaration defined as follows.

    Syntax 

  3. basic_declaration ::=
     type_declaration         | subtype_declaration
   | object_declaration       | number_declaration
   | subprogram_declaration   | abstract_subprogram_declaration
   | package_declaration      | renaming_declaration
   | exception_declaration    | generic_declaration
   | generic_instantiation

  4. defining_identifier ::= identifier

    Static Semantics

  5. A declaration is a language construct that associates a name with (a view of) an entity. A declaration may appear explicitly in the program text (an explicit declaration), or may be supposed to occur at a given place in the text as a consequence of the semantics of another construct (an implicit declaration).
  6. Each of the following is defined to be a declaration: any basic_declaration; an enumeration_literal_specification; a discriminant_specification; a component_declaration; a loop_parameter_specification; a parameter_specification; a subprogram_body; an entry_declaration; an entry_index_specification; a choice_parameter_specification; a generic_formal_parameter_declaration.
  7. All declarations contain a definition for a view of an entity. A view consists of an identification of the entity (the entity of the view), plus view-specific characteristics that affect the use of the entity through that view (such as mode of access to an object, formal parameter names and defaults for a subprogram, or visibility to components of a type). In most cases, a declaration also contains the definition for the entity itself (a renaming_declaration is an example of a declaration that does not define a new entity, but instead defines a view of an existing entity, see section Renaming Declarations.)
  8. For each declaration, the language rules define a certain region of text called the scope of the declaration (see section Scope of Declarations). Most declarations associate an identifier with a declared entity. Within its scope, and only there, there are places where it is possible to use the identifier to refer to the declaration, the view it defines, and the associated entity; these places are defined by the visibility rules (see section Visibility). At such places the identifier is said to be a name of the entity (the direct_name or selector_name); the name is said to denote the declaration, the view, and the associated entity (see section The Context of Overload Resolution). The declaration is said to declare the name, the view, and in most cases, the entity itself.
  9. As an alternative to an identifier, an enumeration literal can be declared with a character_literal as its name (see section Enumeration Types) and a function can be declared with an operator_symbol as its name (see section Subprogram Declarations).
  10. The syntax rules use the terms defining_identifier, defining_character_literal, and defining_operator_symbol for the defining occurrence of a name; these are collectively called defining names. The terms direct_name and selector_name are used for usage occurrences of identifiers, character_literals, and operator_symbols. These are collectively called usage names.

    Dynamic Semantics

  11. The process by which a construct achieves its run-time effect is called execution. This process is also called elaboration for declarations and evaluation for expressions. One of the terms execution, elaboration, or evaluation is defined by this International Standard for each construct that has a run-time effect. NOTES
  12. (1) At compile time, the declaration of an entity declares the entity. At run time, the elaboration of the declaration creates the entity.

Types and Subtypes

Static Semantics

  1. A type is characterized by a set of values, and a set of primitive operations which implement the fundamental aspects of its semantics. An object of a given type is a run-time entity that contains (has) a value of the type.
  2. Types are grouped into classes of types, reflecting the similarity of their values and primitive operations. There exist several language-defined classes of types (see NOTES below). Elementary types are those whose values are logically indivisible; composite types are those whose values are composed of component values.
  3. The elementary types are the scalar types (discrete and real) and the access types (whose values provide access to objects or subprograms). Discrete types are either integer types or are defined by enumeration of their values (enumeration types). Real types are either floating point types or fixed point types.
  4. The composite types are the record types, record extensions, array types, task types, and protected types. A private type or private extension represents a partial view, see section Private Types and Private Extensions, of a type, providing support for data abstraction. A partial view is a composite type.
  5. Certain composite types (and partial views thereof) have special components called discriminants whose values affect the presence, constraints, or initialization of other components. Discriminants can be thought of as parameters of the type.
  6. The term subcomponent is used in this International Standard in place of the term component to indicate either a component, or a component of another subcomponent. Where other subcomponents are excluded, the term component is used instead. Similarly, a part of an object or value is used to mean the whole object or value, or any set of its subcomponents.
  7. The set of possible values for an object of a given type can be subjected to a condition that is called a constraint (the case of a null constraint that specifies no restriction is also included); the rules for which values satisfy a given kind of constraint are given in section Scalar Types for range_constraints, section Index Constraints and Discrete Ranges, for index_constraints, and section Discriminant Constraints, for discriminant_constraints.
  8. A subtype of a given type is a combination of the type, a constraint on values of the type, and certain attributes specific to the subtype. The given type is called the type of the subtype. Similarly, the associated constraint is called the constraint of the subtype. The set of values of a subtype consists of the values of its type that satisfy its constraint. Such values belong to the subtype.
  9. A subtype is called an unconstrained subtype if its type has unknown discriminants, or if its type allows range, index, or discriminant constraints, but the subtype does not impose such a constraint; otherwise, the subtype is called a constrained subtype (since it has no unconstrained characteristics). NOTES
  10. (2) Any set of types that is closed under derivation (see section Derived Types and Classes) can be called a "class" of types. However, only certain classes are used in the description of the rules of the language -- generally those that have their own particular set of primitive operations (see section Classification of Operations) or that correspond to a set of types that are matched by a given kind of generic formal type (see section Formal Types). The following are examples of "interesting" language-defined classes: elementary, scalar, discrete, enumeration, character, boolean, integer, signed integer, modular, real, floating point, fixed point, ordinary fixed point, decimal fixed point, numeric, access, access-to-object, access-to-subprogram, composite, array, string, (untagged) record, tagged, task, protected, nonlimited. Special syntax is provided to define types in each of these classes.
    1. These language-defined classes are organized like this: 
    2. all types
   elementary
      scalar
         discrete
            enumeration
               character
               boolean
               other enumeration
            integer
               signed integer
               modular integer
         real
            floating point
            fixed point
               ordinary fixed point
               decimal fixed point
      access
         access-to-object
         access-to-subprogram
   composite
      array
         string
         other array
      untagged record
      tagged
      task
      protected
    3. The classes "numeric" and "nonlimited" represent other classification dimensions and do not fit into the above strictly hierarchical picture.

Type Declarations

  1. A type_declaration declares a type and its first subtype.

    Syntax 

  2. type_declaration ::=
     full_type_declaration
   | incomplete_type_declaration
   | private_type_declaration
   | private_extension_declaration

  3. full_type_declaration ::=
     type defining_identifier [known_discriminant_part]
       is type_definition;
   | task_type_declaration
   | protected_type_declaration

  4. type_definition ::=
     enumeration_type_definition | integer_type_definition
   | real_type_definition        | array_type_definition
   | record_type_definition      | access_type_definition
   | derived_type_definition

    Legality Rules

  5. A given type shall not have a subcomponent whose type is the given type itself.

    Static Semantics

  6. The defining_identifier of a type_declaration denotes the first subtype of the type. The known_discriminant_part, if any, defines the discriminants of the type (see section Discriminants). The remainder of the type_ declaration defines the remaining characteristics of (the view of) the type.
  7. A type defined by a type_declaration is a named type; such a type has one or more nameable subtypes. Certain other forms of declaration also include type definitions as part of the declaration for an object (including a parameter or a discriminant). The type defined by such a declaration is anonymous -- it has no nameable subtypes. For explanatory purposes, this International Standard sometimes refers to an anonymous type by a pseudo-name, written in italics, and uses such pseudo-names at places where the syntax normally requires an identifier. For a named type whose first subtype is T, this International Standard sometimes refers to the type of T as simply "the type T."
  8. A named type that is declared by a full_type_declaration, or an anonymous type that is defined as part of declaring an object of the type, is called a full type. The type_definition, task_definition, protected_definition, or access_definition that defines a full type is called a full type definition. Types declared by other forms of type_declaration are not separate types; they are partial or incomplete views of some full type.
  9. The definition of a type implicitly declares certain predefined operators that operate on the type, according to what classes the type belongs, as specified in section Operators and Expression Evaluation.
  10. The predefined types (for example the types Boolean, Wide_Character, Integer, root_integer, and universal_integer) are the types that are defined in a predefined library package called Standard; this package also includes the (implicit) declarations of their predefined operators. The package Standard is described in section The Package Standard.

    Dynamic Semantics

  11. The elaboration of a full_type_declaration consists of the elaboration of the full type definition. Each elaboration of a full type definition creates a distinct type and its first subtype.

    Examples

  12. Examples of type definitions: 
  13. (White, Red, Yellow, Green, Blue, Brown, Black)
range 1 .. 72
array(1 .. 10) of Integer
  14. Examples of type declarations: 
  15. type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
type Column is range 1 .. 72;
type Table  is array(1 .. 10) of Integer;
    NOTES
  16. (3) Each of the above examples declares a named type. The identifier given denotes the first subtype of the type. Other named subtypes of the type can be declared with subtype_declarations (see section Subtype Declarations). Although names do not directly denote types, a phrase like "the type Column" is sometimes used in this International Standard to refer to the type of Column, where Column denotes the first subtype of the type. For an example of the definition of an anonymous type, see the declaration of the array Color_Table in section Object Declarations, its type is anonymous -- it has no nameable subtypes.

Subtype Declarations

  1. A subtype_declaration declares a subtype of some previously declared type, as defined by a subtype_indication.

    Syntax 

  2. subtype_declaration ::=
   subtype defining_identifier is subtype_indication;

  3. subtype_indication ::=  subtype_mark [constraint]

  4. subtype_mark ::= subtype_name

  5. constraint ::= scalar_constraint | composite_constraint

  6. scalar_constraint ::=
   range_constraint | digits_constraint | delta_constraint

  7. composite_constraint ::=
   index_constraint | discriminant_constraint

    Name Resolution Rules

  8. A subtype_mark shall resolve to denote a subtype. The type determined by a subtype_mark is the type of the subtype denoted by the subtype_mark.

    Dynamic Semantics

  9. The elaboration of a subtype_declaration consists of the elaboration of the subtype_indication. The elaboration of a subtype_indication creates a new subtype. If the subtype_indication does not include a constraint, the new subtype has the same (possibly null) constraint as that denoted by the subtype_mark. The elaboration of a subtype_indication that includes a constraint proceeds as follows:
    1. The constraint is first elaborated.
    2. A check is then made that the constraint is compatible with the subtype denoted by the subtype_mark.
  1. The condition imposed by a constraint is the condition obtained after elaboration of the constraint. The rules defining compatibility are given for each form of constraint in the appropriate subclause. These rules are such that if a constraint is compatible with a subtype, then the condition imposed by the constraint cannot contradict any condition already imposed by the subtype on its values. The exception Constraint_Error is raised if any check of compatibility fails. NOTES
  2. (4) A scalar_constraint may be applied to a subtype of an appropriate scalar type, see section Scalar Types, see section Fixed Point Types, and section Reduced Accuracy Subtypes, even if the subtype is already constrained. On the other hand, a composite_constraint may be applied to a composite subtype (or an access-to-composite subtype) only if the composite subtype is unconstrained, see section Index Constraints and Discrete Ranges and section Discriminant Constraints.

    Examples

  3. Examples of subtype declarations: 
  4. subtype Rainbow   is Color range Red .. Blue;  -- see section Type Declarations
subtype Red_Blue  is Rainbow;
subtype Int       is Integer;
subtype Small_Int is Integer range -10 .. 10;
subtype Up_To_K   is Column range 1 .. K;      -- see section Type Declarations
subtype Square    is Matrix(1 .. 10, 1 .. 10); -- see section Array Types
subtype Male      is Person(Sex => M);         -- see section Incomplete Type Declarations

Classification of Operations

Static Semantics

  1. An operation operates on a type T if it yields a value of type T, if it has an operand whose expected type, see section The Context of Overload Resolution, is T, or if it has an access parameter, see section Subprogram Declarations designating T. A predefined operator, or other language-defined operation such as assignment or a membership test, that operates on a type, is called a predefined operation of the type. The primitive operations of a type are the predefined operations of the type, plus any user-defined primitive subprograms.
  2. The primitive subprograms of a specific type are defined as follows:
    1. The predefined operators of the type, see section Operators and Expression Evaluation,
    2. For a derived type, the inherited, see section Derived Types and Classes, user-defined subprograms;
    3. For an enumeration type, the enumeration literals (which are considered parameterless functions -- see section Enumeration Types.);
    4. For a specific type declared immediately within a package_specification, any subprograms (in addition to the enumeration literals) that are explicitly declared immediately within the same package_specification and that operate on the type;
    5. Any subprograms not covered above that are explicitly declared immediately within the same declarative region as the type and that override, see section Visibility, other implicitly declared primitive subprograms of the type.
  1. A primitive subprogram whose designator is an operator_symbol is called a primitive operator.

Objects and Named Numbers

  1. Objects are created at run time and contain a value of a given type. An object can be created and initialized as part of elaborating a declaration, evaluating an allocator, aggregate, or function_call, or passing a parameter by copy. Prior to reclaiming the storage for an object, it is finalized if necessary, see section Completion and Finalization.

    Static Semantics

  2. All of the following are objects:
    1. the entity declared by an object_declaration;
    2. a formal parameter of a subprogram, entry, or generic subprogram;
    3. a generic formal object;
    4. a loop parameter;
    5. a choice parameter of an exception_handler;
    6. an entry index of an entry_body;
    7. the result of dereferencing an access-to-object value, see section Names,
    8. the result of evaluating a function_call (or the equivalent operator invocation -- see section Overloading of Operators,
    9. the result of evaluating an aggregate;
    10. a component, slice, or view conversion of another object.
  1. An object is either a constant object or a variable object. The value of a constant object cannot be changed between its initialization and its finalization, whereas the value of a variable object can be changed. Similarly, a view of an object is either a constant or a variable. All views of a constant object are constant. A constant view of a variable object cannot be used to modify the value of the variable. The terms constant and variable by themselves refer to constant and variable views of objects.
  2. The value of an object is read when the value of any part of the object is evaluated, or when the value of an enclosing object is evaluated. The value of a variable is updated when an assignment is performed to any part of the variable, or when an assignment is performed to an enclosing object.
  3. Whether a view of an object is constant or variable is determined by the definition of the view. The following (and no others) represent constants:
    1. an object declared by an object_declaration with the reserved word constant;
    2. a formal parameter or generic formal object of mode in;
    3. a discriminant;
    4. a loop parameter, choice parameter, or entry index;
    5. the dereference of an access-to-constant value;
    6. he result of evaluating a function_call or an aggregate;
    7. a selected_component, indexed_component, slice, or view conversion of a constant.
  1. At the place where a view of an object is defined, a nominal subtype is associated with the view. The object's actual subtype (that is, its subtype) can be more restrictive than the nominal subtype of the view; it always is if the nominal subtype is an indefinite subtype. A subtype is an indefinite subtype if it is an unconstrained array subtype, or if it has unknown discriminants or unconstrained discriminants without defaults (see section Discriminants) otherwise the subtype is a definite subtype (all elementary subtypes are definite subtypes). A class-wide subtype is defined to have unknown discriminants, and is therefore an indefinite subtype. An indefinite subtype does not by itself provide enough information to create an object; an additional constraint or explicit initialization expression is necessary (see section Object Declarations). A component cannot have an indefinite nominal subtype.
  2. A named number provides a name for a numeric value known at compile time. It is declared by a number_declaration. NOTES
  3. (5) A constant cannot be the target of an assignment operation, nor be passed as an in out or out parameter, between its initialization and finalization, if any.
  4. (6) The nominal and actual subtypes of an elementary object are always the same. For a discriminated or array object, if the nominal subtype is constrained then so is the actual subtype.

Object Declarations

  1. An object_declaration declares a stand-alone object with a given nominal subtype and, optionally, an explicit initial value given by an initialization expression. For an array, task, or protected object, the object_declaration may include the definition of the (anonymous) type of the object.

    Syntax 

  2. object_declaration ::=
    defining_identifier_list : [aliased] [constant]
      subtype_indication [:= expression];
  | defining_identifier_list : [aliased] [constant]
      array_type_definition [:= expression];
  | single_task_declaration
  | single_protected_declaration

  3. defining_identifier_list ::=
   defining_identifier {, defining_identifier}

    Name Resolution Rules

  4. For an object_declaration with an expression following the compound delimiter :=, the type expected for the expression is that of the object. This expression is called the initialization expression.

    Legality Rules

  5. An object_declaration without the reserved word constant declares a variable object. If it has a subtype_indication or an array_type_definition that defines an indefinite subtype, then there shall be an initialization expression. An initialization expression shall not be given if the object is of a limited type.

    Static Semantics

  6. An object_declaration with the reserved word constant declares a constant object. If it has an initialization expression, then it is called a full constant declaration. Otherwise it is called a deferred constant declaration. The rules for deferred constant declarations are given in clause (see section Deferred Constants). The rules for full constant declarations are given in this subclause.
  7. Any declaration that includes a defining_identifier_list with more than one defining_identifier is equivalent to a series of declarations each containing one defining_identifier from the list, with the rest of the text of the declaration copied for each declaration in the series, in the same order as the list. The remainder of this International Standard relies on this equivalence; explanations are given for declarations with a single defining_identifier.
  8. The subtype_indication or full type definition of an object_declaration defines the nominal subtype of the object. The object_declaration declares an object of the type of the nominal subtype.

    Dynamic Semantics

  9. If a composite object declared by an object_declaration has an unconstrained nominal subtype, then if this subtype is indefinite or the object is constant or aliased, see section Access Types, the actual subtype of this object is constrained. The constraint is determined by the bounds or discriminants (if any) of its initial value; the object is said to be constrained by its initial value. In the case of an aliased object, this initial value may be either explicit or implicit; in the other cases, an explicit initial value is required. When not constrained by its initial value, the actual and nominal subtypes of the object are the same. If its actual subtype is constrained, the object is called a constrained object.
  10. For an object_declaration without an initialization expression, any initial values for the object or its subcomponents are determined by the implicit initial values defined for its nominal subtype, as follows:
    1. The implicit initial value for an access subtype is the null value of the access type.
    2. The implicit initial (and only) value for each discriminant of a constrained discriminated subtype is defined by the subtype.
    3. For a (definite) composite subtype, the implicit initial value of each component with a default_expression is obtained by evaluation of this expression and conversion to the component's nominal subtype (which might raise Constraint_Error -- see section Type Conversions.), unless the component is a discriminant of a constrained subtype (the previous case), or is in an excluded variant, see section Variant Parts and Discrete Choices. For each component that does not have a default_expression, any implicit initial values are those determined by the component's nominal subtype.
    4. For a protected or task subtype, there is an implicit component (an entry queue) corresponding to each entry, with its implicit initial value being an empty queue.
  1. The elaboration of an object_declaration proceeds in the following sequence of steps:
    1. The subtype_indication, array_type_definition, single_task_declaration, or single_protected_declaration is first elaborated. This creates the nominal subtype (and the anonymous type in the latter three cases).
    2. If the object_declaration includes an initialization expression, the (explicit) initial value is obtained by evaluating the expression and converting it to the nominal subtype (which might raise Constraint_Error -- see section Type Conversions.).
    3. The object is created, and, if there is not an initialization expression, any per-object expressions, see section Record Types are evaluated and any implicit initial values for the object or for its subcomponents are obtained as determined by the nominal subtype.
    4. Any initial values (whether explicit or implicit) are assigned to the object or to the corresponding subcomponents. As described in section Assignment Statements, and section User-Defined Assignment and Finalization, Initialize and Adjust procedures can be called.
  1. For the third step above, the object creation and any elaborations and evaluations are performed in an arbitrary order, except that if the default_expression for a discriminant is evaluated to obtain its initial value, then this evaluation is performed before that of the default_expression for any component that depends on the discriminant, and also before that of any default_expression that includes the name of the discriminant. The evaluations of the third step and the assignments of the fourth step are performed in an arbitrary order, except that each evaluation is performed before the resulting value is assigned.
  2. There is no implicit initial value defined for a scalar subtype. In the absence of an explicit initialization, a newly created scalar object might have a value that does not belong to its subtype (see section Data Validity and section Pragma Normalize_Scalars). NOTES
  3. (7) Implicit initial values are not defined for an indefinite subtype, because if an object's nominal subtype is indefinite, an explicit initial value is required.
  4. (8) As indicated above, a stand-alone object is an object declared by an object_declaration. Similar definitions apply to "stand-alone constant" and "stand-alone variable." A subcomponent of an object is not a stand-alone object, nor is an object that is created by an allocator. An object declared by a loop_parameter_specification, parameter_specification, entry_index_specification, choice_parameter_specification, or a formal_object_declaration is not called a stand-alone object.
  5. (9) The type of a stand-alone object cannot be abstract, see section Abstract Types and Subprograms.

    Examples

  6. Example of a multiple object declaration: 
  7. --  the multiple object declaration

  8. John, Paul : Person_Name := new Person(Sex => M); --  see section Incomplete Type Declarations

  9. --  is equivalent to the two single object
--  declarations in the order given

  10. John : Person_Name := new Person(Sex => M);
Paul : Person_Name := new Person(Sex => M);
  11. Examples of variable declarations: 
  12. Count, Sum  : Integer;
Size        : Integer range 0 .. 10_000 := 0;
Sorted      : Boolean := False;
Color_Table : array(1 .. Max) of Color;
Option      : Bit_Vector(1 .. 10) := (others => True);
Hello       : constant String := "Hi, world.";
  13. Examples of constant declarations: 
  14. Limit     : constant Integer := 10_000;
Low_Limit : constant Integer := Limit/10;
Tolerance : constant Real := Dispersion(1.15);

Number Declarations

  1. A number_declaration declares a named number.

    Syntax 

  2. number_declaration ::=
   defining_identifier_list : constant := static_expression;

    Name Resolution Rules

  3. The static_expression given for a number_declaration is expected to be of any numeric type.

    Legality Rules

  4. The static_expression given for a number declaration shall be a static expression, as defined by clause (see section Static Expressions and Static Subtypes).

    Static Semantics

  5. The named number denotes a value of type universal_integer if the type of the static_expression is an integer type. The named number denotes a value of type universal_real if the type of the static_expression is a real type.
  6. The value denoted by the named number is the value of the static_expression, converted to the corresponding universal type.

    Dynamic Semantics

  7. The elaboration of a number_declaration has no effect.

    Examples

  8. Examples of number declarations: 
  9. Two_Pi        : constant := 2.0*Ada.Numerics.Pi;
-- a real number, see section The Numerics Packages

  10. Max           : constant := 500;     -- an integer number
Max_Line_Size : constant := Max/6;   -- the integer 83
Power_16      : constant := 2**16;   -- the integer 65_536
One, Un, Eins : constant := 1;       -- three different names for 1

Derived Types and Classes

  1. A derived_type_definition defines a new type (and its first subtype) whose characteristics are derived from those of a parent type.

    Syntax 

  2. derived_type_definition ::= [abstract] new
  parent_subtype_indication [record_extension_part]

    Legality Rules

  3. The parent_subtype_indication defines the parent subtype; its type is the parent type.
  4. A type shall be completely defined, see section Completions of Declarations, prior to being specified as the parent type in a derived_type_definition -- the full_type_declarations for the parent type and any of its subcomponents have to precede the derived_type_definition.
  5. If there is a record_extension_part, the derived type is called a record extension of the parent type. A record_extension_part shall be provided if and only if the parent type is a tagged type.

    Static Semantics

  6. The first subtype of the derived type is unconstrained if a known_discriminant_part is provided in the declaration of the derived type, or if the parent subtype is unconstrained. Otherwise, the constraint of the first subtype corresponds to that of the parent subtype in the following sense: it is the same as that of the parent subtype except that for a range constraint (implicit or explicit), the value of each bound of its range is replaced by the corresponding value of the derived type.
  7. The characteristics of the derived type are defined as follows:
    1. Each class of types that includes the parent type also includes the derived type.
    2. If the parent type is an elementary type or an array type, then the set of possible values of the derived type is a copy of the set of possible values of the parent type. For a scalar type, the base range of the derived type is the same as that of the parent type.
    3. If the parent type is a composite type other than an array type, then the components, protected subprograms, and entries that are declared for the derived type are as follows:
      1. The discriminants specified by a new known_discriminant_part, if there is one; otherwise, each discriminant of the parent type (implicitly declared in the same order with the same specifications) -- in the latter case, the discriminants are said to be inherited, or if unknown in the parent, are also unknown in the derived type;
      2. Each nondiscriminant component, entry, and protected subprogram of the parent type, implicitly declared in the same order with the same declarations; these components, entries, and protected subprograms are said to be inherited;
      3. Each component declared in a record_extension_part, if any.
    1. Declarations of components, protected subprograms, and entries, whether implicit or explicit, occur immediately within the declarative region of the type, in the order indicated above, following the parent subtype_indication.
    2. The derived type is limited if and only if the parent type is limited.
    3. For each predefined operator of the parent type, there is a corresponding predefined operator of the derived type.
    4. For each user-defined primitive subprogram (other than a user-defined equality operator -- see below) of the parent type that already exists at the place of the derived_type_definition, there exists a corresponding inherited primitive subprogram of the derived type with the same defining name. Primitive user-defined equality operators of the parent type are also inherited by the derived type, except when the derived type is a nonlimited record extension, and the inherited operator would have a profile that is type conformant with the profile of the corresponding predefined equality operator; in this case, the user-defined equality operator is not inherited, but is rather incorporated into the implementation of the predefined equality operator of the record extension, see section Relational Operators and Membership Tests.
    5. The profile of an inherited subprogram (including an inherited enumeration literal) is obtained from the profile of the corresponding (user-defined) primitive subprogram of the parent type, after systematic replacement of each subtype of its profile, see section Subprogram Declarations, that is of the parent type with a corresponding subtype of the derived type. For a given subtype of the parent type, the corresponding subtype of the derived type is defined as follows:
      1. If the declaration of the derived type has neither a known_discriminant_part nor a record_extension_part, then the corresponding subtype has a constraint that corresponds (as defined above for the first subtype of the derived type) to that of the given subtype.
      2. If the derived type is a record extension, then the corresponding subtype is the first subtype of the derived type.
      3. If the derived type has a new known_discriminant_part but is not a record extension, then the corresponding subtype is constrained to those values that when converted to the parent type belong to the given subtype, see section Type Conversions.
    1. The same formal parameters have default_expressions in the profile of the inherited subprogram. Any type mismatch due to the systematic replacement of the parent type by the derived type is handled as part of the normal type conversion associated with parameter passing -- see section Parameter Associations.
  1. If a primitive subprogram of the parent type is visible at the place of the derived_type_definition, then the corresponding inherited subprogram is implicitly declared immediately after the derived_type_definition. Otherwise, the inherited subprogram is implicitly declared later or not at all, as explained in section Private Operations.
  2. A derived type can also be defined by a private_extension_declaration (see section Private Types and Private Extensions) or a formal_derived_type_definition, see section Formal Private and Derived Types. Such a derived type is a partial view of the corresponding full or actual type.
  3. All numeric types are derived types, in that they are implicitly derived from a corresponding root numeric type (see section Integer Types, and section Real Types).

    Dynamic Semantics

  4. The elaboration of a derived_type_definition creates the derived type and its first subtype, and consists of the elaboration of the subtype_indication and the record_extension_part, if any. If the subtype_indication depends on a discriminant, then only those expressions that do not depend on a discriminant are evaluated.
  5. For the execution of a call on an inherited subprogram, a call on the corresponding primitive subprogram of the parent type is performed; the normal conversion of each actual parameter to the subtype of the corresponding formal parameter, see section Parameter Associations performs any necessary type conversion as well. If the result type of the inherited subprogram is the derived type, the result of calling the parent's subprogram is converted to the derived type. NOTES
  6. (10) Classes are closed under derivation -- any class that contains a type also contains its derivatives. Operations available for a given class of types are available for the derived types in that class.
  7. (11) Evaluating an inherited enumeration literal is equivalent to evaluating the corresponding enumeration literal of the parent type, and then converting the result to the derived type. This follows from their equivalence to parameterless functions.
  8. (12) A generic subprogram is not a subprogram, and hence cannot be a primitive subprogram and cannot be inherited by a derived type. On the other hand, an instance of a generic subprogram can be a primitive subprogram, and hence can be inherited.
  9. (13) If the parent type is an access type, then the parent and the derived type share the same storage pool; there is a null access value for the derived type and it is the implicit initial value for the type (see section Access Types).
  10. (14) If the parent type is a boolean type, the predefined relational operators of the derived type deliver a result of the predefined type Boolean, see section Relational Operators and Membership Tests. If the parent type is an integer type, the right operand of the predefined exponentiation operator is of the predefined type Integer, see section Highest Precedence Operators.
  11. (15) Any discriminants of the parent type are either all inherited, or completely replaced with a new set of discriminants.
  12. (16) For an inherited subprogram, the subtype of a formal parameter of the derived type need not have any value in common with the first subtype of the derived type.
  13. (17) If the reserved word abstract is given in the declaration of a type, the type is abstract, see section Abstract Types and Subprograms.

    Examples

  14. Examples of derived type declarations: 
  15. type Local_Coordinate is new Coordinate;   --  two different types
type Midweek is new Day range Tue .. Thu;  --  see section Enumeration Types
type Counter is new Positive;              --  same range as Positive

  16. type Special_Key is new Key_Manager.Key;   --  see section Private Operations
  -- the inherited subprograms have the following specifications:
  --         procedure Get_Key(K : out Special_Key);
  --         function "<"(X,Y : Special_Key) return Boolean;

Derivation Classes

  1. In addition to the various language-defined classes of types, types can be grouped into derivation classes.

    Static Semantics

  2. A derived type is derived from its parent type directly; it is derived indirectly from any type from which its parent type is derived. The derivation class of types for a type T (also called the class rooted at T) is the set consisting of T (the root type of the class) and all types derived from T (directly or indirectly) plus any associated universal or class-wide types (defined below).
  3. Every type is either a specific type, a class-wide type, or a universal type. A specific type is one defined by a type_declaration, a formal_type_declaration, or a full type definition embedded in a declaration for an object. Class-wide and universal types are implicitly defined, to act as representatives for an entire class of types, as follows:
  4. Class-wide types
      Class-wide types are defined for (and belong to) each derivation class rooted at a tagged type, see section Tagged Types and Type Extensions. Given a subtype S of a tagged type T, S'Class is the subtype_mark for a corresponding subtype of the tagged class-wide type T'Class. Such types are called "class-wide" because when a formal parameter is defined to be of a class-wide type T'Class, an actual parameter of any type in the derivation class rooted at T is acceptable, see section The Context of Overload Resolution.
    1. The set of values for a class-wide type T'Class is the discriminated union of the set of values of each specific type in the derivation class rooted at T (the tag acts as the implicit discriminant -- see section Tagged Types and Type Extensions.). Class-wide types have no primitive subprograms of their own. However, as explained in section Dispatching Operations of Tagged Types, operands of a class-wide type T'Class can be used as part of a dispatching call on a primitive subprogram of the type T. The only components (including discriminants) of T'Class that are visible are those of T. If S is a first subtype, then S'Class is a first subtype.
  1. Universal types
      Universal types are defined for (and belong to) the integer, real, and fixed point classes, and are referred to in this standard as respectively, universal_integer, universal_real, and universal_fixed. These are analogous to class-wide types for these language-defined numeric classes. As with class-wide types, if a formal parameter is of a universal type, then an actual parameter of any type in the corresponding class is acceptable. In addition, a value of a universal type (including an integer or real numeric_literal) is "universal" in that it is acceptable where some particular type in the class is expected, see section The Context of Overload Resolution.
    1. The set of values of a universal type is the undiscriminated union of the set of values possible for any definable type in the associated class. Like class-wide types, universal types have no primitive subprograms of their own. However, their "universality" allows them to be used as operands with the primitive subprograms of any type in the corresponding class.
  1. The integer and real numeric classes each have a specific root type in addition to their universal type, named respectively root_integer and root_real.
  2. A class-wide or universal type is said to cover all of the types in its class. A specific type covers only itself.
  3. A specific type T2 is defined to be a descendant of a type T1 if T2 is the same as T1, or if T2 is derived (directly or indirectly) from T1. A class-wide type T2'Class is defined to be a descendant of type T1 if T2 is a descendant of T1. Similarly, the universal types are defined to be descendants of the root types of their classes. If a type T2 is a descendant of a type T1, then T1 is called an ancestor of T2. The ultimate ancestor of a type is the ancestor of the type that is not a descendant of any other type.
  4. An inherited component (including an inherited discriminant) of a derived type is inherited from a given ancestor of the type if the corresponding component was inherited by each derived type in the chain of derivations going back to the given ancestor. NOTES
  5. (18) Because operands of a universal type are acceptable to the predefined operators of any type in their class, ambiguity can result. For universal_integer and universal_real, this potential ambiguity is resolved by giving a preference, see section The Context of Overload Resolution to the predefined operators of the corresponding root types (root_integer and root_real, respectively). Hence, in an apparently ambiguous expression like 
  6. 1 + 4 < 7
  7. where each of the literals is of type universal_integer, the predefined operators of root_integer will be preferred over those of other specific integer types, thereby resolving the ambiguity.

Scalar Types

  1. Scalar types comprise enumeration types, integer types, and real types. Enumeration types and integer types are called discrete types; each value of a discrete type has a position number which is an integer value. Integer types and real types are called numeric types. All scalar types are ordered, that is, all relational operators are predefined for their values.

    Syntax 

  2. range_constraint ::= range range

  3. range ::=
     range_attribute_reference
   | simple_expression .. simple_expression
  4. A range has a lower bound and an upper bound and specifies a subset of the values of some scalar type (the type of the range). A range with lower bound L and upper bound R is described by "L .. R". If R is less than L, then the range is a null range, and specifies an empty set of values. Otherwise, the range specifies the values of the type from the lower bound to the upper bound, inclusive. A value belongs to a range if it is of the type of the range, and is in the subset of values specified by the range. A value satisfies a range constraint if it belongs to the associated range. One range is included in another if all values that belong to the first range also belong to the second.

    Name Resolution Rules

  5. For a subtype_indication containing a range_constraint, either directly or as part of some other scalar_constraint, the type of the range shall resolve to that of the type determined by the subtype_mark of the subtype_indication. For a range of a given type, the simple_expressions of the range (likewise, the simple_expressions of the equivalent range for a range_attribute_reference) are expected to be of the type of the range.

    Static Semantics

  6. The base range of a scalar type is the range of finite values of the type that can be represented in every unconstrained object of the type; it is also the range supported at a minimum for intermediate values during the evaluation of expressions involving predefined operators of the type.
  7. A constrained scalar subtype is one to which a range constraint applies. The range of a constrained scalar subtype is the range associated with the range constraint of the subtype. The range of an unconstrained scalar subtype is the base range of its type.

    Dynamic Semantics

  8. A range is compatible with a scalar subtype if and only if it is either a null range or each bound of the range belongs to the range of the subtype. A range_constraint is compatible with a scalar subtype if and only if its range is compatible with the subtype.
  9. The elaboration of a range_constraint consists of the evaluation of the range. The evaluation of a range determines a lower bound and an upper bound. If simple_expressions are given to specify bounds, the evaluation of the range evaluates these simple_expressions in an arbitrary order, and converts them to the type of the range. If a range_attribute_reference is given, the evaluation of the range consists of the evaluation of the range_attribute_reference.
  10. Attributes
  11. For every scalar subtype S, the following attributes are defined:
  12. S'First 
    S'First denotes the lower bound of the range of S. The value
of this attribute is of the type of S.
  13. S'Last 
    S'Last denotes the upper bound of the range of S. The value
of this attribute is of the type of S.
  14. S'Range 
    S'Range is equivalent to the range S'First .. S'Last.
  15. S'Base 
    S'Base denotes an unconstrained subtype of the type of
S. This unconstrained subtype is called the base subtype of
the type.
  16. S'Min
      S'Min denotes a function with the following specification: 
    1. function S'Min(Left, Right : S'Base)
  return S'Base
    2. The function returns the lesser of the values of the two parameters.
  1. S'Max
      S'Max denotes a function with the following specification: 
    1. function S'Max(Left, Right : S'Base)
  return S'Base
    2. The function returns the greater of the values of the two parameters.
  1. S'Succ
      S'Succ denotes a function with the following specification: 
    1. function S'Succ(Arg : S'Base)
  return S'Base
    2. For an enumeration type, the function returns the value whose position number is one more than that of the value of Arg; Constraint_Error is raised if there is no such value of the type. For an integer type, the function returns the result of adding one to the value of Arg. For a fixed point type, the function returns the result of adding small to the value of Arg. For a floating point type, the function returns the machine number (as defined in section Floating Point Types.) immediately above the value of Arg; Constraint_Error is raised if there is no such machine number.
  1. S'Pred
      S'Pred denotes a function with the following specification: 
    1. function S'Pred(Arg : S'Base)
  return S'Base
    2. For an enumeration type, the function returns the value whose position number is one less than that of the value of Arg; Constraint_Error is raised if there is no such value of the type. For an integer type, the function returns the result of subtracting one from the value of Arg. For a fixed point type, the function returns the result of subtracting small from the value of Arg. For a floating point type, the function returns the machine number (as defined in section Floating Point Types.) immediately below the value of Arg; Constraint_Error is raised if there is no such machine number.
  1. S'Wide_Image
      S'Wide_Image denotes a function with the following specification: 
    1. function S'Wide_Image(Arg : S'Base)
  return Wide_String
    2. The function returns an image of the value of Arg, that is, a sequence of characters representing the value in display form. The lower bound of the result is one.
    3. The image of an integer value is the corresponding decimal literal, without underlines, leading zeros, exponent, or trailing spaces, but with a single leading character that is either a minus sign or a space.
    4. The image of an enumeration value is either the corresponding identifier in upper case or the corresponding character literal (including the two apostrophes); neither leading nor trailing spaces are included. For a nongraphic character (a value of a character type that has no enumeration literal associated with it), the result is a corresponding language-defined or implementation-defined name in upper case (for example, the image of the nongraphic character identified as nul is "NUL" -- the quotes are not part of the image).
    5. The image of a floating point value is a decimal real literal best approximating the value (rounded away from zero if halfway between) with a single leading character that is either a minus sign or a space, a single digit (that is nonzero unless the value is zero), a decimal point, S'Digits-1, see section Operations of Floating Point Types, digits after the decimal point (but one if S'Digits is one), an upper case E, the sign of the exponent (either + or -), and two or more digits (with leading zeros if necessary) representing the exponent. If S'Signed_Zeros is True, then the leading character is a minus sign for a negatively signed zero.
    6. The image of a fixed point value is a decimal real literal best approximating the value (rounded away from zero if halfway between) with a single leading character that is either a minus sign or a space, one or more digits before the decimal point (with no redundant leading zeros), a decimal point, and S'Aft, see section Operations of Fixed Point Types, digits after the decimal point.
  1. S'Image
      S'Image denotes a function with the following specification: 
    1. function S'Image(Arg : S'Base)
  return String
    2. The function returns an image of the value of Arg as a String. The lower bound of the result is one. The image has the same sequence of graphic characters as that defined for S'Wide_Image if all the graphic characters are defined in Character; otherwise the sequence of characters is implementation defined (but no shorter than that of S'Wide_Image for the same value of Arg).
  1. S'Wide_Width 
    S'Wide_Width denotes the maximum length of a Wide_String
returned by S'Wide_Image over all values of the subtype S. It
denotes zero for a subtype that has a null range. Its type
is universal_integer.
  2. S'Width 
    S'Width denotes the maximum length of a String returned by
S'Image over all values of the subtype S. It denotes
zero for a subtype that has a null range. Its type is
universal_integer.
  3. S'Wide_Value
      S'Wide_Value denotes a function with the following specification: 
    1. function S'Wide_Value(Arg : Wide_String)
  return S'Base
    2. This function returns a value given an image of the value as a Wide_String, ignoring any leading or trailing spaces.
    3. For the evaluation of a call on S'Wide_Value for an enumeration subtype S, if the sequence of characters of the parameter (ignoring leading and trailing spaces) has the syntax of an enumeration literal and if it corresponds to a literal of the type of S (or corresponds to the result of S'Wide_Image for a nongraphic character of the type), the result is the corresponding enumeration value; otherwise Constraint_Error is raised.
    4. For the evaluation of a call on S'Wide_Value (or S'Value) for an integer subtype S, if the sequence of characters of the parameter (ignoring leading and trailing spaces) has the syntax of an integer literal, with an optional leading sign character (plus or minus for a signed type; only plus for a modular type), and the corresponding numeric value belongs to the base range of the type of S, then that value is the result; otherwise Constraint_Error is raised.
    5. For the evaluation of a call on S'Wide_Value (or S'Value) for a real subtype S, if the sequence of characters of the parameter (ignoring leading and trailing spaces) has the syntax of one of the following:
      1. numeric_literal
      2. numeral.[exponent]
      3. .numeral[exponent]
      4. base#based_numeral.#[exponent]
      5. base#.based_numeral#[exponent]
    1. with an optional leading sign character (plus or minus), and if the corresponding numeric value belongs to the base range of the type of S, then that value is the result; otherwise Constraint_Error is raised. The sign of a zero value is preserved (positive if none has been specified) if S'Signed_Zeros is True.
  1. S'Value
      S'Value denotes a function with the following specification: 
    1. function S'Value(Arg : String)
  return S'Base
    2. This function returns a value given an image of the value as a String, ignoring any leading or trailing spaces.
    3. For the evaluation of a call on S'Value for an enumeration subtype S, if the sequence of characters of the parameter (ignoring leading and trailing spaces) has the syntax of an enumeration literal and if it corresponds to a literal of the type of S (or corresponds to the result of S'Image for a value of the type), the result is the corresponding enumeration value; otherwise Constraint_Error is raised. For a numeric subtype S, the evaluation of a call on S'Value with Arg of type String is equivalent to a call on S'Wide_Value for a corresponding Arg of type Wide_String.

Implementation Permissions

  1. An implementation may extend the Wide_Value, Value, Wide_Image, and Image attributes of a floating point type to support special values such as infinities and NaNs. NOTES
  2. (19) The evaluation of S'First or S'Last never raises an exception. If a scalar subtype S has a nonnull range, S'First and S'Last belong to this range. These values can, for example, always be assigned to a variable of subtype S.
  3. (20) For a subtype of a scalar type, the result delivered by the attributes Succ, Pred, and Value might not belong to the subtype; similarly, the actual parameters of the attributes Succ, Pred, and Image need not belong to the subtype.
  4. (21) For any value V (including any nongraphic character) of an enumeration subtype S, S'Value(S'Image(V)) equals V, as does S'Wide_Value(S'Wide_Image(V)). Neither expression ever raises Constraint_Error.

    Examples

  5. Examples of ranges: 
  6. -10 .. 10
X .. X + 1
0.0 .. 2.0*Pi
Red .. Green     --  see section Enumeration Types
1 .. 0           -- a null range
Table'Range      -- a range attribute reference, see section Array Types
  7. Examples of range constraints: 
  8. range -999.0 .. +999.0
range S'First+1 .. S'Last-1

Enumeration Types

  1. An enumeration_type_definition defines an enumeration type.

    Syntax 

  2. enumeration_type_definition ::=
   (enumeration_literal_specification
     {, enumeration_literal_specification})

  3. enumeration_literal_specification ::=
   defining_identifier | defining_character_literal

  4. defining_character_literal ::= character_literal

    Legality Rules

  5. The defining_identifiers and defining_character_literals listed in an enumeration_type_definition shall be distinct.

    Static Semantics

  6. Each enumeration_literal_specification is the explicit declaration of the corresponding enumeration literal: it declares a parameterless function, whose defining name is the defining_identifier or defining_character_literal, and whose result type is the enumeration type.
  7. Each enumeration literal corresponds to a distinct value of the enumeration type, and to a distinct position number. The position number of the value of the first listed enumeration literal is zero; the position number of the value of each subsequent enumeration literal is one more than that of its predecessor in the list.
  8. The predefined order relations between values of the enumeration type follow the order of corresponding position numbers.
  9. If the same defining_identifier or defining_character_literal is specified in more than one enumeration_type_definition, the corresponding enumeration literals are said to be overloaded. At any place where an overloaded enumeration literal occurs in the text of a program, the type of the enumeration literal has to be determinable from the context, see section The Context of Overload Resolution.

    Dynamic Semantics

  10. The elaboration of an enumeration_type_definition creates the enumeration type and its first subtype, which is constrained to the base range of the type.
  11. When called, the parameterless function associated with an enumeration literal returns the corresponding value of the enumeration type. NOTES
  12. (22) If an enumeration literal occurs in a context that does not otherwise suffice to determine the type of the literal, then qualification by the name of the enumeration type is one way to resolve the ambiguity, see section Qualified Expressions.

    Examples

  13. Examples of enumeration types and subtypes: 
  14. type Day    is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
type Suit   is (Clubs, Diamonds, Hearts, Spades);
type Gender is (M, F);
type Level  is (Low, Medium, Urgent);
type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
type Light  is (Red, Amber, Green); -- Red and Green are overloaded

  15. type Hexa   is ('A', 'B', 'C', 'D', 'E', 'F');
type Mixed  is ('A', 'B', '*', B, None, '?', '%');

  16. subtype Weekday is Day   range Mon .. Fri;
subtype Major   is Suit  range Hearts .. Spades;
subtype Rainbow is Color range Red .. Blue;
--  the Color Red, not the Light

Character Types

Static Semantics

  1. An enumeration type is said to be a character type if at least one of its enumeration literals is a character_literal.
  2. The predefined type Character is a character type whose values correspond to the 256 code positions of Row 00 (also known as Latin-1) of the ISO 10646 Basic Multilingual Plane (BMP). Each of the graphic characters of Row 00 of the BMP has a corresponding character_literal in Character. Each of the nongraphic positions of Row 00 (0000-001F and 007F-009F) has a corresponding language-defined name, which is not usable as an enumeration literal, but which is usable with the attributes (Wide_)Image and (Wide_)Value; these names are given in the definition of type Character in section The Package Standard, but are set in italics.
  3. The predefined type Wide_Character is a character type whose values correspond to the 65536 code positions of the ISO 10646 Basic Multilingual Plane (BMP). Each of the graphic characters of the BMP has a corresponding character_literal in Wide_Character. The first 256 values of Wide_Character have the same character_literal or language-defined name as defined for Character. The last 2 values of Wide_Character correspond to the nongraphic positions FFFE and FFFF of the BMP, and are assigned the language-defined names FFFE and FFFF. As with the other language-defined names for nongraphic characters, the names FFFE and FFFF are usable only with the attributes (Wide_)Image and (Wide_)Value; they are not usable as enumeration literals. All other values of Wide_Character are considered graphic characters, and have a corresponding character_literal.

    Implementation Permissions

  4. In a nonstandard mode, an implementation may provide other interpretations for the predefined types Character and Wide_Character, to conform to local conventions.

    Implementation Advice

  5. If an implementation supports a mode with alternative interpretations for Character and Wide_Character, the set of graphic characters of Character should nevertheless remain a proper subset of the set of graphic characters of Wide_Character. Any character set "localizations" should be reflected in the results of the subprograms defined in the language-defined package Characters.Handling, see section Character Handling, available in such a mode. In a mode with an alternative interpretation of Character, the implementation should also support a corresponding change in what is a legal identifier_letter. NOTES
  6. (23) The language-defined library package Characters.Latin_1 (section The Package Characters.Latin_1) includes the declaration of constants denoting control characters, lower case characters, and special characters of the predefined type Character.
  7. (24) A conventional character set such as EBCDIC can be declared as a character type; the internal codes of the characters can be specified by an enumeration_representation_clause as explained in clause (see section Enumeration Representation Clauses).

    Examples

  8. Example of a character type: 
  9. type Roman_Digit is ('I', 'V', 'X', 'L', 'C', 'D', 'M');

Boolean Types

Static Semantics

  1. There is a predefined enumeration type named Boolean, declared in the visible part of package Standard. It has the two enumeration literals False and True ordered with the relation False < True. Any descendant of the predefined type Boolean is called a boolean type.

Integer Types

  1. An integer_type_definition defines an integer type; it defines either a signed integer type, or a modular integer type. The base range of a signed integer type includes at least the values of the specified range. A modular type is an integer type with all arithmetic modulo a specified positive modulus; such a type corresponds to an unsigned type with wrap-around semantics.

    Syntax 

  2. integer_type_definition ::=
   signed_integer_type_definition | modular_type_definition

  3. signed_integer_type_definition ::=
   range static_simple_expression .. static_simple_expression

  4. modular_type_definition ::= mod static_expression

    Name Resolution Rules

  5. Each simple_expression in a signed_integer_type_definition is expected to be of any integer type; they need not be of the same type. The expression in a modular_type_definition is likewise expected to be of any integer type.

    Legality Rules

  6. The simple_expressions of a signed_integer_type_definition shall be static, and their values shall be in the range System.Min_Int .. System.Max_Int.
  7. The expression of a modular_type_definition shall be static, and its value (the modulus) shall be positive, and shall be no greater than System.Max_Binary_Modulus if a power of 2, or no greater than System.Max_Nonbinary_Modulus if not.

    Static Semantics

  8. The set of values for a signed integer type is the (infinite) set of mathematical integers, though only values of the base range of the type are fully supported for run-time operations. The set of values for a modular integer type are the values from 0 to one less than the modulus, inclusive.
  9. A signed_integer_type_definition defines an integer type whose base range includes at least the values of the simple_expressions and is symmetric about zero, excepting possibly an extra negative value. A signed_integer_type_definition also defines a constrained first subtype of the type, with a range whose bounds are given by the values of the simple_expressions, converted to the type being defined.
  10. A modular_type_definition defines a modular type whose base range is from zero to one less than the given modulus. A modular_type_definition also defines a constrained first subtype of the type with a range that is the same as the base range of the type.
  11. There is a predefined signed integer subtype named Integer, declared in the visible part of package Standard. It is constrained to the base range of its type.
  12. Integer has two predefined subtypes, declared in the visible part of package Standard: 
  13. subtype Natural  is Integer range 0 .. Integer'Last;
subtype Positive is Integer range 1 .. Integer'Last;
  14. A type defined by an integer_type_definition is implicitly derived from root_integer, an anonymous predefined (specific) integer type, whose base range is System.Min_Int .. System.Max_Int. However, the base range of the new type is not inherited from root_integer, but is instead determined by the range or modulus specified by the integer_type_definition. Integer literals are all of the type universal_integer, the universal type, see section Derivation Classes, for the class rooted at root_integer, allowing their use with the operations of any integer type.
  15. The position number of an integer value is equal to the value.
  16. For every modular subtype S, the following attribute is defined:
  17. S'Modulus 
    S'Modulus yields the modulus of the type of S, as a value of
the type universal_integer.

    Dynamic Semantics

  18. The elaboration of an integer_type_definition creates the integer type and its first subtype.
  19. For a modular type, if the result of the execution of a predefined operator, see section Operators and Expression Evaluation is outside the base range of the type, the result is reduced modulo the modulus of the type to a value that is within the base range of the type.
  20. For a signed integer type, the exception Constraint_Error is raised by the execution of an operation that cannot deliver the correct result because it is outside the base range of the type. For any integer type, Constraint_Error is raised by the operators "/", "rem", and "mod" if the right operand is zero.

    Implementation Requirements

  21. In an implementation, the range of Integer shall include the range -2**15+1 .. +2**15-1.
  22. If Long_Integer is predefined for an implementation, then its range shall include the range -2**31+1 .. +2**31-1.
  23. System.Max_Binary_Modulus shall be at least 2**16.

    Implementation Permissions

  24. For the execution of a predefined operation of a signed integer type, the implementation need not raise Constraint_Error if the result is outside the base range of the type, so long as the correct result is produced.
  25. An implementation may provide additional predefined signed integer types, declared in the visible part of Standard, whose first subtypes have names of the form Short_Integer, Long_Integer, Short_Short_Integer, Long_Long_Integer, etc. Different predefined integer types are allowed to have the same base range. However, the range of Integer should be no wider than that of Long_Integer. Similarly, the range of Short_Integer (if provided) should be no wider than Integer. Corresponding recommendations apply to any other predefined integer types. There need not be a named integer type corresponding to each distinct base range supported by an implementation. The range of each first subtype should be the base range of its type.
  26. An implementation may provide nonstandard integer types, descendants of root_integer that are declared outside of the specification of package Standard, which need not have all the standard characteristics of a type defined by an integer_type_definition. For example, a nonstandard integer type might have an asymmetric base range or it might not be allowed as an array or loop index (a very long integer). Any type descended from a nonstandard integer type is also nonstandard. An implementation may place arbitrary restrictions on the use of such types; it is implementation defined whether operators that are predefined for "any integer type" are defined for a particular nonstandard integer type. In any case, such types are not permitted as explicit_generic_actual_parameters for formal scalar types -- see section Formal Scalar Types.
  27. For a one's complement machine, the high bound of the base range of a modular type whose modulus is one less than a power of 2 may be equal to the modulus, rather than one less than the modulus. It is implementation defined for which powers of 2, if any, this permission is exercised.

    Implementation Advice

  28. An implementation should support Long_Integer in addition to Integer if the target machine supports 32-bit (or longer) arithmetic. No other named integer subtypes are recommended for package Standard. Instead, appropriate named integer subtypes should be provided in the library package Interfaces, see section The Package Interfaces.
  29. An implementation for a two's complement machine should support modular types with a binary modulus up to System.Max_Int*2+2. An implementation should support a nonbinary modulus up to Integer'Last. NOTES
  30. (25) Integer literals are of the anonymous predefined integer type universal_integer. Other integer types have no literals. However, the overload resolution rules, see section The Context of Overload Resolution, allow expressions of the type universal_integer whenever an integer type is expected.
  31. (26) The same arithmetic operators are predefined for all signed integer types defined by a signed_integer_type_definition, see section Operators and Expression Evaluation. For modular types, these same operators are predefined, plus bit-wise logical operators (and, or, xor, and not). In addition, for the unsigned types declared in the language-defined package Interfaces, see section The Package Interfaces, functions are defined that provide bit-wise shifting and rotating.
  32. (27) Modular types match a generic_formal_parameter_declaration of the form "type T is mod <>;"; signed integer types match "type T is range <>;", see section Formal Scalar Types.

    Examples

  33. Examples of integer types and subtypes: 
  34. type Page_Num  is range 1 .. 2_000;
type Line_Size is range 1 .. Max_Line_Size;

  35. subtype Small_Int   is Integer   range -10 .. 10;
subtype Column_Ptr  is Line_Size range 1 .. 10;
subtype Buffer_Size is Integer   range 0 .. Max;

  36. type Byte        is mod 256; -- an unsigned byte
type Hash_Index  is mod 97;  -- modulus is prime

Operations of Discrete Types

Static Semantics

  1. For every discrete subtype S, the following attributes are defined:
  2. S'Pos
      S'Pos denotes a function with the following specification: 
    1. function S'Pos(Arg : S'Base)
  return universal_integer
    2. This function returns the position number of the value of Arg, as a value of type universal_integer.
  1. S'Val
      S'Val denotes a function with the following specification: 
    1. function S'Val(Arg : universal_integer)
  return S'Base
    2. This function returns a value of the type of S whose position number equals the value of Arg. For the evaluation of a call on S'Val, if there is no value in the base range of its type with the given position number, Constraint_Error is raised.

Implementation Advice

  1. For the evaluation of a call on S'Pos for an enumeration subtype, if the value of the operand does not correspond to the internal code for any enumeration literal of its type (perhaps due to an uninitialized variable), then the implementation should raise Program_Error. This is particularly important for enumeration types with noncontiguous internal codes specified by an enumeration_representation_clause. NOTES
  2. (28) Indexing and loop iteration use values of discrete types.
  3. (29) The predefined operations of a discrete type include the assignment operation, qualification, the membership tests, and the relational operators; for a boolean type they include the short-circuit control forms and the logical operators; for an integer type they include type conversion to and from other numeric types, as well as the binary and unary adding operators - and +, the multiplying operators, the unary operator abs, and the exponentiation operator. The assignment operation is described in section Assignment Statements. The other predefined operations are described in Section section Names and Expressions.
  4. (30) As for all types, objects of a discrete type have Size and Address attributes, see section Representation Attributes.
  5. (31) For a subtype of a discrete type, the result delivered by the attribute Val might not belong to the subtype; similarly, the actual parameter of the attribute Pos need not belong to the subtype. The following relations are satisfied (in the absence of an exception) by these attributes: 
  6. S'Val(S'Pos(X)) = X
S'Pos(S'Val(N)) = N

    Examples

  7. Examples of attributes of discrete subtypes: 
  8. --  For the types and subtypes declared in subclause
--  see section Enumeration Types, the following hold:

  9. --  Color'First   = White,   Color'Last   = Black
--  Rainbow'First = Red,     Rainbow'Last = Blue

  10. --  Color'Succ(Blue) = Rainbow'Succ(Blue) = Brown
--  Color'Pos(Blue)  = Rainbow'Pos(Blue)  = 4
--  Color'Val(0)     = Rainbow'Val(0)     = White

Real Types

  1. Real types provide approximations to the real numbers, with relative bounds on errors for floating point types, and with absolute bounds for fixed point types.

    Syntax 

  2. real_type_definition ::=
   floating_point_definition | fixed_point_definition

    Static Semantics

  3. A type defined by a real_type_definition is implicitly derived from root_real, an anonymous predefined (specific) real type. Hence, all real types, whether floating point or fixed point, are in the derivation class rooted at root_real.
  4. Real literals are all of the type universal_real, the universal type (see section Derivation Classes) for the class rooted at root_real, allowing their use with the operations of any real type. Certain multiplying operators have a result type of universal_fixed, see section Multiplying Operators, the universal type for the class of fixed point types, allowing the result of the multiplication or division to be used where any specific fixed point type is expected.

    Dynamic Semantics

  5. The elaboration of a real_type_definition consists of the elaboration of the floating_point_definition or the fixed_point_definition.

    Implementation Requirements

  6. An implementation shall perform the run-time evaluation of a use of a predefined operator of root_real with an accuracy at least as great as that of any floating point type definable by a floating_point_definition.

    Implementation Permissions

  7. For the execution of a predefined operation of a real type, the implementation need not raise Constraint_Error if the result is outside the base range of the type, so long as the correct result is produced, or the Machine_Overflows attribute of the type is false, see section Numeric Performance Requirements.
  8. An implementation may provide nonstandard real types, descendants of root_real that are declared outside of the specification of package Standard, which need not have all the standard characteristics of a type defined by a real_type_definition. For example, a nonstandard real type might have an asymmetric or unsigned base range, or its predefined operations might wrap around or "saturate" rather than overflow (modular or saturating arithmetic), or it might not conform to the accuracy model, see section Numeric Performance Requirements. Any type descended from a nonstandard real type is also nonstandard. An implementation may place arbitrary restrictions on the use of such types; it is implementation defined whether operators that are predefined for "any real type" are defined for a particular nonstandard real type. In any case, such types are not permitted as explicit_generic_actual_parameters for formal scalar types -- see section Formal Scalar Types. NOTES
  9. (32) As stated, real literals are of the anonymous predefined real type universal_real. Other real types have no literals. However, the overload resolution rules, see section The Context of Overload Resolution, allow expressions of the type universal_real whenever a real type is expected.

Floating Point Types

  1. For floating point types, the error bound is specified as a relative precision by giving the required minimum number of significant decimal digits.

    Syntax 

  2. floating_point_definition ::=
   digits static_expression [real_range_specification]

  3. real_range_specification ::=
   range static_simple_expression .. static_simple_expression

    Name Resolution Rules

  4. The requested decimal precision, which is the minimum number of significant decimal digits required for the floating point type, is specified by the value of the expression given after the reserved word digits. This expression is expected to be of any integer type.
  5. Each simple_expression of a real_range_specification is expected to be of any real type; the types need not be the same.

    Legality Rules

  6. The requested decimal precision shall be specified by a static expression whose value is positive and no greater than System.Max_Base_Digits. Each simple_expression of a real_range_specification shall also be static. If the real_range_specification is omitted, the requested decimal precision shall be no greater than System.Max_Digits.
  7. A floating_point_definition is illegal if the implementation does not support a floating point type that satisfies the requested decimal precision and range.

    Static Semantics

  8. The set of values for a floating point type is the (infinite) set of rational numbers. The machine numbers of a floating point type are the values of the type that can be represented exactly in every unconstrained variable of the type. The base range, see section Scalar Types, of a floating point type is symmetric around zero, except that it can include some extra negative values in some implementations.
  9. The base decimal precision of a floating point type is the number of decimal digits of precision representable in objects of the type. The safe range of a floating point type is that part of its base range for which the accuracy corresponding to the base decimal precision is preserved by all predefined operations.
  10. A floating_point_definition defines a floating point type whose base decimal precision is no less than the requested decimal precision. If a real_range_specification is given, the safe range of the floating point type (and hence, also its base range) includes at least the values of the simple expressions given in the real_range_specification. If a real_range_specification is not given, the safe (and base) range of the type includes at least the values of the range -10.0**(4*D) .. +10.0**(4*D) where D is the requested decimal precision. The safe range might include other values as well. The attributes Safe_First and Safe_Last give the actual bounds of the safe range.
  11. A floating_point_definition also defines a first subtype of the type. If a real_range_specification is given, then the subtype is constrained to a range whose bounds are given by a conversion of the values of the simple_expressions of the real_range_specification to the type being defined. Otherwise, the subtype is unconstrained.
  12. There is a predefined, unconstrained, floating point subtype named Float, declared in the visible part of package Standard.

    Dynamic Semantics

  13. The elaboration of a floating_point_definition creates the floating point type and its first subtype.

    Implementation Requirements

  14. In an implementation that supports floating point types with 6 or more digits of precision, the requested decimal precision for Float shall be at least 6.
  15. If Long_Float is predefined for an implementation, then its requested decimal precision shall be at least 11.

    Implementation Permissions

  16. An implementation is allowed to provide additional predefined floating point types, declared in the visible part of Standard, whose (unconstrained) first subtypes have names of the form Short_Float, Long_Float, Short_Short_Float, Long_Long_Float, etc. Different predefined floating point types are allowed to have the same base decimal precision. However, the precision of Float should be no greater than that of Long_Float. Similarly, the precision of Short_Float (if provided) should be no greater than Float. Corresponding recommendations apply to any other predefined floating point types. There need not be a named floating point type corresponding to each distinct base decimal precision supported by an implementation.

    Implementation Advice

  17. An implementation should support Long_Float in addition to Float if the target machine supports 11 or more digits of precision. No other named floating point subtypes are recommended for package Standard. Instead, appropriate named floating point subtypes should be provided in the library package Interfaces, see section The Package Interfaces. NOTES
  18. (33) If a floating point subtype is unconstrained, then assignments to variables of the subtype involve only Overflow_Checks, never Range_Checks.

    Examples

  19. Examples of floating point types and subtypes: 
  20. type Coefficient is digits 10 range -1.0 .. 1.0;

  21. type Real is digits 8;
type Mass is digits 7 range 0.0 .. 1.0E35;

  22. subtype Probability is Real range 0.0 .. 1.0;
--  a subtype with a smaller range

Operations of Floating Point Types

Static Semantics

  1. The following attribute is defined for every floating point subtype S:
  2. S'Digits 
    S'Digits denotes the requested decimal precision for the
subtype S. The value of this attribute is of the type
universal_integer. The requested decimal precision of the
base subtype of a floating point type T is defined to be the
largest value of d for which ceiling(d * log(10) /
log(T'Machine_Radix)) + 1 <= T'Model_Mantissa.
    NOTES
  3. (34) The predefined operations of a floating point type include the assignment operation, qualification, the membership tests, and explicit conversion to and from other numeric types. They also include the relational operators and the following predefined arithmetic operators: the binary and unary adding operators - and +, certain multiplying operators, the unary operator abs, and the exponentiation operator.
  4. (35) As for all types, objects of a floating point type have Size and Address attributes, see section Representation Attributes. Other attributes of floating point types are defined in section Attributes of Floating Point Types.

Fixed Point Types

  1. A fixed point type is either an ordinary fixed point type, or a decimal fixed point type. The error bound of a fixed point type is specified as an absolute value, called the delta of the fixed point type.

    Syntax 

  2. fixed_point_definition ::=
   ordinary_fixed_point_definition | decimal_fixed_point_definition

  3. ordinary_fixed_point_definition ::=
   delta static_expression real_range_specification

  4. decimal_fixed_point_definition ::=
   delta static_expression digits static_expression
     [real_range_specification]

  5. digits_constraint ::=
   digits static_expression [range_constraint]

    Name Resolution Rules

  6. For a type defined by a fixed_point_definition, the delta of the type is specified by the value of the expression given after the reserved word delta; this expression is expected to be of any real type. For a type defined by a decimal_fixed_point_definition (a decimal fixed point type), the number of significant decimal digits for its first subtype (the digits of the first subtype) is specified by the expression given after the reserved word digits; this expression is expected to be of any integer type.

    Legality Rules

  7. In a fixed_point_definition or digits_constraint, the expressions given after the reserved words delta and digits shall be static; their values shall be positive.
  8. The set of values of a fixed point type comprise the integral multiples of a number called the small of the type. For a type defined by an ordinary_fixed_point_definition (an ordinary fixed point type), the small may be specified by an attribute_definition_clause, see section Representation Attributes, if so specified, it shall be no greater than the delta of the type. If not specified, the small of an ordinary fixed point type is an implementation-defined power of two less than or equal to the delta.
  9. For a decimal fixed point type, the small equals the delta; the delta shall be a power of 10. If a real_range_specification is given, both bounds of the range shall be in the range -(10**digits-1)*delta .. +(10**digits-1)*delta.
  10. A fixed_point_definition is illegal if the implementation does not support a fixed point type with the given small and specified range or digits.
  11. For a subtype_indication with a digits_constraint, the subtype_mark shall denote a decimal fixed point subtype.

    Static Semantics

  12. The base range, see section Scalar Types of a fixed point type is symmetric around zero, except possibly for an extra negative value in some implementations.
  13. An ordinary_fixed_point_definition defines an ordinary fixed point type whose base range includes at least all multiples of small that are between the bounds specified in the real_range_specification. The base range of the type does not necessarily include the specified bounds themselves. An ordinary_fixed_point_definition also defines a constrained first subtype of the type, with each bound of its range given by the closer to zero of:
    1. the value of the conversion to the fixed point type of the corresponding expression of the real_range_specification;
    2. the corresponding bound of the base range.
  1. A decimal_fixed_point_definition defines a decimal fixed point type whose base range includes at least the range -(10**digits-1)*delta .. +(10**digits-1)*delta. A decimal_fixed_point_definition also defines a constrained first subtype of the type. If a real_range_specification is given, the bounds of the first subtype are given by a conversion of the values of the expressions of the real_range_specification. Otherwise, the range of the first subtype is -(10**digits-1)*delta .. +(10**digits-1)*delta.

    Dynamic Semantics

  2. The elaboration of a fixed_point_definition creates the fixed point type and its first subtype.
  3. For a digits_constraint on a decimal fixed point subtype with a given delta, if it does not have a range_constraint, then it specifies an implicit range -(10**D-1)*delta .. +(10**D-1)*delta, where D is the value of the expression. A digits_constraint is compatible with a decimal fixed point subtype if the value of the expression is no greater than the digits of the subtype, and if it specifies (explicitly or implicitly) a range that is compatible with the subtype.
  4. The elaboration of a digits_constraint consists of the elaboration of the range_constraint, if any. If a range_constraint is given, a check is made that the bounds of the range are both in the range -(10**D-1)*delta .. +(10**D-1)*delta, where D is the value of the (static) expression given after the reserved word digits. If this check fails, Constraint_Error is raised.

    Implementation Requirements

  5. The implementation shall support at least 24 bits of precision (including the sign bit) for fixed point types.

    Implementation Permissions

  6. Implementations are permitted to support only smalls that are a power of two. In particular, all decimal fixed point type declarations can be disallowed. Note however that conformance with the Information Systems Annex requires support for decimal smalls, and decimal fixed point type declarations with digits up to at least 18. NOTES
  7. (36) The base range of an ordinary fixed point type need not include the specified bounds themselves so that the range specification can be given in a natural way, such as: 
  8. type Fraction is delta 2.0**(-15) range -1.0 .. 1.0;
  9. With 2's complement hardware, such a type could have a signed 16-bit representation, using 1 bit for the sign and 15 bits for fraction, resulting in a base range of -1.0 .. 1.0-2.0**(-15).

    Examples

  10. Examples of fixed point types and subtypes: 
  11. type Volt is delta 0.125 range 0.0 .. 255.0;

  12. --  A pure fraction which requires all the available
--  space in a word can be declared as the type Fraction:

type Fraction is delta System.Fine_Delta range -1.0 .. 1.0;
--  Fraction'Last = 1.0 - System.Fine_Delta

  13. type Money is delta 0.01 digits 15;  -- decimal fixed point
subtype Salary is Money digits 10;
  -- Money'Last = 10.0**13 - 0.01, Salary'Last = 10.0**8 - 0.01

Operations of Fixed Point Types

Static Semantics

  1. The following attributes are defined for every fixed point subtype S:
  2. S'Small 
    S'Small denotes the small of the type of S. The value of
this attribute is of the type universal_real. Small may
be specified for nonderived fixed point types via an
attribute_definition_clause, see section Representation Attributes; the expression
of such a clause shall be static.
  3. S'Delta 
    S'Delta denotes the delta of the fixed point subtype S. The
value of this attribute is of the type universal_real.
  4. S'Fore 
    S'Fore yields the minimum number of characters needed
before the decimal point for the decimal representation
of any value of the subtype S, assuming that the
representation does not include an exponent, but
includes a one-character prefix that is either a minus
sign or a space. (This minimum number does not include
superfluous zeros or underlines, and is at least 2.) The
value of this attribute is of the type
universal_integer.
  5. S'Aft 
    S'Aft yields the number of decimal digits needed after the
decimal point to accommodate the delta of the subtype S,
unless the delta of the subtype S is greater than 0.1, in
which case the attribute yields the value one. (S'Aft is the
smallest positive integer N for which (10**N)*S'Delta is
greater than or equal to one.) The value of this attribute
is of the type universal_integer.
  6. The following additional attributes are defined for every decimal fixed point subtype S:
  7. S'Digits 
    S'Digits denotes the digits of the decimal fixed point
subtype S, which corresponds to the number of decimal digits
that are representable in objects of the subtype. The value
of this attribute is of the type universal_integer. Its
value is determined as follows:
    1. For a first subtype or a subtype defined by a subtype_indication with a digits_constraint, the digits is the value of the expression given after the reserved word digits;
    2. For a subtype defined by a subtype_indication without a digits_constraint, the digits of the subtype is the same as that of the subtype denoted by the subtype_mark in the subtype_indication.
    3. The digits of a base subtype is the largest integer D such that the range -(10**D-1)*delta .. +(10**D-1)*delta is included in the base range of the type.
  1. S'Scale 
    S'Scale denotes the scale of the subtype S, defined as the
value N such that S'Delta = 10.0**(-N). The scale indicates
the position of the point relative to the rightmost
significant digits of values of subtype S. The value of this
attribute is of the type universal_integer.
  2. S'Round
      S'Round denotes a function with the following specification: 
    1. function S'Round(X : universal_real)
  return S'Base
    2. The function returns the value obtained by rounding X (away from 0, if X is midway between two values of the type of S).
    NOTES
  1. (37) All subtypes of a fixed point type will have the same value for the Delta attribute, in the absence of delta_constraints, see section Reduced Accuracy Subtypes.
  2. (38) S'Scale is not always the same as S'Aft for a decimal subtype; for example, if S'Delta = 1.0 then S'Aft is 1 while S'Scale is 0.
  3. (39) The predefined operations of a fixed point type include the assignment operation, qualification, the membership tests, and explicit conversion to and from other numeric types. They also include the relational operators and the following predefined arithmetic operators: the binary and unary adding operators - and +, multiplying operators, and the unary operator abs.
  4. (40) As for all types, objects of a fixed point type have Size and Address attributes, see section Representation Attributes. Other attributes of fixed point types are defined in section Attributes of Fixed Point Types.

Array Types

  1. An array object is a composite object consisting of components which all have the same subtype. The name for a component of an array uses one or more index values belonging to specified discrete types. The value of an array object is a composite value consisting of the values of the components.

    Syntax 

  2. array_type_definition ::=
   unconstrained_array_definition | constrained_array_definition

  3. unconstrained_array_definition ::=
   array(index_subtype_definition {, index_subtype_definition})
     of component_definition

  4. index_subtype_definition ::= subtype_mark range <>

  5. constrained_array_definition ::=
   array (discrete_subtype_definition
     {, discrete_subtype_definition}) of component_definition

  6. discrete_subtype_definition ::= discrete_subtype_indication | range

  7. component_definition ::= [aliased] subtype_indication

    Name Resolution Rules

  8. For a discrete_subtype_definition that is a range, the range shall resolve to be of some specific discrete type; which discrete type shall be determined without using any context other than the bounds of the range itself (plus the preference for root_integer -- see section The Context of Overload Resolution.).

    Legality Rules

  9. Each index_subtype_definition or discrete_subtype_definition in an array_type_definition defines an index subtype; its type (the index type) shall be discrete.
  10. The subtype defined by the subtype_indication of a component_definition (the component subtype) shall be a definite subtype.
  11. Within the definition of a nonlimited composite type (or a limited composite type that later in its immediate scope becomes nonlimited -- section Private Operations, and section Limited Types.), if a component_definition contains the reserved word aliased and the type of the component is discriminated, then the nominal subtype of the component shall be constrained.

    Static Semantics

  12. An array is characterized by the number of indices (the dimensionality of the array), the type and position of each index, the lower and upper bounds for each index, and the subtype of the components. The order of the indices is significant.
  13. A one-dimensional array has a distinct component for each possible index value. A multidimensional array has a distinct component for each possible sequence of index values that can be formed by selecting one value for each index position (in the given order). The possible values for a given index are all the values between the lower and upper bounds, inclusive; this range of values is called the index range. The bounds of an array are the bounds of its index ranges. The length of a dimension of an array is the number of values of the index range of the dimension (zero for a null range). The length of a one-dimensional array is the length of its only dimension.
  14. An array_type_definition defines an array type and its first subtype. For each object of this array type, the number of indices, the type and position of each index, and the subtype of the components are as in the type definition; the values of the lower and upper bounds for each index belong to the corresponding index subtype of its type, except for null arrays, see section Index Constraints and Discrete Ranges.
  15. An unconstrained_array_definition defines an array type with an unconstrained first subtype. Each index_subtype_definition defines the corresponding index subtype to be the subtype denoted by the subtype_mark. The compound delimiter <> (called a box) of an index_subtype_definition stands for an undefined range (different objects of the type need not have the same bounds).
  16. A constrained_array_definition defines an array type with a constrained first subtype. Each discrete_subtype_definition defines the corresponding index subtype, as well as the corresponding index range for the constrained first subtype. The constraint of the first subtype consists of the bounds of the index ranges.
  17. The discrete subtype defined by a discrete_subtype_definition is either that defined by the subtype_indication, or a subtype determined by the range as follows:
    1. If the type of the range resolves to root_integer, then the discrete_subtype_definition defines a subtype of the predefined type Integer with bounds given by a conversion to Integer of the bounds of the range;
    2. Otherwise, the discrete_subtype_definition defines a subtype of the type of the range, with the bounds given by the range.
  1. The component_definition of an array_type_definition defines the nominal subtype of the components. If the reserved word aliased appears in the component_definition, then each component of the array is aliased, see section Access Types.

    Dynamic Semantics

  2. The elaboration of an array_type_definition creates the array type and its first subtype, and consists of the elaboration of any discrete_subtype_definitions and the component_definition.
  3. The elaboration of a discrete_subtype_definition creates the discrete subtype, and consists of the elaboration of the subtype_indication or the evaluation of the range. The elaboration of a component_definition in an array_type_definition consists of the elaboration of the subtype_indication. The elaboration of any discrete_subtype_definitions and the elaboration of the component_definition are performed in an arbitrary order. NOTES
  4. (41) All components of an array have the same subtype. In particular, for an array of components that are one-dimensional arrays, this means that all components have the same bounds and hence the same length.
  5. (42) Each elaboration of an array_type_definition creates a distinct array type. A consequence of this is that each object whose object_declaration contains an array_type_definition is of its own unique type.

    Examples

  6. Examples of type declarations with unconstrained array definitions: 
  7. type Vector     is array(Integer  range <>) of Real;

type Matrix     is array(Integer  range <>, Integer range <>)
  of Real;

type Bit_Vector is array(Integer  range <>) of Boolean;

type Roman      is array(Positive range <>) of
  Roman_Digit;  --  see section Character Types
  8. Examples of type declarations with constrained array definitions: 
  9. type Table    is array(1 .. 10) of Integer;
type Schedule is array(Day) of Boolean;
type Line     is array(1 .. Max_Line_Size) of Character;
  10. Examples of object declarations with array type definitions: 
  11. Grid : array(1 .. 80, 1 .. 100) of Boolean;
Mix  : array(Color range Red .. Green) of Boolean;
Page : array(Positive range <>) of Line :=  --  an array of arrays
  (1 | 50  => Line'(1 | Line'Last => '+', others => '-'),
  --  see section Array Aggregates
   2 .. 49 => Line'(1 | Line'Last => '|', others => ' '));
    -- Page is constrained by its initial value to (1..50)

Index Constraints and Discrete Ranges

  1. An index_constraint determines the range of possible values for every index of an array subtype, and thereby the corresponding array bounds.

    Syntax 

  2. index_constraint ::= (discrete_range {, discrete_range})

  3. discrete_range ::= discrete_subtype_indication | range

    Name Resolution Rules

  4. The type of a discrete_range is the type of the subtype defined by the subtype_indication, or the type of the range. For an index_constraint, each discrete_range shall resolve to be of the type of the corresponding index.

    Legality Rules

  5. An index_constraint shall appear only in a subtype_indication whose subtype_mark denotes either an unconstrained array subtype, or an unconstrained access subtype whose designated subtype is an unconstrained array subtype; in either case, the index_constraint shall provide a discrete_range for each index of the array type.

    Static Semantics

  6. A discrete_range defines a range whose bounds are given by the range, or by the range of the subtype defined by the subtype_indication.

    Dynamic Semantics

  7. An index_constraint is compatible with an unconstrained array subtype if and only if the index range defined by each discrete_range is compatible, see section Scalar Types, with the corresponding index subtype. If any of the discrete_ranges defines a null range, any array thus constrained is a null array, having no components. An array value satisfies an index_constraint if at each index position the array value and the index_constraint have the same index bounds.
  8. The elaboration of an index_constraint consists of the evaluation of the discrete_range(s), in an arbitrary order. The evaluation of a discrete_range consists of the elaboration of the subtype_indication or the evaluation of the range. NOTES
  9. (43) The elaboration of a subtype_indication consisting of a subtype_mark followed by an index_constraint checks the compatibility of the index_constraint with the subtype_mark, see section Subtype Declarations.
  10. (44) Even if an array value does not satisfy the index constraint of an array subtype, Constraint_Error is not raised on conversion to the array subtype, so long as the length of each dimension of the array value and the array subtype match (see section Type Conversions).

    Examples

  11. Examples of array declarations including an index constraint: 
  12. Board     : Matrix(1 .. 8,  1 .. 8);  --  see section Array Types
Rectangle : Matrix(1 .. 20, 1 .. 30);
Inverse   : Matrix(1 .. N,  1 .. N);  --  N need not be static

  13. Filter    : Bit_Vector(0 .. 31);
  14. Example of array declaration with a constrained array subtype: 
  15. My_Schedule : Schedule;
--  all arrays of type Schedule have the same bounds
  16. Example of record type with a component that is an array: 
  17. type Var_Line(Length : Natural) is
   record
      Image : String(1 .. Length);
   end record;

  18. Null_Line : Var_Line(0);  --  Null_Line.Image is a null array

Operations of Array Types

Legality Rules

  1. The argument N used in the attribute_designators for the N-th dimension of an array shall be a static expression of some integer type. The value of N shall be positive (nonzero) and no greater than the dimensionality of the array.

    Static Semantics

  2. The following attributes are defined for a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
  3. A'First 
    A'First denotes the lower bound of the first index range; its
type is the corresponding index type.
  4. A'First(N) 
    A'First(N) denotes the lower bound of the N-th index range;
its type is the corresponding index type.
  5. A'Last 
    A'Last denotes the upper bound of the first index range; its
type is the corresponding index type.
  6. A'Last(N) 
    A'Last(N) denotes the upper bound of the N-th index range;
its type is the corresponding index type.
  7. A'Range 
    A'Range is equivalent to the range A'First .. A'Last, except
that the prefix A is only evaluated once.
  8. A'Range(N) 
    A'Range(N) is equivalent to the range A'First(N) ..
A'Last(N), except that the prefix A is only evaluated once.
  9. A'Length 
    A'Length denotes the number of values of the first index
range (zero for a null range); its type is universal_integer.
  10. A'Length(N) 
    A'Length(N) denotes the number of values of the N-th index
range (zero for a null range); its type is universal_integer.

    Implementation Advice

  11. An implementation should normally represent multidimensional arrays in row-major order, consistent with the notation used for multidimensional array aggregates, see section Array Aggregates. However, if a pragma Convention(Fortran, ...) applies to a multidimensional array type, then column-major order should be used instead, see section Interfacing with Fortran. NOTES
  12. (45) The attribute_references A'First and A'First(1) denote the same value. A similar relation exists for the attribute_references A'Last, A'Range, and A'Length. The following relation is satisfied (except for a null array) by the above attributes if the index type is an integer type: 
  13. A'Length(N) = A'Last(N) - A'First(N) + 1
  14. (46) An array type is limited if its component type is limited, see section Limited Types.
  15. (47) The predefined operations of an array type include the membership tests, qualification, and explicit conversion. If the array type is not limited, they also include assignment and the predefined equality operators. For a one-dimensional array type, they include the predefined concatenation operators (if nonlimited) and, if the component type is discrete, the predefined relational operators; if the component type is boolean, the predefined logical operators are also included.
  16. (48) A component of an array can be named with an indexed_component. A value of an array type can be specified with an array_aggregate, unless the array type is limited. For a one-dimensional array type, a slice of the array can be named; also, string literals are defined if the component type is a character type.

    Examples

  17. Examples (using arrays declared in the examples of subclause section Index Constraints and Discrete Ranges): 
  18. --  Filter'First       =   0
--  Filter'Last        =  31
--  Filter'Length      =  32
--  Rectangle'Last(1)  =  20
--  Rectangle'Last(2)  =  30

String Types

Static Semantics

  1. A one-dimensional array type whose component type is a character type is called a string type.
  2. There are two predefined string types, String and Wide_String, each indexed by values of the predefined subtype Positive; these are declared in the visible part of package Standard: 
  3. subtype Positive is Integer range 1 .. Integer'Last;

  4. type String is array(Positive range <>) of Character;
type Wide_String is array(Positive range <>) of Wide_Character;
    NOTES
  5. (49) String literals, see section String Literals, and section Literals, are defined for all string types. The concatenation operator & is predefined for string types, as for all nonlimited one-dimensional array types. The ordering operators <, <=, >, and >= are predefined for string types, as for all one-dimensional discrete array types; these ordering operators correspond to lexicographic order, see section Relational Operators and Membership Tests.

    Examples

  6. Examples of string objects: 
  7. Stars      : String(1 .. 120) := (1 .. 120 => '*' );
Question   : constant String  := "How many characters?";
--  Question'First = 1, Question'Last = 20
--  Question'Length = 20 (the number of characters)

  8. Ask_Twice  : String  := Question & Question;
--  constrained to (1..40)

Ninety_Six : constant Roman   := "XCVI";
--  see section Character Types, and section Array Types

Discriminants

  1. A composite type (other than an array type) can have discriminants, which parameterize the type. A known_discriminant_part specifies the discriminants of a composite type. A discriminant of an object is a component of the object, and is either of a discrete type or an access type. An unknown_discriminant_part in the declaration of a partial view of a type specifies that the discriminants of the type are unknown for the given view; all subtypes of such a partial view are indefinite subtypes.

    Syntax 

  2. discriminant_part ::=
   unknown_discriminant_part | known_discriminant_part

  3. unknown_discriminant_part ::= (<>)

  4. known_discriminant_part ::=
   (discriminant_specification {; discriminant_specification})

  5. discriminant_specification ::=
     defining_identifier_list : subtype_mark
       [:= default_expression]
   | defining_identifier_list : access_definition
       [:= default_expression]

  6. default_expression ::= expression

    Name Resolution Rules

  7. The expected type for the default_expression of a discriminant_specification is that of the corresponding discriminant.

    Legality Rules

  8. A known_discriminant_part is only permitted in a declaration for a composite type that is not an array type (this includes generic formal types); a type declared with a known_discriminant_part is called a discriminated type, as is a type that inherits (known) discriminants.
  9. The subtype of a discriminant may be defined by a subtype_mark, in which case the subtype_mark shall denote a discrete or access subtype, or it may be defined by an access_definition (in which case the subtype_mark of the access_definition may denote any kind of subtype). A discriminant that is defined by an access_definition is called an access discriminant and is of an anonymous general access-to-variable type whose designated subtype is denoted by the subtype_mark of the access_definition.
  10. A discriminant_specification for an access discriminant shall appear only in the declaration for a task or protected type, or for a type with the reserved word limited in its (full) definition or in that of one of its ancestors. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, this rule applies also in the private part of an instance of a generic unit.
  11. Default_expressions shall be provided either for all or for none of the discriminants of a known_discriminant_part. No default_expressions are permitted in a known_discriminant_part in a declaration of a tagged type or a generic formal type.
  12. For a type defined by a derived_type_definition, if a known_discriminant_part is provided in its declaration, then:
    1. The parent subtype shall be constrained;
    2. If the parent type is not a tagged type, then each discriminant of the derived type shall be used in the constraint defining the parent subtype;
    3. If a discriminant is used in the constraint defining the parent subtype, the subtype of the discriminant shall be statically compatible (see section Statically Matching Constraints and Subtypes) with the subtype of the corresponding parent discriminant.
  1. The type of the default_expression, if any, for an access discriminant shall be convertible to the anonymous access type of the discriminant (see section Type Conversions).

    Static Semantics

  2. A discriminant_specification declares a discriminant; the subtype_mark denotes its subtype unless it is an access discriminant, in which case the discriminant's subtype is the anonymous access-to-variable subtype defined by the access_definition.
  3. For a type defined by a derived_type_definition, each discriminant of the parent type is either inherited, constrained to equal some new discriminant of the derived type, or constrained to the value of an expression. When inherited or constrained to equal some new discriminant, the parent discriminant and the discriminant of the derived type are said to correspond. Two discriminants also correspond if there is some common discriminant to which they both correspond. A discriminant corresponds to itself as well. If a discriminant of a parent type is constrained to a specific value by a derived_type_definition, then that discriminant is said to be specified by that derived_type_definition.
  4. A constraint that appears within the definition of a discriminated type depends on a discriminant of the type if it names the discriminant as a bound or discriminant value. A component_definition depends on a discriminant if its constraint depends on the discriminant, or on a discriminant that corresponds to it.
  5. A component depends on a discriminant if:
    1. Its component_definition depends on the discriminant; or
    2. It is declared in a variant_part that is governed by the discriminant; or
    3. It is a component inherited as part of a derived_type_definition, and the constraint of the parent_subtype_indication depends on the discriminant; or
    4. It is a subcomponent of a component that depends on the discriminant.
  1. Each value of a discriminated type includes a value for each component of the type that does not depend on a discriminant; this includes the discriminants themselves. The values of discriminants determine which other component values are present in the value of the discriminated type.
  2. A type declared with a known_discriminant_part is said to have known discriminants; its first subtype is unconstrained. A type declared with an unknown_discriminant_part is said to have unknown discriminants. A type declared without a discriminant_part has no discriminants, unless it is a derived type; if derived, such a type has the same sort of discriminants (known, unknown, or none) as its parent (or ancestor) type. A tagged class-wide type also has unknown discriminants. Any subtype of a type with unknown discriminants is an unconstrained and indefinite subtype, see section Types and Subtypes, and section Objects and Named Numbers.

    Dynamic Semantics

  3. An access_definition is elaborated when the value of a corresponding access discriminant is defined, either by evaluation of its default_expression or by elaboration of a discriminant_constraint. The elaboration of an access_definition creates the anonymous access type. When the expression defining the access discriminant is evaluated, it is converted to this anonymous access type, see section Type Conversions. NOTES
  4. (50) If a discriminated type has default_expressions for its discriminants, then unconstrained variables of the type are permitted, and the values of the discriminants can be changed by an assignment to such a variable. If defaults are not provided for the discriminants, then all variables of the type are constrained, either by explicit constraint or by their initial value; the values of the discriminants of such a variable cannot be changed after initialization.
  5. (51) The default_expression for a discriminant of a type is evaluated when an object of an unconstrained subtype of the type is created.
  6. (52) Assignment to a discriminant of an object (after its initialization) is not allowed, since the name of a discriminant is a constant; neither assignment_statements nor assignments inherent in passing as an in out or out parameter are allowed. Note however that the value of a discriminant can be changed by assigning to the enclosing object, presuming it is an unconstrained variable.
  7. (53) A discriminant that is of a named access type is not called an access discriminant; that term is used only for discriminants defined by an access_definition.

    Examples

  8. Examples of discriminated types: 
  9. type Buffer(Size : Buffer_Size := 100) is  --  see section Integer Types
   record
      Pos   : Buffer_Size := 0;
      Value : String(1 .. Size);
   end record;

  10. type Matrix_Rec(Rows, Columns : Integer) is
   record
      Mat : Matrix(1 .. Rows, 1 .. Columns);  --  see section Array Types
   end record;

  11. type Square(Side : Integer) is new
  Matrix_Rec(Rows => Side, Columns => Side);

  12. type Double_Square(Number : Integer) is
   record
      Left  : Square(Number);
      Right : Square(Number);
   end record;

    type Item(Number : Positive) is
   record
      Content : Integer;
      --  no component depends on the discriminant
   end record;

Discriminant Constraints

  1. A discriminant_constraint specifies the values of the discriminants for a given discriminated type.

    Syntax 

  2. discriminant_constraint ::=
   (discriminant_association {, discriminant_association})

  3. discriminant_association ::=
   [discriminant_selector_name
     {| discriminant_selector_name} =>] expression
    1. A discriminant_association is said to be named if it has one or more discriminant_selector_names; it is otherwise said to be positional. In a discriminant_constraint, any positional associations shall precede any named associations.

Name Resolution Rules

  1. Each selector_name of a named discriminant_association shall resolve to denote a discriminant of the subtype being constrained; the discriminants so named are the associated discriminants of the named association. For a positional association, the associated discriminant is the one whose discriminant_specification occurred in the corresponding position in the known_discriminant_part that defined the discriminants of the subtype being constrained.
  2. The expected type for the expression in a discriminant_association is that of the associated discriminant(s).

    Legality Rules

  3. A discriminant_constraint is only allowed in a subtype_indication whose subtype_mark denotes either an unconstrained discriminated subtype, or an unconstrained access subtype whose designated subtype is an unconstrained discriminated subtype.
  4. A named discriminant_association with more than one selector_name is allowed only if the named discriminants are all of the same type. A discriminant_constraint shall provide exactly one value for each discriminant of the subtype being constrained.
  5. The expression associated with an access discriminant shall be of a type convertible to the anonymous access type.

    Dynamic Semantics

  6. A discriminant_constraint is compatible with an unconstrained discriminated subtype if each discriminant value belongs to the subtype of the corresponding discriminant.
  7. A composite value satisfies a discriminant constraint if and only if each discriminant of the composite value has the value imposed by the discriminant constraint.
  8. For the elaboration of a discriminant_constraint, the expressions in the discriminant_associations are evaluated in an arbitrary order and converted to the type of the associated discriminant (which might raise Constraint_Error -- see section Type Conversions.); the expression of a named association is evaluated (and converted) once for each associated discriminant. The result of each evaluation and conversion is the value imposed by the constraint for the associated discriminant. NOTES
  9. (54) The rules of the language ensure that a discriminant of an object always has a value, either from explicit or implicit initialization.

    Examples

  10. Examples (using types declared above in clause section Discriminants): 
  11. Large   : Buffer(200);  --  constrained, always 200 characters
                        --   (explicit discriminant value)
Message : Buffer;       --  unconstrained, initially 100 characters
                        --   (default discriminant value)
Basis   : Square(5);    --  constrained, always 5 by 5
Illegal : Square;       --  illegal, a Square has to be constrained

Operations of Discriminated Types

  1. If a discriminated type has default_expressions for its discriminants, then unconstrained variables of the type are permitted, and the discriminants of such a variable can be changed by assignment to the variable. For a formal parameter of such a type, an attribute is provided to determine whether the corresponding actual parameter is constrained or unconstrained.

    Static Semantics

  2. For a prefix A that is of a discriminated type (after any implicit dereference), the following attribute is defined:
  3. A'Constrained 
    Yields the value True if A denotes a constant, a value, or a
constrained variable, and False otherwise.

    Erroneous Execution

  4. The execution of a construct is erroneous if the construct has a constituent that is a name denoting a subcomponent that depends on discriminants, and the value of any of these discriminants is changed by this execution between evaluating the name and the last use (within this execution) of the subcomponent denoted by the name.

Record Types

  1. A record object is a composite object consisting of named components. The value of a record object is a composite value consisting of the values of the components.

    Syntax 

  2. record_type_definition ::=
   [[abstract] tagged] [limited] record_definition

  3. record_definition ::=
     record
        component_list
     end record
   | null record

  4. component_list ::=
     component_item {component_item}
   | {component_item} variant_part
   |  null;

  5. component_item ::= component_declaration | representation_clause

  6. component_declaration ::=
   defining_identifier_list : component_definition
     [:= default_expression];

    Name Resolution Rules

  7. The expected type for the default_expression, if any, in a component_declaration is the type of the component.

    Legality Rules

  8. A default_expression is not permitted if the component is of a limited type.
  9. Each component_declaration declares a component of the record type. Besides components declared by component_declarations, the components of a record type include any components declared by discriminant_specifications of the record type declaration. The identifiers of all components of a record type shall be distinct.
  10. Within a type_declaration, a name that denotes a component, protected subprogram, or entry of the type is allowed only in the following cases:
    1. A name that denotes any component, protected subprogram, or entry is allowed within a representation item that occurs within the declaration of the composite type.
    2. A name that denotes a noninherited discriminant is allowed within the declaration of the type, but not within the discriminant_part. If the discriminant is used to define the constraint of a component, the bounds of an entry family, or the constraint of the parent subtype in a derived_type_definition then its name shall appear alone as a direct_name (not as part of a larger expression or expanded name). A discriminant shall not be used to define the constraint of a scalar component.
  1. If the name of the current instance of a type, see section The Context of Overload Resolution, is used to define the constraint of a component, then it shall appear as a direct_name that is the prefix of an attribute_reference whose result is of an access type, and the attribute_reference shall appear alone.

    Static Semantics

  2. The component_definition of a component_declaration defines the (nominal) subtype of the component. If the reserved word aliased appears in the component_definition, then the component is aliased, see section Access Types.
  3. If the component_list of a record type is defined by the reserved word null and there are no discriminants, then the record type has no components and all records of the type are null records. A record_definition of null record is equivalent to record null; end record.

    Dynamic Semantics

  4. The elaboration of a record_type_definition creates the record type and its first subtype, and consists of the elaboration of the record_definition. The elaboration of a record_definition consists of the elaboration of its component_list, if any.
  5. The elaboration of a component_list consists of the elaboration of the component_items and variant_part, if any, in the order in which they appear. The elaboration of a component_declaration consists of the elaboration of the component_definition.
  6. Within the definition of a composite type, if a component_definition or discrete_subtype_definition, see section Entries and Accept Statements, includes a name that denotes a discriminant of the type, or that is an attribute_reference whose prefix denotes the current instance of the type, the expression containing the name is called a per-object expression, and the constraint being defined is called a per-object constraint. For the elaboration of a component_definition of a component_declaration, if the constraint of the subtype_indication is not a per-object constraint, then the subtype_indication is elaborated. On the other hand, if the constraint is a per-object constraint, then the elaboration consists of the evaluation of any included expression that is not part of a per-object expression. NOTES
  7. (55) A component_declaration with several identifiers is equivalent to a sequence of single component_declarations, as explained in section Object Declarations.
  8. (56) The default_expression of a record component is only evaluated upon the creation of a default-initialized object of the record type (presuming the object has the component, if it is in a variant_part -- see section Object Declarations).
  9. (57) The subtype defined by a component_definition, see section Array Types, has to be a definite subtype.
  10. (58) If a record type does not have a variant_part, then the same components are present in all values of the type.
  11. (59) A record type is limited if it has the reserved word limited in its definition, or if any of its components are limited, see section Limited Types.
  12. (60) The predefined operations of a record type include membership tests, qualification, and explicit conversion. If the record type is nonlimited, they also include assignment and the predefined equality operators.
  13. (61) A component of a record can be named with a selected_component. A value of a record can be specified with a record_aggregate, unless the record type is limited.

    Examples

  14. Examples of record type declarations: 
  15. type Date is
   record
      Day   : Integer range 1 .. 31;
      Month : Month_Name;
      Year  : Integer range 0 .. 4000;
   end record;

  16. type Complex is
   record
      Re : Real := 0.0;
      Im : Real := 0.0;
   end record;
  17. Examples of record variables: 
  18. Tomorrow, Yesterday : Date;
A, B, C : Complex;

  19. -- both components of A, B, and C are implicitly initialized to zero

Variant Parts and Discrete Choices

  1. A record type with a variant_part specifies alternative lists of components. Each variant defines the components for the value or values of the discriminant covered by its discrete_choice_list.

    Syntax 

  2. variant_part ::=
   case discriminant_direct_name is
      variant
      {variant}
   end case;

  3. variant ::=
   when discrete_choice_list =>
      component_list

  4. discrete_choice_list ::= discrete_choice {| discrete_choice}

  5. discrete_choice ::= expression | discrete_range | others

    Name Resolution Rules

  6. The discriminant_direct_name shall resolve to denote a discriminant (called the discriminant of the variant_part) specified in the known_discriminant_part of the full_type_declaration that contains the variant_part. The expected type for each discrete_choice in a variant is the type of the discriminant of the variant_part.

    Legality Rules

  7. The discriminant of the variant_part shall be of a discrete type.
  8. The expressions and discrete_ranges given as discrete_choices in a variant_part shall be static. The discrete_choice others shall appear alone in a discrete_choice_list, and such a discrete_choice_list, if it appears, shall be the last one in the enclosing construct.
  9. A discrete_choice is defined to cover a value in the following cases:
    1. A discrete_choice that is an expression covers a value if the value equals the value of the expression converted to the expected type.
    2. A discrete_choice that is a discrete_range covers all values (possibly none) that belong to the range.
    3. The discrete_choice others covers all values of its expected type that are not covered by previous discrete_choice_lists of the same construct.
  1. A discrete_choice_list covers a value if one of its discrete_choices covers the value.
  2. The possible values of the discriminant of a variant_part shall be covered as follows:
    1. If the discriminant is of a static constrained scalar subtype, then each non-others discrete_choice shall cover only values in that subtype, and each value of that subtype shall be covered by some discrete_choice (either explicitly or by others);
    2. If the type of the discriminant is a descendant of a generic formal scalar type then the variant_part shall have an others discrete_choice;
    3. Otherwise, each value of the base range of the type of the discriminant shall be covered (either explicitly or by others).
  1. Two distinct discrete_choices of a variant_part shall not cover the same value.

    Static Semantics

  2. If the component_list of a variant is specified by null, the variant has no components.
  3. The discriminant of a variant_part is said to govern the variant_part and its variants. In addition, the discriminant of a derived type governs a variant_part and its variants if it corresponds, see section Discriminants, to the discriminant of the variant_part.

    Dynamic Semantics

  4. A record value contains the values of the components of a particular variant only if the value of the discriminant governing the variant is covered by the discrete_choice_list of the variant. This rule applies in turn to any further variant that is, itself, included in the component_list of the given variant.
  5. The elaboration of a variant_part consists of the elaboration of the component_list of each variant in the order in which they appear.

    Examples

  6. Example of record type with a variant part: 
  7. type Device is (Printer, Disk, Drum);
type State  is (Open, Closed);

  8. type Peripheral(Unit : Device := Disk) is
   record
      Status : State;
      case Unit is
         when Printer =>
            Line_Count : Integer range 1 .. Page_Size;
         when others =>
            Cylinder   : Cylinder_Index;
            Track      : Track_Number;
         end case;
      end record;
  9. Examples of record subtypes: 
  10. subtype Drum_Unit is Peripheral(Drum);
subtype Disk_Unit is Peripheral(Disk);
  11. Examples of constrained record variables: 
  12. Writer   : Peripheral(Unit  => Printer);
Archive  : Disk_Unit;

Tagged Types and Type Extensions

  1. Tagged types and type extensions support object-oriented programming, based on inheritance with extension and run-time polymorphism via dispatching operations.

    Static Semantics

  2. A record type or private type that has the reserved word tagged in its declaration is called a tagged type. When deriving from a tagged type, additional components may be defined. As for any derived type, additional primitive subprograms may be defined, and inherited primitive subprograms may be overridden. The derived type is called an extension of the ancestor type, or simply a type extension. Every type extension is also a tagged type, and is either a record extension or a private extension of some other tagged type. A record extension is defined by a derived_type_definition with a record_extension_part. A private extension, which is a partial view of a record extension, can be declared in the visible part of a package, see section Private Types and Private Extensions, or in a generic formal part, see section Formal Private and Derived Types.
  3. An object of a tagged type has an associated (run-time) tag that identifies the specific tagged type used to create the object originally. The tag of an operand of a class-wide tagged type T'Class controls which subprogram body is to be executed when a primitive subprogram of type T is applied to the operand, see section Dispatching Operations of Tagged Types, using a tag to control which body to execute is called dispatching.
  4. The tag of a specific tagged type identifies the full_type_declaration of the type. If a declaration for a tagged type occurs within a generic_package_declaration, then the corresponding type declarations in distinct instances of the generic package are associated with distinct tags. For a tagged type that is local to a generic package body, the language does not specify whether repeated instantiations of the generic body result in distinct tags.
  5. The following language-defined library package exists: 
  6. package Ada.Tags is
    type Tag is private;

  7.     function Expanded_Name(T : Tag) return String;
    function External_Tag(T : Tag) return String;
    function Internal_Tag(External : String) return Tag;

  8.     Tag_Error : exception;

  9. private
   ... -- not specified by the language
end Ada.Tags;
  10. The function Expanded_Name returns the full expanded name of the first subtype of the specific type identified by the tag, in upper case, starting with a root library unit. The result is implementation defined if the type is declared within an unnamed block_statement.
  11. The function External_Tag returns a string to be used in an external representation for the given tag. The call External_Tag(S'Tag) is equivalent to the attribute_reference S'External_Tag, see section Representation Attributes.
  12. The function Internal_Tag returns the tag that corresponds to the given external tag, or raises Tag_Error if the given string is not the external tag for any specific type of the partition.
  13. For every subtype S of a tagged type T (specific or class-wide), the following attributes are defined:
  14. S'Class 
    S'Class denotes a subtype of the class-wide type (called
T'Class in this International Standard) for the class rooted
at T (or if S already denotes a class-wide subtype, then
S'Class is the same as S).
    1. S'Class is unconstrained. However, if S is constrained, then the values of S'Class are only those that when converted to the type T belong to S.
  1. S'Tag 
    S'Tag denotes the tag of the type T (or if T is class-wide,
the tag of the root type of the corresponding class). The
value of this attribute is of type Tag.
  2. Given a prefix X that is of a class-wide tagged type (after any implicit dereference), the following attribute is defined:
  3. X'Tag 
    X'Tag denotes the tag of X. The value of this attribute is of
type Tag.

    Dynamic Semantics

  4. The tag associated with an object of a tagged type is determined as follows:
    1. The tag of a stand-alone object, a component, or an aggregate of a specific tagged type T identifies T.
    2. The tag of an object created by an allocator for an access type with a specific designated tagged type T, identifies T.
    3. The tag of an object of a class-wide tagged type is that of its initialization expression.
    4. The tag of the result returned by a function whose result type is a specific tagged type T identifies T.
    5. The tag of the result returned by a function with a class-wide result type is that of the return expression.
  1. The tag is preserved by type conversion and by parameter passing. The tag of a value is the tag of the associated object, see section Formal Parameter Modes.

    Implementation Permissions

  2. The implementation of the functions in Ada.Tags may raise Tag_Error if no specific type corresponding to the tag passed as a parameter exists in the partition at the time the function is called. NOTES
  3. (62) A type declared with the reserved word tagged should normally be declared in a package_specification, so that new primitive subprograms can be declared for it.
  4. (63) Once an object has been created, its tag never changes.
  5. (64) Class-wide types are defined to have unknown discriminants (see section Discriminants). This means that objects of a class-wide type have to be explicitly initialized (whether created by an object_declaration or an allocator), and that aggregates have to be explicitly qualified with a specific type when their expected type is class-wide.
  6. (65) If S denotes an untagged private type whose full type is tagged, then S'Class is also allowed before the full type definition, but only in the private part of the package in which the type is declared (see section Private Operations). Similarly, the Class attribute is defined for incomplete types whose full type is tagged, but only within the library unit in which the incomplete type is declared, see section Incomplete Type Declarations.

    Examples

  7. Examples of tagged record types: 
  8. type Point is tagged
  record
    X, Y : Real := 0.0;
  end record;

  9. type Expression is tagged null record;
  -- Components will be added by each extension

Type Extensions

  1. Every type extension is a tagged type, and is either a record extension or a private extension of some other tagged type.

    Syntax 

  2. record_extension_part ::= with record_definition

    Legality Rules

  3. The parent type of a record extension shall not be a class-wide type. If the parent type is nonlimited, then each of the components of the record_extension_part shall be nonlimited. The accessibility level (see section Operations of Access Types) of a record extension shall not be statically deeper than that of its parent type. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, these rules apply also in the private part of an instance of a generic unit.
  4. A type extension shall not be declared in a generic body if the parent type is declared outside that body.

    Dynamic Semantics

  5. The elaboration of a record_extension_part consists of the elaboration of the record_definition. NOTES
  6. (66) The term "type extension" refers to a type as a whole. The term "extension part" refers to the piece of text that defines the additional components (if any) the type extension has relative to its specified ancestor type.
  7. (67) The accessibility rules imply that a tagged type declared in a library package_specification can be extended only at library level or as a generic formal. When the extension is declared immediately within a package_body, primitive subprograms are inherited and are overridable, but new primitive subprograms cannot be added.
  8. (68) A name that denotes a component (including a discriminant) of the parent type is not allowed within the record_extension_part. Similarly, a name that denotes a component defined within the record_extension_part is not allowed within the record_extension_part. It is permissible to use a name that denotes a discriminant of the record extension, providing there is a new known_discriminant_part in the enclosing type declaration. (The full rule is given in section Record Types.)
  9. (69) Each visible component of a record extension has to have a unique name, whether the component is (visibly) inherited from the parent type or declared in the record_extension_part, see section Visibility.

    Examples

  10. Examples of record extensions (of types defined above in section Tagged Types and Type Extensions.): 
  11. type Painted_Point is new Point with
  record
    Paint : Color := White;
  end record;
    -- Components X and Y are inherited

  12. Origin : constant Painted_Point := (X | Y => 0.0, Paint => Black);

  13. type Literal is new Expression with
  record                 -- a leaf in an Expression tree
    Value : Real;
  end record;

  14. type Expr_Ptr is access all Expression'Class;
--  see section Access Types

  15. type Binary_Operation is new Expression with
  record       -- an internal node in an Expression tree
    Left, Right : Expr_Ptr;
  end record;

  16. type Addition is new Binary_Operation with null record;
type Subtraction is new Binary_Operation with null record;
-- No additional components needed for these extensions

  17. Tree : Expr_Ptr :=  -- A tree representation of "5.0 + (13.0-7.0)"
   new Addition'(
      Left  => new Literal'(Value => 5.0),
      Right => new Subtraction'(
         Left  => new Literal'(Value => 13.0),
         Right => new Literal'(Value => 7.0)));

Dispatching Operations of Tagged Types

  1. The primitive subprograms of a tagged type are called dispatching operations. A dispatching operation can be called using a statically determined controlling tag, in which case the body to be executed is determined at compile time. Alternatively, the controlling tag can be dynamically determined, in which case the call dispatches to a body that is determined at run time; such a call is termed a dispatching call. As explained below, the properties of the operands and the context of a particular call on a dispatching operation determine how the controlling tag is determined, and hence whether or not the call is a dispatching call. Run-time polymorphism is achieved when a dispatching operation is called by a dispatching call.

    Static Semantics

  2. A call on a dispatching operation is a call whose name or prefix denotes the declaration of a primitive subprogram of a tagged type, that is, a dispatching operation. A controlling operand in a call on a dispatching operation of a tagged type T is one whose corresponding formal parameter is of type T or is of an anonymous access type with designated type T; the corresponding formal parameter is called a controlling formal parameter. If the controlling formal parameter is an access parameter, the controlling operand is the object designated by the actual parameter, rather than the actual parameter itself. If the call is to a (primitive) function with result type T, then the call has a controlling result -- the context of the call can control the dispatching.
  3. A name or expression of a tagged type is either statically tagged, dynamically tagged, or tag indeterminate, according to whether, when used as a controlling operand, the tag that controls dispatching is determined statically by the operand's (specific) type, dynamically by its tag at run time, or from context. A qualified_expression or parenthesized expression is statically, dynamically, or indeterminately tagged according to its operand. For other kinds of names and expressions, this is determined as follows:
    1. The name or expression is statically tagged if it is of a specific tagged type and, if it is a call with a controlling result, it has at least one statically tagged controlling operand;
    2. The name or expression is dynamically tagged if it is of a class-wide type, or it is a call with a controlling result and at least one dynamically tagged controlling operand;
    3. The name or expression is tag indeterminate if it is a call with a controlling result, all of whose controlling operands (if any) are tag indeterminate.
  1. A type_conversion is statically or dynamically tagged according to whether the type determined by the subtype_mark is specific or class-wide, respectively. For a controlling operand that is designated by an actual parameter, the controlling operand is statically or dynamically tagged according to whether the designated type of the actual parameter is specific or class-wide, respectively.

    Legality Rules

  2. A call on a dispatching operation shall not have both dynamically tagged and statically tagged controlling operands.
  3. If the expected type for an expression or name is some specific tagged type, then the expression or name shall not be dynamically tagged unless it is a controlling operand in a call on a dispatching operation. Similarly, if the expected type for an expression is an anonymous access-to-specific tagged type, then the expression shall not be of an access-to-class-wide type unless it designates a controlling operand in a call on a dispatching operation.
  4. In the declaration of a dispatching operation of a tagged type, everywhere a subtype of the tagged type appears as a subtype of the profile, see section Subprogram Declarations, it shall statically match the first subtype of the tagged type. If the dispatching operation overrides an inherited subprogram, it shall be subtype conformant with the inherited subprogram. A dispatching operation shall not be of convention Intrinsic. If a dispatching operation overrides the predefined equals operator, then it shall be of convention Ada (either explicitly or by default -- see section Conformance Rules.).
  5. The default_expression for a controlling formal parameter of a dispatching operation shall be tag indeterminate. A controlling formal parameter that is an access parameter shall not have a default_expression.
  6. A given subprogram shall not be a dispatching operation of two or more distinct tagged types.
  7. The explicit declaration of a primitive subprogram of a tagged type shall occur before the type is frozen, see section Freezing Rules. For example, new dispatching operations cannot be added after objects or values of the type exist, nor after deriving a record extension from it, nor after a body.

    Dynamic Semantics

  8. For the execution of a call on a dispatching operation of a type T, the controlling tag value determines which subprogram body is executed. The controlling tag value is defined as follows:
    1. If one or more controlling operands are statically tagged, then the controlling tag value is statically determined to be the tag of T.
    2. If one or more controlling operands are dynamically tagged, then the controlling tag value is not statically determined, but is rather determined by the tags of the controlling operands. If there is more than one dynamically tagged controlling operand, a check is made that they all have the same tag. If this check fails, Constraint_Error is raised unless the call is a function_call whose name denotes the declaration of an equality operator (predefined or user defined) that returns Boolean, in which case the result of the call is defined to indicate inequality, and no subprogram_body is executed. This check is performed prior to evaluating any tag-indeterminate controlling operands.
    3. If all of the controlling operands are tag-indeterminate, then:
      1. If the call has a controlling result and is itself a (possibly parenthesized or qualified) controlling operand of an enclosing call on a dispatching operation of type T, then its controlling tag value is determined by the controlling tag value of this enclosing call;
      2. Otherwise, the controlling tag value is statically determined to be the tag of type T.
  1. For the execution of a call on a dispatching operation, the body executed is the one for the corresponding primitive subprogram of the specific type identified by the controlling tag value. The body for an explicitly declared dispatching operation is the corresponding explicit body for the subprogram. The body for an implicitly declared dispatching operation that is overridden is the body for the overriding subprogram, even if the overriding occurs in a private part. The body for an inherited dispatching operation that is not overridden is the body of the corresponding subprogram of the parent or ancestor type. NOTES
  2. (70) The body to be executed for a call on a dispatching operation is determined by the tag; it does not matter whether that tag is determined statically or dynamically, and it does not matter whether the subprogram's declaration is visible at the place of the call.
  3. (71) This subclause covers calls on primitive subprograms of a tagged type. Rules for tagged type membership tests are described in 4.5.2. Controlling tag determination for an assignment_statement is described in section Assignment Statements.
  4. (72) A dispatching call can dispatch to a body whose declaration is not visible at the place of the call.
  5. (73) A call through an access-to-subprogram value is never a dispatching call, even if the access value designates a dispatching operation. Similarly a call whose prefix denotes a subprogram_renaming_declaration cannot be a dispatching call unless the renaming itself is the declaration of a primitive subprogram.

Abstract Types and Subprograms

  1. An abstract type is a tagged type intended for use as a parent type for type extensions, but which is not allowed to have objects of its own. An abstract subprogram is a subprogram that has no body, but is intended to be overridden at some point when inherited. Because objects of an abstract type cannot be created, a dispatching call to an abstract subprogram always dispatches to some overriding body.

    Legality Rules

  2. An abstract type is a specific type that has the reserved word abstract in its declaration. Only a tagged type is allowed to be declared abstract.
  3. A subprogram declared by an abstract_subprogram_declaration, see section Subprogram Declarations, is an abstract subprogram. If it is a primitive subprogram of a tagged type, then the tagged type shall be abstract.
  4. For a derived type, if the parent or ancestor type has an abstract primitive subprogram, or a primitive function with a controlling result, then:
    1. If the derived type is abstract or untagged, the inherited subprogram is abstract.
    2. Otherwise, the subprogram shall be overridden with a nonabstract subprogram; for a type declared in the visible part of a package, the overriding may be either in the visible or the private part. However, if the type is a generic formal type, the subprogram need not be overridden for the formal type itself; a nonabstract version will necessarily be provided by the actual type.
  1. A call on an abstract subprogram shall be a dispatching call; nondispatching calls to an abstract subprogram are not allowed.
  2. The type of an aggregate, or of an object created by an object_declaration or an allocator, or a generic formal object of mode in, shall not be abstract. The type of the target of an assignment operation, see section Assignment Statements, shall not be abstract. The type of a component shall not be abstract. If the result type of a function is abstract, then the function shall be abstract.
  3. If a partial view is not abstract, the corresponding full view shall not be abstract. If a generic formal type is abstract, then for each primitive subprogram of the formal that is not abstract, the corresponding primitive subprogram of the actual shall not be abstract.
  4. For an abstract type declared in a visible part, an abstract primitive subprogram shall not be declared in the private part, unless it is overriding an abstract subprogram implicitly declared in the visible part. For a tagged type declared in a visible part, a primitive function with a controlling result shall not be declared in the private part, unless it is overriding a function implicitly declared in the visible part.
  5. A generic actual subprogram shall not be an abstract subprogram. The prefix of an attribute_reference for the Access, Unchecked_Access, or Address attributes shall not denote an abstract subprogram. NOTES
  6. (74) Abstractness is not inherited; to declare an abstract type, the reserved word abstract has to be used in the declaration of the type extension.
  7. (75) A class-wide type is never abstract. Even if a class is rooted at an abstract type, the class-wide type for the class is not abstract, and an object of the class-wide type can be created; the tag of such an object will identify some nonabstract type in the class.

    Examples

  8. Example of an abstract type representing a set of natural numbers: 
  9. package Sets is
    subtype Element_Type is Natural;
    type Set is abstract tagged null record;
    function Empty return Set is abstract;
    function Union(Left, Right : Set) return Set is abstract;
    function Intersection(Left, Right : Set) return Set is abstract;
    function Unit_Set(Element : Element_Type) return Set is abstract;
    procedure Take
      (Element : out Element_Type;
       From : in out Set) is abstract;
end Sets;
    NOTES
  10. (76) Notes on the example: Given the above abstract type, one could then derive various (nonabstract) extensions of the type, representing alternative implementations of a set. One might use a bit vector, but impose an upper bound on the largest element representable, while another might use a hash table, trading off space for flexibility.

Access Types

  1. A value of an access type (an access value) provides indirect access to the object or subprogram it designates. Depending on its type, an access value can designate either subprograms, objects created by allocators (see section Allocators) or more generally aliased objects of an appropriate type.

    Syntax 

  2. access_type_definition ::=
     access_to_object_definition
   | access_to_subprogram_definition

  3. access_to_object_definition ::=
    access [general_access_modifier] subtype_indication

  4. general_access_modifier ::= all | constant

  5. access_to_subprogram_definition ::=
     access [protected] procedure parameter_profile
   | access [protected] function  parameter_and_result_profile

  6. access_definition ::= access subtype_mark

    Static Semantics

  7. There are two kinds of access types, access-to-object types, whose values designate objects, and access-to-subprogram types, whose values designate subprograms. Associated with an access-to-object type is a storage pool; several access types may share the same storage pool. A storage pool is an area of storage used to hold dynamically allocated objects (called pool elements) created by allocators; storage pools are described further in section Storage Management.
  8. Access-to-object types are further subdivided into pool-specific access types, whose values can designate only the elements of their associated storage pool, and general access types, whose values can designate the elements of any storage pool, as well as aliased objects created by declarations rather than allocators, and aliased subcomponents of other objects.
  9. A view of an object is defined to be aliased if it is defined by an object_declaration or component_definition with the reserved word aliased, or by a renaming of an aliased view. In addition, the dereference of an access-to-object value denotes an aliased view, as does a view conversion, see section Type Conversions of an aliased view. Finally, the current instance of a limited type, and a formal parameter or generic formal object of a tagged type are defined to be aliased. Aliased views are the ones that can be designated by an access value. If the view defined by an object_declaration is aliased, and the type of the object has discriminants, then the object is constrained; if its nominal subtype is unconstrained, then the object is constrained by its initial value. Similarly, if the object created by an allocator has discriminants, the object is constrained, either by the designated subtype, or by its initial value.
  10. An access_to_object_definition defines an access-to-object type and its first subtype; the subtype_indication defines the designated subtype of the access type. If a general_access_modifier appears, then the access type is a general access type. If the modifier is the reserved word constant, then the type is an access-to-constant type; a designated object cannot be updated through a value of such a type. If the modifier is the reserved word all, then the type is an access-to-variable type; a designated object can be both read and updated through a value of such a type. If no general_access_modifier appears in the access_to_object_definition, the access type is a pool-specific access-to-variable type.
  11. An access_to_subprogram_definition defines an access-to-subprogram type and its first subtype; the parameter_profile or parameter_and_result_profile defines the designated profile of the access type. There is a calling convention associated with the designated profile; only subprograms with this calling convention can be designated by values of the access type. By default, the calling convention is "protected" if the reserved word protected appears, and "Ada" otherwise. See Annex section Interface to Other Languages (normative) for how to override this default.
  12. An access_definition defines an anonymous general access-to-variable type; the subtype_mark denotes its designated subtype. An access_definition is used in the specification of an access discriminant, see section Discriminants, or an access parameter, see section Subprogram Declarations.
  13. For each (named) access type, there is a literal null which has a null access value designating no entity at all. The null value of a named access type is the default initial value of the type. Other values of an access type are obtained by evaluating an attribute_reference for the Access or Unchecked_Access attribute of an aliased view of an object or non-intrinsic subprogram, or, in the case of a named access-to-object type, an allocator, which returns an access value designating a newly created object, see section Operations of Access Types.
  14. All subtypes of an access-to-subprogram type are constrained. The first subtype of a type defined by an access_type_definition or an access_to_object_definition is unconstrained if the designated subtype is an unconstrained array or discriminated type; otherwise it is constrained.

    Dynamic Semantics

  15. A composite_constraint is compatible with an unconstrained access subtype if it is compatible with the designated subtype. An access value satisfies a composite_constraint of an access subtype if it equals the null value of its type or if it designates an object whose value satisfies the constraint.
  16. The elaboration of an access_type_definition creates the access type and its first subtype. For an access-to-object type, this elaboration includes the elaboration of the subtype_indication, which creates the designated subtype.
  17. The elaboration of an access_definition creates an anonymous general access-to-variable type (this happens as part of the initialization of an access parameter or access discriminant). NOTES
  18. (77) Access values are called "pointers" or "references" in some other languages.
  19. (78) Each access-to-object type has an associated storage pool; several access types can share the same pool. An object can be created in the storage pool of an access type by an allocator, see section Allocators, for the access type. A storage pool (roughly) corresponds to what some other languages call a "heap.". See section Storage Management, for a discussion of pools.
  20. (79) Only index_constraints and discriminant_constraints can be applied to access types, see section Index Constraints and Discrete Ranges, and section Discriminant Constraints.

    Examples

  21. Examples of access-to-object types: 
  22. type Peripheral_Ref is access Peripheral;  --  see section Variant Parts and Discrete Choices
type Binop_Ptr is access all Binary_Operation'Class;
-- general access-to-class-wide, see section Type Extensions
  23. Example of an access subtype: 
  24. subtype Drum_Ref is Peripheral_Ref(Drum);  --  see section Variant Parts and Discrete Choices
  25. Example of an access-to-subprogram type: 
  26. type Message_Procedure is access
  procedure (M : in String := "Error!");
procedure Default_Message_Procedure(M : in String);
Give_Message : Message_Procedure := Default_Message_Procedure'Access;
...
procedure Other_Procedure(M : in String);
...
Give_Message := Other_Procedure'Access;
...
Give_Message("File not found.");
-- call with parameter (.all is optional)
Give_Message.all;
-- call with no parameters

Incomplete Type Declarations

  1. There are no particular limitations on the designated type of an access type. In particular, the type of a component of the designated type can be another access type, or even the same access type. This permits mutually dependent and recursive access types. An incomplete_type_declaration can be used to introduce a type to be used as a designated type, while deferring its full definition to a subsequent full_type_declaration.

    Syntax 

  2. incomplete_type_declaration ::=
   type defining_identifier [discriminant_part];

    Legality Rules

  3. An incomplete_type_declaration requires a completion, which shall be a full_type_declaration. If the incomplete_type_declaration occurs immediately within either the visible part of a package_specification or a declarative_part, then the full_type_declaration shall occur later and immediately within this visible part or declarative_part. If the incomplete_type_declaration occurs immediately within the private part of a given package_specification, then the full_type_declaration shall occur later and immediately within either the private part itself, or the declarative_part of the corresponding package_body.
  4. If an incomplete_type_declaration has a known_discriminant_part, then a full_type_declaration that completes it shall have a fully conforming (explicit) known_discriminant_part, see section Conformance Rules. If an incomplete_type_declaration has no discriminant_part (or an unknown_discriminant_part), then a corresponding full_type_declaration is nevertheless allowed to have discriminants, either explicitly, or inherited via derivation.
  5. The only allowed uses of a name that denotes an incomplete_type_declaration are as follows:
    1. as the subtype_mark in the subtype_indication of an access_to_object_definition; the only form of constraint allowed in this subtype_indication is a discriminant_constraint;
    2. as the subtype_mark defining the subtype of a parameter or result of an access_to_subprogram_definition;
    3. as the subtype_mark in an access_definition;
    4. as the prefix of an attribute_reference whose attribute_designator is Class; such an attribute_reference is similarly restricted to the uses allowed here; when used in this way, the corresponding full_type_declaration shall declare a tagged type, and the attribute_reference shall occur in the same library unit as the incomplete_type_declaration.
  1. A dereference (whether implicit or explicit -- see section Names.) shall not be of an incomplete type.

    Static Semantics

  2. An incomplete_type_declaration declares an incomplete type and its first subtype; the first subtype is unconstrained if a known_discriminant_part appears.

    Dynamic Semantics

  3. The elaboration of an incomplete_type_declaration has no effect. NOTES
  4. (80) Within a declarative_part, an incomplete_type_declaration and a corresponding full_type_declaration cannot be separated by an intervening body. This is because a type has to be completely defined before it is frozen, and a body freezes all types declared prior to it in the same declarative_part, see section Freezing Rules.

    Examples

  5. Example of a recursive type: 
  6. type Cell;  --  incomplete type declaration
type Link is access Cell;

  7. type Cell is
   record
      Value  : Integer;
      Succ   : Link;
      Pred   : Link;
   end record;

  8. Head   : Link  := new Cell'(0, null, null);
Next   : Link  := Head.Succ;
  9. Examples of mutually dependent access types: 
  10. type Person(<>);    -- incomplete type declaration
type Car;           -- incomplete type declaration

  11. type Person_Name is access Person;
type Car_Name    is access all Car;

  12. type Car is
   record
      Number  : Integer;
      Owner   : Person_Name;
   end record;

  13. type Person(Sex : Gender) is
   record
      Name     : String(1 .. 20);
      Birth    : Date;
      Age      : Integer range 0 .. 130;
      Vehicle  : Car_Name;
      case Sex is
         when M => Wife    : Person_Name(Sex => F);
         when F => Husband : Person_Name(Sex => M);
      end case;
   end record;

  14. My_Car, Your_Car, Next_Car : Car_Name := new Car;
--  see section Allocators
George : Person_Name := new Person(M);
   ...
George.Vehicle := Your_Car;

Operations of Access Types

  1. The attribute Access is used to create access values designating aliased objects and non-intrinsic subprograms. The "accessibility" rules prevent dangling references (in the absence of uses of certain unchecked features -- see section Representation Issues.).

    Name Resolution Rules

  2. For an attribute_reference with attribute_designator Access (or Unchecked_Access -- see section Unchecked Access Value Creation.), the expected type shall be a single access type; the prefix of such an attribute_reference is never interpreted as an implicit_dereference. If the expected type is an access-to-subprogram type, then the expected profile of the prefix is the designated profile of the access type.

    Static Semantics

  3. The accessibility rules, which prevent dangling references, are written in terms of accessibility levels, which reflect the run-time nesting of masters. As explained in section Completion and Finalization, a master is the execution of a task_body, a block_statement, a subprogram_body, an entry_body, or an accept_statement. An accessibility level is deeper than another if it is more deeply nested at run time. For example, an object declared local to a called subprogram has a deeper accessibility level than an object declared local to the calling subprogram. The accessibility rules for access types require that the accessibility level of an object designated by an access value be no deeper than that of the access type. This ensures that the object will live at least as long as the access type, which in turn ensures that the access value cannot later designate an object that no longer exists. The Unchecked_Access attribute may be used to circumvent the accessibility rules.
  4. A given accessibility level is said to be statically deeper than another if the given level is known at compile time (as defined below) to be deeper than the other for all possible executions. In most cases, accessibility is enforced at compile time by Legality Rules. Run-time accessibility checks are also used, since the Legality Rules do not cover certain cases involving access parameters and generic packages.
  5. Each master, and each entity and view created by it, has an accessibility level:
    1. The accessibility level of a given master is deeper than that of each dynamically enclosing master, and deeper than that of each master upon which the task executing the given master directly depends, see section Task Dependence - Termination of Tasks.
    2. An entity or view created by a declaration has the same accessibility level as the innermost enclosing master, except in the cases of renaming and derived access types described below. A parameter of a master has the same accessibility level as the master.
    3. The accessibility level of a view of an object or subprogram defined by a renaming_declaration is the same as that of the renamed view.
    4. The accessibility level of a view conversion is the same as that of the operand.
    5. For a function whose result type is a return-by-reference type, the accessibility level of the result object is the same as that of the master that elaborated the function body. For any other function, the accessibility level of the result object is that of the execution of the called function.
    6. The accessibility level of a derived access type is the same as that of its ultimate ancestor.
    7. The accessibility level of the anonymous access type of an access discriminant is the same as that of the containing object or associated constrained subtype.
    8. The accessibility level of the anonymous access type of an access parameter is the same as that of the view designated by the actual. If the actual is an allocator, this is the accessibility level of the execution of the called subprogram.
    9. The accessibility level of an object created by an allocator is the same as that of the access type.
    10. The accessibility level of a view of an object or subprogram denoted by a dereference of an access value is the same as that of the access type.
    11. The accessibility level of a component, protected subprogram, or entry of (a view of) a composite object is the same as that of (the view of) the composite object.
  1. One accessibility level is defined to be statically deeper than another in the following cases:
    1. For a master that is statically nested within another master, the accessibility level of the inner master is statically deeper than that of the outer master.
    2. The statically deeper relationship does not apply to the accessibility level of the anonymous type of an access parameter; that is, such an accessibility level is not considered to be statically deeper, nor statically shallower, than any other.
    3. For determining whether one level is statically deeper than another when within a generic package body, the generic package is presumed to be instantiated at the same level as where it was declared; run-time checks are needed in the case of more deeply nested instantiations.
    4. For determining whether one level is statically deeper than another when within the declarative region of a type_declaration, the current instance of the type is presumed to be an object created at a deeper level than that of the type.
  1. The accessibility level of all library units is called the library level; a library-level declaration or entity is one whose accessibility level is the library level.
  2. The following attribute is defined for a prefix X that denotes an aliased view of an object:
  3. X'Access 
    X'Access yields an access value that designates the object
denoted by X. The type of X'Access is an access-to-object
type, as determined by the expected type. The expected type
shall be a general access type. X shall denote an aliased
view of an object, including possibly the current instance
(see section The Context of Overload Resolution) of a limited type within its definition, or a
formal parameter or generic formal object of a tagged type.
The view denoted by the prefix X shall satisfy the following
additional requirements, presuming the expected type for
X'Access is the general access type A:
      1. If A is an access-to-variable type, then the view shall be a variable; on the other hand, if A is an access-to-constant type, the view may be either a constant or a variable.
      2. The view shall not be a subcomponent that depends on discriminants of a variable whose nominal subtype is unconstrained, unless this subtype is indefinite, or the variable is aliased.
      3. If the designated type of A is tagged, then the type of the view shall be covered by the designated type; if A's designated type is not tagged, then the type of the view shall be the same, and either A's designated subtype shall statically match the nominal subtype of the view, or the designated subtype shall be discriminated and unconstrained;
      4. The accessibility level of the view shall not be statically deeper than that of the access type A. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, this rule applies also in the private part of an instance of a generic unit.
    1. A check is made that the accessibility level of X is not deeper than that of the access type A. If this check fails, Program_Error is raised.
    2. If the nominal subtype of X does not statically match the designated subtype of A, a view conversion of X to the designated subtype is evaluated (which might raise Constraint_Error -- see section Type Conversions.) and the value of X'Access designates that view.
  1. The following attribute is defined for a prefix P that denotes a subprogram:
  2. P'Access 
    P'Access yields an access value that designates the
subprogram denoted by P. The type of P'Access is an
access-to-subprogram type (S), as determined by the expected
type. The accessibility level of P shall not be statically
deeper than that of S. In addition to the places where
Legality Rules normally apply, see section Generic Instantiation, this rule applies
also in the private part of an instance of a generic unit.
The profile of P shall be subtype-conformant with the
designated profile of S, and shall not be Intrinsic. If
the subprogram denoted by P is declared within a generic
body, S shall be declared within the generic body.
    NOTES
  3. (81) The Unchecked_Access attribute yields the same result as the Access attribute for objects, but has fewer restrictions, see section Unchecked Access Value Creation. There are other predefined operations that yield access values: an allocator can be used to create an object, and return an access value that designates it, see section Allocators, evaluating the literal null yields a null access value that designates no entity at all, see section Literals.
  4. (82) The predefined operations of an access type also include the assignment operation, qualification, and membership tests. Explicit conversion is allowed between general access types with matching designated subtypes; explicit conversion is allowed between access-to-subprogram types with subtype conformant profiles, see section Type Conversions. Named access types have predefined equality operators; anonymous access types do not, see section Relational Operators and Membership Tests.
  5. (83) The object or subprogram designated by an access value can be named with a dereference, either an explicit_dereference or an implicit_dereference (see section Names).
  6. (84) A call through the dereference of an access-to-subprogram value is never a dispatching call.
  7. (85) The accessibility rules imply that it is not possible to use the Access attribute to implement "downward closures" -- that is, to pass a more-nested subprogram as a parameter to a less-nested subprogram, as might be desired for example for an iterator abstraction. Instead, downward closures can be implemented using generic formal subprograms (see section Formal Subprograms). Note that Unchecked_Access is not allowed for subprograms.
  8. (86) Note that using an access-to-class-wide tagged type with a dispatching operation is a potentially more structured alternative to using an access-to-subprogram type.
  9. (87) An implementation may consider two access-to-subprogram values to be unequal, even though they designate the same subprogram. This might be because one points directly to the subprogram, while the other points to a special prologue that performs an Elaboration_Check and then jumps to the subprogram (see section Relational Operators and Membership Tests).

    Examples

  10. Example of use of the Access attribute: 
  11. Martha : Person_Name := new Person(F);  --  see section Incomplete Type Declarations
Cars   : array (1..2) of aliased Car;
   ...
Martha.Vehicle := Cars(1)'Access;
George.Vehicle := Cars(2)'Access;

Declarative Parts

  1. A declarative_part contains declarative_items (possibly none).

    Syntax 

  2. declarative_part ::= {declarative_item}

  3. declarative_item ::= basic_declarative_item | body

  4. basic_declarative_item ::=
   basic_declaration | representation_clause | use_clause

  5. body ::= proper_body | body_stub

  6. proper_body ::=
   subprogram_body | package_body | task_body | protected_body

    Dynamic Semantics

  7. The elaboration of a declarative_part consists of the elaboration of the declarative_items, if any, in the order in which they are given in the declarative_part.
  8. An elaborable construct is in the elaborated state after the normal completion of its elaboration. Prior to that, it is not yet elaborated.
  9. For a construct that attempts to use a body, a check (Elaboration_Check) is performed, as follows:
    1. For a call to a (non-protected) subprogram that has an explicit body, a check is made that the subprogram_body is already elaborated. This check and the evaluations of any actual parameters of the call are done in an arbitrary order.
    2. For a call to a protected operation of a protected type (that has a body -- no check is performed if a pragma Import applies to the protected type), a check is made that the protected_body is already elaborated. This check and the evaluations of any actual parameters of the call are done in an arbitrary order.
    3. For the activation of a task, a check is made by the activator that the task_body is already elaborated. If two or more tasks are being activated together, see section Task Execution - Task Activation, as the result of the elaboration of a declarative_part or the initialization for the object created by an allocator, this check is done for all of them before activating any of them.
    4. For the instantiation of a generic unit that has a body, a check is made that this body is already elaborated. This check and the evaluation of any explicit_generic_actual_parameters of the instantiation are done in an arbitrary order.
  1. The exception Program_Error is raised if any of these checks fails.

Completions of Declarations

  1. Declarations sometimes come in two parts. A declaration that requires a second part is said to require completion. The second part is called the completion of the declaration (and of the entity declared), and is either another declaration, a body, or a pragma.

    Name Resolution Rules

  2. A construct that can be a completion is interpreted as the completion of a prior declaration only if:
    1. The declaration and the completion occur immediately within the same declarative region;
    2. The defining name or defining_program_unit_name in the completion is the same as in the declaration, or in the case of a pragma, the pragma applies to the declaration;
    3. If the declaration is overloadable, then the completion either has a type-conformant profile, or is a pragma.

Legality Rules

  1. An implicit declaration shall not have a completion. For any explicit declaration that is specified to require completion, there shall be a corresponding explicit completion.
  2. At most one completion is allowed for a given declaration. Additional requirements on completions appear where each kind of completion is defined.
  3. A type is completely defined at a place that is after its full type definition (if it has one) and after all of its subcomponent types are completely defined. A type shall be completely defined before it is frozen, see section Freezing Rules, and section Private Types and Private Extensions. NOTES
  4. (88) Completions are in principle allowed for any kind of explicit declaration. However, for some kinds of declaration, the only allowed completion is a pragma Import, and implementations are not required to support pragma Import for every kind of entity.
  5. (89) There are rules that prevent premature uses of declarations that have a corresponding completion. The Elaboration_Checks (see section Declarative Parts) prevent such uses at run time for subprograms, protected operations, tasks, and generic units. The "Freezing Rules" (see section Freezing Rules) prevent, at compile time, premature uses of other entities such as private types and deferred constants.

Names and Expressions

  1. The rules applicable to the different forms of name and expression, and to their evaluation, are given in this section.

Names

  1. Names can denote declared entities, whether declared explicitly or implicitly, see section Declarations. Names can also denote objects or subprograms designated by access values; the results of type_conversions or function_calls; subcomponents and slices of objects and values; protected subprograms, single entries, entry families, and entries in families of entries. Finally, names can denote attributes of any of the foregoing.

    Syntax 

  2. name ::=
     direct_name          | explicit_dereference
   | indexed_component    | slice
   | selected_component   | attribute_reference
   | type_conversion      | function_call
   | character_literal

  3. direct_name ::= identifier | operator_symbol

  4. prefix ::= name | implicit_dereference

  5. explicit_dereference ::= name.all

  6. implicit_dereference ::= name
  7. Certain forms of name (indexed_components, selected_components, slices, and attributes) include a prefix that is either itself a name that denotes some related entity, or an implicit_dereference of an access value that designates some related entity.

    Name Resolution Rules

  8. The name in a dereference (either an implicit_dereference or an explicit_dereference) is expected to be of any access type.

    Static Semantics

  9. If the type of the name in a dereference is some access-to-object type T, then the dereference denotes a view of an object, the nominal subtype of the view being the designated subtype of T.
  10. If the type of the name in a dereference is some access-to-subprogram type S, then the dereference denotes a view of a subprogram, the profile of the view being the designated profile of S.

    Dynamic Semantics

  11. The evaluation of a name determines the entity denoted by the name. This evaluation has no other effect for a name that is a direct_name or a character_literal.
  12. The evaluation of a name that has a prefix includes the evaluation of the prefix. The evaluation of a prefix consists of the evaluation of the name or the implicit_dereference. The prefix denotes the entity denoted by the name or the implicit_dereference.
  13. The evaluation of a dereference consists of the evaluation of the name and the determination of the object or subprogram that is designated by the value of the name. A check is made that the value of the name is not the null access value. Constraint_Error is raised if this check fails. The dereference denotes the object or subprogram designated by the value of the name.

    Examples

  14. Examples of direct names: 
  15. Pi      -- the direct name of a number            (see section Number Declarations)
Limit   -- the direct name of a constant          (see section Object Declarations)
Count   -- the direct name of a scalar variable   (see section Object Declarations)
Board   -- the direct name of an array variable   (see section Index Constraints and Discrete Ranges)
Matrix  -- the direct name of a type              (see section Array Types)
Random  -- the direct name of a function          (see section Subprogram Declarations)
Error   -- the direct name of an exception        (see section Exception Declarations)
  16. Examples of dereferences: 
  17. Next_Car.all    --  explicit dereference denoting the object
                --  designated by the access variable Next_Car,
                --  see section Incomplete Type Declarations
Next_Car.Owner  --  selected component with implicit dereference;
                --  same as Next_Car.all.Owner

Indexed Components

  1. An indexed_component denotes either a component of an array or an entry in a family of entries.

    Syntax 

  2. indexed_component ::= prefix(expression {, expression})

    Name Resolution Rules

  3. The prefix of an indexed_component with a given number of expressions shall resolve to denote an array (after any implicit dereference) with the corresponding number of index positions, or shall resolve to denote an entry family of a task or protected object (in which case there shall be only one expression).
  4. The expected type for each expression is the corresponding index type.

    Static Semantics

  5. When the prefix denotes an array, the indexed_component denotes the component of the array with the specified index value(s). The nominal subtype of the indexed_component is the component subtype of the array type.
  6. When the prefix denotes an entry family, the indexed_component denotes the individual entry of the entry family with the specified index value.

    Dynamic Semantics

  7. For the evaluation of an indexed_component, the prefix and the expressions are evaluated in an arbitrary order. The value of each expression is converted to the corresponding index type. A check is made that each index value belongs to the corresponding index range of the array or entry family denoted by the prefix. Constraint_Error is raised if this check fails.

    Examples

  8. Examples of indexed components: 
  9. My_Schedule(Sat)
--  a component of a one-dimensional array   (see see section Index Constraints and Discrete Ranges)

Page(10)
--  a component of a one-dimensional array   (see see section Array Types)

Board(M, J + 1)
--  a component of a two-dimensional array   (see see section Index Constraints and Discrete Ranges)

Page(10)(20)
--  a component of a component               (see see section Array Types)

Request(Medium)
--  an entry in a family of entries          (see see section Task Units and Task Objects)

Next_Frame(L)(M, N)
--  a component of a function call           (see see section Subprogram Declarations)
    NOTES
  10. (1) Notes on the examples: Distinct notations are used for components of multidimensional arrays (such as Board) and arrays of arrays (such as Page). The components of an array of arrays are arrays and can therefore be indexed. Thus Page(10)(20) denotes the 20th component of Page(10). In the last example Next_Frame(L) is a function call returning an access value that designates a two-dimensional array.

Slices

  1. A slice denotes a one-dimensional array formed by a sequence of consecutive components of a one-dimensional array. A slice of a variable is a variable; a slice of a constant is a constant; a slice of a value is a value.

    Syntax 

  2. slice ::= prefix(discrete_range)

    Name Resolution Rules

  3. The prefix of a slice shall resolve to denote a one-dimensional array (after any implicit dereference).
  4. The expected type for the discrete_range of a slice is the index type of the array type.

    Static Semantics

  5. A slice denotes a one-dimensional array formed by the sequence of consecutive components of the array denoted by the prefix, corresponding to the range of values of the index given by the discrete_range.
  6. The type of the slice is that of the prefix. Its bounds are those defined by the discrete_range.

    Dynamic Semantics

  7. For the evaluation of a slice, the prefix and the discrete_range are evaluated in an arbitrary order. If the slice is not a null slice (a slice where the discrete_range is a null range), then a check is made that the bounds of the discrete_range belong to the index range of the array denoted by the prefix. Constraint_Error is raised if this check fails. NOTES
  8. (2) A slice is not permitted as the prefix of an Access attribute_reference, even if the components or the array as a whole are aliased (see section Operations of Access Types).
  9. (3) For a one-dimensional array A, the slice A(N .. N) denotes an array that has only one component; its type is the type of A. On the other hand, A(N) denotes a component of the array A and has the corresponding component type.

    Examples

  10. Examples of slices: 
  11. Stars(1 .. 15)
--  a slice of 15 characters         (see section String Types)

Page(10 .. 10 + Size)
--  a slice of 1 + Size components   (see section Array Types)

Page(L)(A .. B)
--  a slice of the array Page(L)     (see section Array Types)

Stars(1 .. 0)
--  a null slice                     (see section String Types)

My_Schedule(Weekday)
--  bounds given by subtype          (see section Index Constraints and Discrete Ranges, and section Enumeration Types)

Stars(5 .. 15)(K)
--  same as Stars(K)                 (see section String Types)
--  provided that K is in 5 .. 15

Selected Components

  1. Selected_components are used to denote components (including discriminants), entries, entry families, and protected subprograms; they are also used as expanded names as described below.

    Syntax 

  2. selected_component ::= prefix . selector_name

  3. selector_name ::= identifier | character_literal | operator_symbol

    Name Resolution Rules

  4. A selected_component is called an expanded name if, according to the visibility rules, at least one possible interpretation of its prefix denotes a package or an enclosing named construct (directly, not through a subprogram_renaming_declaration or generic_renaming_declaration).
  5. A selected_component that is not an expanded name shall resolve to denote one of the following:
    1. A component (including a discriminant):
      1. The prefix shall resolve to denote an object or value of some non-array composite type (after any implicit dereference). The selector_name shall resolve to denote a discriminant_specification of the type, or, unless the type is a protected type, a component_declaration of the type. The selected_component denotes the corresponding component of the object or value.
    1. A single entry, an entry family, or a protected subprogram:
      1. The prefix shall resolve to denote an object or value of some task or protected type (after any implicit dereference). The selector_name shall resolve to denote an entry_declaration or subprogram_declaration occurring (implicitly or explicitly) within the visible part of that type. The selected_component denotes the corresponding entry, entry family, or protected subprogram.
  1. An expanded name shall resolve to denote a declaration that occurs immediately within a named declarative region, as follows:
    1. The prefix shall resolve to denote either a package (including the current instance of a generic package, or a rename of a package), or an enclosing named construct.
    2. The selector_name shall resolve to denote a declaration that occurs immediately within the declarative region of the package or enclosing construct (the declaration shall be visible at the place of the expanded name -- see section Visibility.). The expanded name denotes that declaration.
    3. If the prefix does not denote a package, then it shall be a direct_name or an expanded name, and it shall resolve to denote a program unit (other than a package), the current instance of a type, a block_statement, a loop_statement, or an accept_statement (in the case of an accept_statement or entry_body, no family index is allowed); the expanded name shall occur within the declarative region of this construct. Further, if this construct is a callable construct and the prefix denotes more than one such enclosing callable construct, then the expanded name is ambiguous, independently of the selector_name.

Dynamic Semantics

  1. The evaluation of a selected_component includes the evaluation of the prefix.
  2. For a selected_component that denotes a component of a variant, a check is made that the values of the discriminants are such that the value or object denoted by the prefix has this component. The exception Constraint_Error is raised if this check fails.

    Examples

  3. Examples of selected components: 
  4. Tomorrow.Month
--  a record component                    (see section Record Types)

Next_Car.Owner
--  a record component                    (see section Incomplete Type Declarations)

Next_Car.Owner.Age
--  a record component                    (see section Incomplete Type Declarations)
--  the previous two lines involve implicit dereferences

Writer.Unit
--  a record component (a discriminant)   (see section Variant Parts and Discrete Choices)

Min_Cell(H).Value
--  a record component of the result      (see section Subprogram Declarations)
--  of the function call Min_Cell(H)

Control.Seize
--  an entry of a protected object        (see section Protected Units and Protected Objects)

Pool(K).Write
--  an entry of the task Pool(K)          (see section Protected Units and Protected Objects)
  5. Examples of expanded names: 
  6. Key_Manager."<"
--  an operator of the visible part of a package   (see section Private Operations)

Dot_Product.Sum
--  a variable declared in a function body         (see section Subprogram Declarations)

Buffer.Pool
--  a variable declared in a protected unit        (see section Example of Tasking and Synchronization)

Buffer.Read
--  an entry of a protected unit                   (see section Example of Tasking and Synchronization)

Swap.Temp
--  a variable declared in a block statement       (see section Block Statements)

Standard.Boolean
--  the name of a predefined type                  (see section The Package Standard)

Attributes

  1. An attribute is a characteristic of an entity that can be queried via an attribute_reference or a range_attribute_reference.

    Syntax 

  2. attribute_reference ::= prefix'attribute_designator

  3. attribute_designator ::=
     identifier[(static_expression)]
   | Access | Delta | Digits

  4. range_attribute_reference ::= prefix'range_attribute_designator

  5. range_attribute_designator ::= Range[(static_expression)]

    Name Resolution Rules

  6. In an attribute_reference, if the attribute_designator is for an attribute defined for (at least some) objects of an access type, then the prefix is never interpreted as an implicit_dereference; otherwise (and for all range_attribute_references), if the type of the name within the prefix is of an access type, the prefix is interpreted as an implicit_dereference. Similarly, if the attribute_designator is for an attribute defined for (at least some) functions, then the prefix is never interpreted as a parameterless function_call; otherwise (and for all range_attribute_references), if the prefix consists of a name that denotes a function, it is interpreted as a parameterless function_call.
  7. The expression, if any, in an attribute_designator or range_attribute_designator is expected to be of any integer type.

    Legality Rules

  8. The expression, if any, in an attribute_designator or range_attribute_designator shall be static.

    Static Semantics

  9. An attribute_reference denotes a value, an object, a subprogram, or some other kind of program entity.
  10. A range_attribute_reference X'Range(N) is equivalent to the range X'First(N) .. X'Last(N), except that the prefix is only evaluated once. Similarly, X'Range is equivalent to X'First .. X'Last, except that the prefix is only evaluated once.

    Dynamic Semantics

  11. The evaluation of an attribute_reference (or range_attribute_reference) consists of the evaluation of the prefix.

    Implementation Permissions

  12. An implementation may provide implementation-defined attributes; the identifier for an implementation-defined attribute shall differ from those of the language-defined attributes. NOTES
  13. (4) Attributes are defined throughout this International Standard, and are summarized in section Language-Defined Attributes (informative).
  14. (5) In general, the name in a prefix of an attribute_reference (or a range_attribute_reference) has to be resolved without using any context. However, in the case of the Access attribute, the expected type for the prefix has to be a single access type, and if it is an access-to-subprogram type, see section Operations of Access Types, then the resolution of the name can use the fact that the profile of the callable entity denoted by the prefix has to be type conformant with the designated profile of the access type.

    Examples

  15. Examples of attributes: 
  16. Color'First
-- minimum value of the enumeration type Color    (see section Enumeration Types)

Rainbow'Base'First
-- same as Color'First                            (see section Enumeration Types)

Real'Digits
-- precision of the type Real                     (see section Floating Point Types)

Board'Last(2)
-- upper bound of the second dimension of Board   (see section Index Constraints and Discrete Ranges)

Board'Range(1)
-- index range of the first dimension of Board    (see section Index Constraints and Discrete Ranges)

Pool(K)'Terminated
-- True if task Pool(K) is terminated             (see section Task Units and Task Objects)

Date'Size
-- number of bits for records of type Date        (see section Record Types)

Message'Address
-- address of the record variable Message         (see section Discriminant Constraints)

Literals

  1. A literal represents a value literally, that is, by means of notation suited to its kind. A literal is either a numeric_literal, a character_literal, the literal null, or a string_literal.

    Name Resolution Rules

  2. The expected type for a literal null shall be a single access type.
  3. For a name that consists of a character_literal, either its expected type shall be a single character type, in which case it is interpreted as a parameterless function_call that yields the corresponding value of the character type, or its expected profile shall correspond to a parameterless function with a character result type, in which case it is interpreted as the name of the corresponding parameterless function declared as part of the character type's definition, see section Enumeration Types. In either case, the character_literal denotes the enumeration_literal_specification.
  4. The expected type for a primary that is a string_literal shall be a single string type.

    Legality Rules

  5. A character_literal that is a name shall correspond to a defining_character_literal of the expected type, or of the result type of the expected profile.
  6. For each character of a string_literal with a given expected string type, there shall be a corresponding defining_character_literal of the component type of the expected string type.
  7. A literal null shall not be of an anonymous access type, since such types do not have a null value, see section Access Types.

    Static Semantics

  8. An integer literal is of type universal_integer. A real literal is of type universal_real.

    Dynamic Semantics

  9. The evaluation of a numeric literal, or the literal null, yields the represented value.
  10. The evaluation of a string_literal that is a primary yields an array value containing the value of each character of the sequence of characters of the string_literal, as defined in section String Literals. The bounds of this array value are determined according to the rules for positional_array_aggregates (see section Array Aggregates), except that for a null string literal the upper bound is the predecessor of the lower bound.
  11. For the evaluation of a string_literal of type T, a check is made that the value of each character of the string_literal belongs to the component subtype of T. For the evaluation of a null string literal, a check is made that its lower bound is greater than the lower bound of the base range of the index type. The exception Constraint_Error is raised if either of these checks fails. NOTES
  12. (6) Enumeration literals that are identifiers rather than character_literals follow the normal rules for identifiers when used in a name, see section Names, and section Selected Components. Character_literals used as selector_names follow the normal rules for expanded names, see section Selected Components.

    Examples

  13. Examples of literals: 
  14. 3.14159_26536    --  a real literal
1_345            --  an integer literal
'A'              --  a character literal
"Some Text"      --  a string literal

Aggregates

  1. An aggregate combines component values into a composite value of an array type, record type, or record extension.

    Syntax 

  2. aggregate ::=
   record_aggregate | extension_aggregate | array_aggregate

    Name Resolution Rules

  3. The expected type for an aggregate shall be a single nonlimited array type, record type, or record extension.

    Legality Rules

  4. An aggregate shall not be of a class-wide type.

    Dynamic Semantics

  5. For the evaluation of an aggregate, an anonymous object is created and values for the components or ancestor part are obtained (as described in the subsequent subclause for each kind of the aggregate) and assigned into the corresponding components or ancestor part of the anonymous object. Obtaining the values and the assignments occur in an arbitrary order. The value of the aggregate is the value of this object.
  6. If an aggregate is of a tagged type, a check is made that its value belongs to the first subtype of the type. Constraint_Error is raised if this check fails.

Record Aggregates

  1. In a record_aggregate, a value is specified for each component of the record or record extension value, using either a named or a positional association.

    Syntax 

  2. record_aggregate ::= (record_component_association_list)

  3. record_component_association_list ::=
     record_component_association {, record_component_association}
   | null record

  4. record_component_association ::=
   [ component_choice_list => ] expression

  5. component_choice_list ::=
     component_selector_name {| component_selector_name}
   | others
    1. A record_component_association is a named component association if it has a component_choice_list; otherwise, it is a positional component association. Any positional component associations shall precede any named component associations. If there is a named association with a component_choice_list of others, it shall come last.
    2. In the record_component_association_list for a record_aggregate, if there is only one association, it shall be a named association.

Name Resolution Rules

  1. The expected type for a record_aggregate shall be a single nonlimited record type or record extension.
  2. For the record_component_association_list of a record_aggregate, all components of the composite value defined by the aggregate are needed; for the association list of an extension_aggregate, only those components not determined by the ancestor expression or subtype are needed, see section Extension Aggregates. Each selector_name in a record_component_association shall denote a needed component (including possibly a discriminant).
  3. The expected type for the expression of a record_component_association is the type of the associated component(s); the associated component(s) are as follows:
    1. For a positional association, the component (including possibly a discriminant) in the corresponding relative position (in the declarative region of the type), counting only the needed components;
    2. For a named association with one or more component_selector_names, the named component(s);
    3. For a named association with the reserved word others, all needed components that are not associated with some previous association.

Legality Rules

  1. If the type of a record_aggregate is a record extension, then it shall be a descendant of a record type, through one or more record extensions (and no private extensions).
  2. If there are no components needed in a given record_component_association_list, then the reserved words null record shall appear rather than a list of record_component_associations.
  3. Each record_component_association shall have at least one associated component, and each needed component shall be associated with exactly one record_component_association. If a record_component_association has two or more associated components, all of them shall be of the same type.
  4. If the components of a variant_part are needed, then the value of a discriminant that governs the variant_part shall be given by a static expression.

    Dynamic Semantics

  5. The evaluation of a record_aggregate consists of the evaluation of the record_component_association_list.
  6. For the evaluation of a record_component_association_list, any per-object constraints, see section Record Types, for components specified in the association list are elaborated and any expressions are evaluated and converted to the subtype of the associated component. Any constraint elaborations and expression evaluations (and conversions) occur in an arbitrary order, except that the expression for a discriminant is evaluated (and converted) prior to the elaboration of any per-object constraint that depends on it, which in turn occurs prior to the evaluation and conversion of the expression for the component with the per-object constraint.
  7. The expression of a record_component_association is evaluated (and converted) once for each associated component. NOTES
  8. (7) For a record_aggregate with positional associations, expressions specifying discriminant values appear first since the known_discriminant_part is given first in the declaration of the type; they have to be in the same order as in the known_discriminant_part.

    Examples

  9. Example of a record aggregate with positional associations: 
  10. (4, July, 1776)  --  see section Record Types
  11. Examples of record aggregates with named associations: 
  12. (Day => 4, Month => July, Year => 1776)
(Month => July, Day => 4, Year => 1776)

  13. (Disk, Closed, Track => 5, Cylinder => 12)  --  see section Variant Parts and Discrete Choices
(Unit => Disk, Status => Closed, Cylinder => 9, Track => 1)
  14. Example of component association with several choices: 
  15. (Value => 0, Succ|Pred => new Cell'(0, null, null))
--  see section Incomplete Type Declarations

  16. --  The allocator is evaluated twice:
--  Succ and Pred designate different cells
  17. Examples of record aggregates for tagged types, see section Tagged Types and Type Extensions, and section Type Extensions 
  18. Expression'(null record)
Literal'(Value => 0.0)
Painted_Point'(0.0, Pi/2.0, Paint => Red)

Extension Aggregates

  1. An extension_aggregate specifies a value for a type that is a record extension by specifying a value or subtype for an ancestor of the type, followed by associations for any components not determined by the ancestor_part.

    Syntax 

  2. extension_aggregate ::=
   (ancestor_part with record_component_association_list)

  3. ancestor_part ::= expression | subtype_mark

    Name Resolution Rules

  4. The expected type for an extension_aggregate shall be a single nonlimited type that is a record extension. If the ancestor_part is an expression, it is expected to be of any nonlimited tagged type.

    Legality Rules

  5. If the ancestor_part is a subtype_mark, it shall denote a specific tagged subtype. The type of the extension_aggregate shall be derived from the type of the ancestor_part, through one or more record extensions (and no private extensions).

    Static Semantics

  6. For the record_component_association_list of an extension_aggregate, the only components needed are those of the composite value defined by the aggregate that are not inherited from the type of the ancestor_part, plus any inherited discriminants if the ancestor_part is a subtype_mark that denotes an unconstrained subtype.

    Dynamic Semantics

  7. For the evaluation of an extension_aggregate, the record_component_association_list is evaluated. If the ancestor_part is an expression, it is also evaluated; if the ancestor_part is a subtype_mark, the components of the value of the aggregate not given by the record_component_association_list are initialized by default as for an object of the ancestor type. Any implicit initializations or evaluations are performed in an arbitrary order, except that the expression for a discriminant is evaluated prior to any other evaluation or initialization that depends on it.
  8. If the type of the ancestor_part has discriminants that are not inherited by the type of the extension_aggregate, then, unless the ancestor_part is a subtype_mark that denotes an unconstrained subtype, a check is made that each discriminant of the ancestor has the value specified for a corresponding discriminant, either in the record_component_association_list, or in the derived_type_definition for some ancestor of the type of the extension_aggregate. Constraint_Error is raised if this check fails. NOTES
  9. (8) If all components of the value of the extension_aggregate are determined by the ancestor_part, then the record_component_association_list is required to be simply null record.
  10. (9) If the ancestor_part is a subtype_mark, then its type can be abstract. If its type is controlled, then as the last step of evaluating the aggregate, the Initialize procedure of the ancestor type is called, unless the Initialize procedure is abstract, see section User-Defined Assignment and Finalization.

    Examples

  11. Examples of extension aggregates (for types defined in section Type Extensions.): 
  12. Painted_Point'(Point with Red)
(Point'(P) with Paint => Black)

  13. (Expression with Left => 1.2, Right => 3.4)
Addition'(Binop with null record)
-- presuming Binop is of type Binary_Operation

Array Aggregates

  1. In an array_aggregate, a value is specified for each component of an array, either positionally or by its index. For a positional_array_aggregate, the components are given in increasing-index order, with a final others, if any, representing any remaining components. For a named_array_aggregate, the components are identified by the values covered by the discrete_choices.

    Syntax 

  2. array_aggregate ::=
   positional_array_aggregate | named_array_aggregate

  3. positional_array_aggregate ::=
     (expression, expression {, expression})
   | (expression {, expression}, others => expression)

  4. named_array_aggregate ::=
   (array_component_association {, array_component_association})

  5. array_component_association ::=
   discrete_choice_list => expression
  6. An n-dimensional array_aggregate is one that is written as n levels of nested array_aggregates (or at the bottom level, equivalent string_literals). For the multidimensional case (n >= 2) the array_aggregates (or equivalent string_literals) at the n-1 lower levels are called subaggregates of the enclosing n-dimensional array_aggregate. The expressions of the bottom level subaggregates (or of the array_aggregate itself if one-dimensional) are called the array component expressions of the enclosing n-dimensional array_aggregate.

    Name Resolution Rules

  7. The expected type for an array_aggregate (that is not a subaggregate) shall be a single nonlimited array type. The component type of this array type is the expected type for each array component expression of the array_aggregate.
  8. The expected type for each discrete_choice in any discrete_choice_list of a named_array_aggregate is the type of the corresponding index; the corresponding index for an array_aggregate that is not a subaggregate is the first index of its type; for an (n-m)-dimensional subaggregate within an array_aggregate of an n-dimensional type, the corresponding index is the index in position m+1.

    Legality Rules

  9. An array_aggregate of an n-dimensional array type shall be written as an n-dimensional array_aggregate.
  10. An others choice is allowed for an array_aggregate only if an applicable index constraint applies to the array_aggregate. An applicable index constraint is a constraint provided by certain contexts where an array_aggregate is permitted that can be used to determine the bounds of the array value specified by the aggregate. Each of the following contexts (and none other) defines an applicable index constraint:
    1. For an explicit_actual_parameter, an explicit_generic_actual_parameter, the expression of a return_statement, the initialization expression in an object_declaration, or a default_expression (for a parameter or a component), when the nominal subtype of the corresponding formal parameter, generic formal parameter, function result, object, or component is a constrained array subtype, the applicable index constraint is the constraint of the subtype;
    2. For the expression of an assignment_statement where the name denotes an array variable, the applicable index constraint is the constraint of the array variable;
    3. For the operand of a qualified_expression whose subtype_mark denotes a constrained array subtype, the applicable index constraint is the constraint of the subtype;
    4. For a component expression in an aggregate, if the component's nominal subtype is a constrained array subtype, the applicable index constraint is the constraint of the subtype;
    5. For a parenthesized expression, the applicable index constraint is that, if any, defined for the expression.
  1. The applicable index constraint applies to an array_aggregate that appears in such a context, as well as to any subaggregates thereof. In the case of an explicit_actual_parameter (or default_expression) for a call on a generic formal subprogram, no applicable index constraint is defined.
  2. The discrete_choice_list of an array_component_association is allowed to have a discrete_choice that is a nonstatic expression or that is a discrete_range that defines a nonstatic or null range, only if it is the single discrete_choice of its discrete_choice_list, and there is only one array_component_association in the array_aggregate.
  3. In a named_array_aggregate with more than one discrete_choice, no two discrete_choices are allowed to cover the same value, see section Variant Parts and Discrete Choices, if there is no others choice, the discrete_choices taken together shall exactly cover a contiguous sequence of values of the corresponding index type.
  4. A bottom level subaggregate of a multidimensional array_aggregate of a given array type is allowed to be a string_literal only if the component type of the array type is a character type; each character of such a string_literal shall correspond to a defining_character_literal of the component type.

    Static Semantics

  5. A subaggregate that is a string_literal is equivalent to one that is a positional_array_aggregate of the same length, with each expression being the character_literal for the corresponding character of the string_literal.

    Dynamic Semantics

  6. The evaluation of an array_aggregate of a given array type proceeds in two steps:
    1. Any discrete_choices of this aggregate and of its subaggregates are evaluated in an arbitrary order, and converted to the corresponding index type;
    2. The array component expressions of the aggregate are evaluated in an arbitrary order and their values are converted to the component subtype of the array type; an array component expression is evaluated once for each associated component.
  1. The bounds of the index range of an array_aggregate (including a subaggregate) are determined as follows:
    1. For an array_aggregate with an others choice, the bounds are those of the corresponding index range from the applicable index constraint;
    2. For a positional_array_aggregate (or equivalent string_literal) without an others choice, the lower bound is that of the corresponding index range in the applicable index constraint, if defined, or that of the corresponding index subtype, if not; in either case, the upper bound is determined from the lower bound and the number of expressions (or the length of the string_literal);
    3. For a named_array_aggregate without an others choice, the bounds are determined by the smallest and largest index values covered by any discrete_choice_list.
  1. For an array_aggregate, a check is made that the index range defined by its bounds is compatible with the corresponding index subtype.
  2. For an array_aggregate with an others choice, a check is made that no expression is specified for an index value outside the bounds determined by the applicable index constraint.
  3. For a multidimensional array_aggregate, a check is made that all subaggregates that correspond to the same index have the same bounds.
  4. The exception Constraint_Error is raised if any of the above checks fail. NOTES
  5. (10) In an array_aggregate, positional notation may only be used with two or more expressions; a single expression in parentheses is interpreted as a parenthesized_expression. A named_array_aggregate, such as (1 => X), may be used to specify an array with a single component.

    Examples

  6. Examples of array aggregates with positional associations: 
  7. (7, 9, 5, 1, 3, 2, 4, 8, 6, 0)
Table'(5, 8, 4, 1, others => 0)  --  see section Array Types
  8. Examples of array aggregates with named associations: 
  9. (1 .. 5 => (1 .. 8 => 0.0))  --  two-dimensional
(1 .. N => new Cell)         --  N new cells, in particular for N = 0

  10. Table'(2 | 4 | 10 => 1, others => 0)

Schedule'(Mon .. Fri => True,  others => False)
Schedule'(Wed | Sun  => False, others => True)
--  see section Array Types

Vector'(1 => 2.5)
--  single-component vector
  11. Examples of two-dimensional array aggregates: 
  12. -- Three aggregates for the same value of subtype
--  Matrix(1..2,1..3), see section Array Types

  13. ((1.1, 1.2, 1.3), (2.1, 2.2, 2.3))
(1 => (1.1, 1.2, 1.3), 2 => (2.1, 2.2, 2.3))
(1 => (1 => 1.1, 2 => 1.2, 3 => 1.3),
  2 => (1 => 2.1, 2 => 2.2, 3 => 2.3))
  14. Examples of aggregates as initial values: 
  15. A : Table := (7, 9, 5, 1, 3, 2, 4, 8, 6, 0);
-- A(1)=7, A(10)=0

B : Table := (2 | 4 | 10 => 1, others => 0);
-- B(1)=0, B(10)=1

C : constant Matrix := (1 .. 5 => (1 .. 8 => 0.0));
-- C'Last(1)=5, C'Last(2)=8

  16. D : Bit_Vector(M .. N) := (M .. N => True);  --  see section Array Types
E : Bit_Vector(M .. N) := (others => True);
F : String(1 .. 1) := (1 => 'F');
-- a one component aggregate: same as "F"

Expressions

  1. An expression is a formula that defines the computation or retrieval of a value. In this International Standard, the term "expression" refers to a construct of the syntactic category expression or of any of the other five syntactic categories defined below.

    Syntax 

  2. expression ::=
     relation {and relation} | relation {and then relation}
   | relation {or relation}  | relation {or else relation}
   | relation {xor relation}

  3. relation ::=
     simple_expression [relational_operator simple_expression]
   | simple_expression [not] in range
   | simple_expression [not] in subtype_mark

  4. simple_expression ::=
   [unary_adding_operator] term {binary_adding_operator term}

  5. term ::= factor {multiplying_operator factor}

  6. factor ::= primary [** primary] | abs primary | not primary

  7. primary ::=
     numeric_literal   | null
   | string_literal    | aggregate
   | name              | qualified_expression
   | allocator         | (expression)

    Name Resolution Rules

  8. A name used as a primary shall resolve to denote an object or a value.

    Static Semantics

  9. Each expression has a type; it specifies the computation or retrieval of a value of that type.

    Dynamic Semantics

  10. The value of a primary that is a name denoting an object is the value of the object.

    Implementation Permissions

  11. For the evaluation of a primary that is a name denoting an object of an unconstrained numeric subtype, if the value of the object is outside the base range of its type, the implementation may either raise Constraint_Error or return the value of the object.

    Examples

  12. Examples of primaries: 
  13. 4.0                --  real literal
Pi                 --  named number
(1 .. 10 => 0)     --  array aggregate
Sum                --  variable
Integer'Last       --  attribute
Sine(X)            --  function call
Color'(Blue)       --  qualified expression
Real(M*N)          --  conversion
(Line_Count + 10)  --  parenthesized expression
  14. Examples of expressions: 
  15. Volume                      -- primary
not Destroyed               -- factor
2*Line_Count                -- term
-4.0                        -- simple expression
-4.0 + A                    -- simple expression
B**2 - 4.0*A*C              -- simple expression
Password(1 .. 3) = "Bwv"    -- relation
Count in Small_Int          -- relation
Count not in Small_Int      -- relation
Index = 0 or Item_Hit       -- expression
(Cold and Sunny) or Warm    -- expression (parentheses are required)
A**(B**C)                   -- expression (parentheses are required)

Operators and Expression Evaluation

  1. The language defines the following six categories of operators (given in order of increasing precedence). The corresponding operator_symbols, and only those, can be used as designators in declarations of functions for user-defined operators (see section Overloading of Operators).

    Syntax 

  2. logical_operator            ::=  and | or  | xor

  3. relational_operator         ::=  =   | /=  | <   | <= | > | >=

  4. binary_adding_operator      ::=  +   | -   | &

  5. unary_adding_operator       ::=  +   | -

  6. multiplying_operator        ::=  *   | /   | mod | rem

  7. highest_precedence_operator ::=  **  | abs | not

    Static Semantics

  8. For a sequence of operators of the same precedence level, the operators are associated with their operands in textual order from left to right. Parentheses can be used to impose specific associations.
  9. For each form of type definition, certain of the above operators are predefined; that is, they are implicitly declared immediately after the type definition. For each such implicit operator declaration, the parameters are called Left and Right for binary operators; the single parameter is called Right for unary operators. An expression of the form X op Y, where op is a binary operator, is equivalent to a function_call of the form "op"(X, Y). An expression of the form op Y, where op is a unary operator, is equivalent to a function_call of the form "op"(Y). The predefined operators and their effects are described in subclauses section Logical Operators and Short-circuit Control Forms through section Highest Precedence Operators.

    Dynamic Semantics

  10. The predefined operations on integer types either yield the mathematically correct result or raise the exception Constraint_Error. For implementations that support the Numerics Annex, the predefined operations on real types yield results whose accuracy is defined in section Numerics (normative), or raise the exception Constraint_Error.

    Implementation Requirements

  11. The implementation of a predefined operator that delivers a result of an integer or fixed point type may raise Constraint_Error only if the result is outside the base range of the result type.
  12. The implementation of a predefined operator that delivers a result of a floating point type may raise Constraint_Error only if the result is outside the safe range of the result type.

    Implementation Permissions

  13. For a sequence of predefined operators of the same precedence level (and in the absence of parentheses imposing a specific association), an implementation may impose any association of the operators with operands so long as the result produced is an allowed result for the left-to-right association, but ignoring the potential for failure of language-defined checks in either the left-to-right or chosen order of association. NOTES
  14. (11) The two operands of an expression of the form X op Y, where op is a binary operator, are evaluated in an arbitrary order, as for any function_call, see section Subprogram Calls.

    Examples

  15. Examples of precedence: 
  16. not Sunny or Warm    --  same as (not Sunny) or Warm
X > 4.0 and Y > 0.0  --  same as (X > 4.0) and (Y > 0.0)

  17. -4.0*A**2            --  same as -(4.0 * (A**2))
abs(1 + A) + B       --  same as (abs (1 + A)) + B
Y**(-3)              --  parentheses are necessary
A / B * C            --  same as (A/B)*C
A + (B + C)          --  evaluate B + C before adding it to A

Logical Operators and Short-circuit Control Forms

Name Resolution Rules

  1. An expression consisting of two relations connected by and then or or else (a short-circuit control form) shall resolve to be of some boolean type; the expected type for both relations is that same boolean type.

    Static Semantics

  2. The following logical operators are predefined for every boolean type T, for every modular type T, and for every one-dimensional array type T whose component type is a boolean type: 
  3. function "and"(Left, Right : T) return T
function "or" (Left, Right : T) return T
function "xor"(Left, Right : T) return T
  4. For boolean types, the predefined logical operators and, or, and xor perform the conventional operations of conjunction, inclusive disjunction, and exclusive disjunction, respectively.
  5. For modular types, the predefined logical operators are defined on a bit-by-bit basis, using the binary representation of the value of the operands to yield a binary representation for the result, where zero represents False and one represents True. If this result is outside the base range of the type, a final subtraction by the modulus is performed to bring the result into the base range of the type.
  6. The logical operators on arrays are performed on a component-by-component basis on matching components (as for equality -- see section Relational Operators and Membership Tests.), using the predefined logical operator for the component type. The bounds of the resulting array are those of the left operand.

    Dynamic Semantics

  7. The short-circuit control forms and then and or else deliver the same result as the corresponding predefined and and or operators for boolean types, except that the left operand is always evaluated first, and the right operand is not evaluated if the value of the left operand determines the result.
  8. For the logical operators on arrays, a check is made that for each component of the left operand there is a matching component of the right operand, and vice versa. Also, a check is made that each component of the result belongs to the component subtype. The exception Constraint_Error is raised if either of the above checks fails. NOTES
  9. (12) The conventional meaning of the logical operators is given by the following truth table: 
  10. A      B      (A and B)  (A or B)  (A xor B)

True   True     True       True      False
True   False    False      True      True
False  True     False      True      True
False  False    False      False     False

    Examples

  11. Examples of logical operators: 
  12. Sunny or Warm
Filter(1 .. 10) and Filter(15 .. 24)   --  see section Index Constraints and Discrete Ranges
  13. Examples of short-circuit control forms: 
  14. Next_Car.Owner /= null and then Next_Car.Owner.Age > 25
--  see section Incomplete Type Declarations

N = 0 or else A(N) = Hit_Value

Relational Operators and Membership Tests

  1. The equality operators = (equals) and /= (not equals) are predefined for nonlimited types. The other relational_operators are the ordering operators < (less than), <= (less than or equal), > (greater than), and >= (greater than or equal). The ordering operators are predefined for scalar types, and for discrete array types, that is, one-dimensional array types whose components are of a discrete type.
  2. A membership test, using in or not in, determines whether or not a value belongs to a given subtype or range, or has a tag that identifies a type that is covered by a given type. Membership tests are allowed for all types.

    Name Resolution Rules

  3. The tested type of a membership test is the type of the range or the type determined by the subtype_mark. If the tested type is tagged, then the simple_expression shall resolve to be of a type that covers or is covered by the tested type; if untagged, the expected type for the simple_expression is the tested type.

    Legality Rules

  4. For a membership test, if the simple_expression is of a tagged class-wide type, then the tested type shall be (visibly) tagged.

    Static Semantics

  5. The result type of a membership test is the predefined type Boolean.
  6. The equality operators are predefined for every specific type T that is not limited, and not an anonymous access type, with the following specifications: 
  7. function "=" (Left, Right : T) return Boolean
function "/="(Left, Right : T) return Boolean
  8. The ordering operators are predefined for every specific scalar type T, and for every discrete array type T, with the following specifications: 
  9. function "<" (Left, Right : T) return Boolean
function "<="(Left, Right : T) return Boolean
function ">" (Left, Right : T) return Boolean
function ">="(Left, Right : T) return Boolean

    Dynamic Semantics

  10. For discrete types, the predefined relational operators are defined in terms of corresponding mathematical operations on the position numbers of the values of the operands.
  11. For real types, the predefined relational operators are defined in terms of the corresponding mathematical operations on the values of the operands, subject to the accuracy of the type.
  12. Two access-to-object values are equal if they designate the same object, or if both are equal to the null value of the access type.
  13. Two access-to-subprogram values are equal if they are the result of the same evaluation of an Access attribute_reference, or if both are equal to the null value of the access type. Two access-to-subprogram values are unequal if they designate different subprograms. It is unspecified whether two access values that designate the same subprogram but are the result of distinct evaluations of Access attribute_references are equal or unequal.
  14. For a type extension, predefined equality is defined in terms of the primitive (possibly user-defined) equals operator of the parent type and of any tagged components of the extension part, and predefined equality for any other components not inherited from the parent type.
  15. For a private type, if its full type is tagged, predefined equality is defined in terms of the primitive equals operator of the full type; if the full type is untagged, predefined equality for the private type is that of its full type.
  16. For other composite types, the predefined equality operators (and certain other predefined operations on composite types -- see section Logical Operators and Short-circuit Control Forms, and section Type Conversions.) are defined in terms of the corresponding operation on matching components, defined as follows:
    1. For two composite objects or values of the same non-array type, matching components are those that correspond to the same component_declaration or discriminant_specification;
    2. For two one-dimensional arrays of the same type, matching components are those (if any) whose index values match in the following sense: the lower bounds of the index ranges are defined to match, and the successors of matching indices are defined to match;
    3. For two multidimensional arrays of the same type, matching components are those whose index values match in successive index positions.
  1. The analogous definitions apply if the types of the two objects or values are convertible, rather than being the same.
  2. Given the above definition of matching components, the result of the predefined equals operator for composite types (other than for those composite types covered earlier) is defined as follows:
    1. If there are no components, the result is defined to be True;
    2. If there are unmatched components, the result is defined to be False;
    3. Otherwise, the result is defined in terms of the primitive equals operator for any matching tagged components, and the predefined equals for any matching untagged components.
  1. The predefined "/=" operator gives the complementary result to the predefined "=" operator.
  2. For a discrete array type, the predefined ordering operators correspond to lexicographic order using the predefined order relation of the component type: A null array is lexicographically less than any array having at least one component. In the case of nonnull arrays, the left operand is lexicographically less than the right operand if the first component of the left operand is less than that of the right; otherwise the left operand is lexicographically less than the right operand only if their first components are equal and the tail of the left operand is lexicographically less than that of the right (the tail consists of the remaining components beyond the first and can be null).
  3. For the evaluation of a membership test, the simple_expression and the range (if any) are evaluated in an arbitrary order.
  4. A membership test using in yields the result True if:
    1. The tested type is scalar, and the value of the simple_expression belongs to the given range, or the range of the named subtype; or
    2. The tested type is not scalar, and the value of the simple_ expression satisfies any constraints of the named subtype, and, if the type of the simple_expression is class-wide, the value has a tag that identifies a type covered by the tested type.
  1. Otherwise the test yields the result False.
  2. A membership test using not in gives the complementary result to the corresponding membership test using in. NOTES
  3. (13) No exception is ever raised by a membership test, by a predefined ordering operator, or by a predefined equality operator for an elementary type, but an exception can be raised by the evaluation of the operands. A predefined equality operator for a composite type can only raise an exception if the type has a tagged part whose primitive equals operator propagates an exception.
  4. (14) If a composite type has components that depend on discriminants, two values of this type have matching components if and only if their discriminants are equal. Two nonnull arrays have matching components if and only if the length of each dimension is the same for both.

    Examples

  5. Examples of expressions involving relational operators and membership tests: 
  6. X /= Y

  7. "" < "A" and "A" < "Aa"     --  True
"Aa" < "B" and "A" < "A  "  --  True

  8. My_Car = null
-- true if My_Car has been set to null  (see section Incomplete Type Declarations)

My_Car = Your_Car
-- true if we both share the same car

My_Car.all = Your_Car.all
-- true if the two cars are identical

  9. N not in 1 .. 10
-- range membership test

Today in Mon .. Fri
-- range membership test

Today in Weekday
-- subtype membership test  (see section Enumeration Types)

Archive in Disk_Unit
-- subtype membership test, see section Variant Parts and Discrete Choices

Tree.all in Addition'Class
-- class membership test  (see section Type Extensions)

Binary Adding Operators

Static Semantics

  1. The binary adding operators + (addition) and - (subtraction) are predefined for every specific numeric type T with their conventional meaning. They have the following specifications: 
  2. function "+"(Left, Right : T) return T
function "-"(Left, Right : T) return T
  3. The concatenation operators & are predefined for every nonlimited, one-dimensional array type T with component type C. They have the following specifications: 
  4. function "&"(Left : T; Right : T) return T
function "&"(Left : T; Right : C) return T
function "&"(Left : C; Right : T) return T
function "&"(Left : C; Right : C) return T

    Dynamic Semantics

  5. For the evaluation of a concatenation with result type T, if both operands are of type T, the result of the concatenation is a one-dimensional array whose length is the sum of the lengths of its operands, and whose components comprise the components of the left operand followed by the components of the right operand. If the left operand is a null array, the result of the concatenation is the right operand. Otherwise, the lower bound of the result is determined as follows:
    1. If the ultimate ancestor of the array type was defined by a constrained_array_definition, then the lower bound of the result is that of the index subtype;
    2. If the ultimate ancestor of the array type was defined by an unconstrained_array_definition, then the lower bound of the result is that of the left operand.
  1. The upper bound is determined by the lower bound and the length. A check is made that the upper bound of the result of the concatenation belongs to the range of the index subtype, unless the result is a null array. Constraint_Error is raised if this check fails.
  2. If either operand is of the component type C, the result of the concatenation is given by the above rules, using in place of such an operand an array having this operand as its only component (converted to the component subtype) and having the lower bound of the index subtype of the array type as its lower bound.
  3. The result of a concatenation is defined in terms of an assignment to an anonymous object, as for any function call, see section Return Statements. NOTES
  4. (15) As for all predefined operators on modular types, the binary adding operators + and - on modular types include a final reduction modulo the modulus if the result is outside the base range of the type.

    Examples

  5. Examples of expressions involving binary adding operators: 
  6. Z + 0.1
--  Z has to be of a real type

  7. "A" & "BCD"
--  concatenation of two string literals

'A' & "BCD"
--  concatenation of a character literal and a string literal

'A' & 'A'
--  concatenation of two character literals

Unary Adding Operators

Static Semantics

  1. The unary adding operators + (identity) and - (negation) are predefined for every specific numeric type T with their conventional meaning. They have the following specifications: 
  2. function "+"(Right : T) return T
function "-"(Right : T) return T
    NOTES
  3. (16) For modular integer types, the unary adding operator -, when given a nonzero operand, returns the result of subtracting the value of the operand from the modulus; for a zero operand, the result is zero.

Multiplying Operators

Static Semantics

  1. The multiplying operators * (multiplication), / (division), mod (modulus), and rem (remainder) are predefined for every specific integer type T: 
  2. function "*"  (Left, Right : T) return T
function "/"  (Left, Right : T) return T
function "mod"(Left, Right : T) return T
function "rem"(Left, Right : T) return T
  3. Signed integer multiplication has its conventional meaning.
  4. Signed integer division and remainder are defined by the relation: 
  5. A = (A/B)*B + (A rem B)
  6. where (A rem B) has the sign of A and an absolute value less than the absolute value of B. Signed integer division satisfies the identity: 
  7. (-A)/B = -(A/B) = A/(-B)
  8. The signed integer modulus operator is defined such that the result of A mod B has the sign of B and an absolute value less than the absolute value of B; in addition, for some signed integer value N, this result satisfies the relation: 
  9. A = B*N + (A mod B)
  10. The multiplying operators on modular types are defined in terms of the corresponding signed integer operators, followed by a reduction modulo the modulus if the result is outside the base range of the type (which is only possible for the "*" operator).
  11. Multiplication and division operators are predefined for every specific floating point type T: 
  12. function "*"(Left, Right : T) return T
function "/"(Left, Right : T) return T
  13. The following multiplication and division operators, with an operand of the predefined type Integer, are predefined for every specific fixed point type T: 
  14. function "*"(Left : T; Right : Integer) return T
function "*"(Left : Integer; Right : T) return T
function "/"(Left : T; Right : Integer) return T
  15. All of the above multiplying operators are usable with an operand of an appropriate universal numeric type. The following additional multiplying operators for root_real are predefined, and are usable when both operands are of an appropriate universal or root numeric type, and the result is allowed to be of type root_real, as in a number_declaration: 
  16. function "*"(Left, Right : root_real) return root_real
function "/"(Left, Right : root_real) return root_real

  17. function "*"(Left : root_real; Right : root_integer) return root_real
function "*"(Left : root_integer; Right : root_real) return root_real
function "/"(Left : root_real; Right : root_integer) return root_real
  18. Multiplication and division between any two fixed point types are provided by the following two predefined operators: 
  19. function "*"(Left, Right : universal_fixed) return universal_fixed
function "/"(Left, Right : universal_fixed) return universal_fixed

    Legality Rules

  20. The above two fixed-fixed multiplying operators shall not be used in a context where the expected type for the result is itself universal_fixed -- the context has to identify some other numeric type to which the result is to be converted, either explicitly or implicitly.

    Dynamic Semantics

  21. The multiplication and division operators for real types have their conventional meaning. For floating point types, the accuracy of the result is determined by the precision of the result type. For decimal fixed point types, the result is truncated toward zero if the mathematical result is between two multiples of the small of the specific result type (possibly determined by context); for ordinary fixed point types, if the mathematical result is between two multiples of the small, it is unspecified which of the two is the result.
  22. The exception Constraint_Error is raised by integer division, rem, and mod if the right operand is zero. Similarly, for a real type T with T'Machine_Overflows True, division by zero raises Constraint_Error. NOTES
  23. (17) For positive A and B, A/B is the quotient and A rem B is the remainder when A is divided by B. The following relations are satisfied by the rem operator: 
  24.   A  rem (-B) =   A rem B
(-A) rem   B  = -(A rem B)
  25. (18) For any signed integer K, the following identity holds: 
  26.   A mod B   =   (A + K*B) mod B
  27. The relations between signed integer division, remainder, and modulus are illustrated by the following table: 
  28.   A    B  A/B  A rem B  A mod B    A   B  A/B  A rem B  A mod B

  29.   10   5   2      0        0      -10  5   -2     0        0
  11   5   2      1        1      -11  5   -2    -1        4
  12   5   2      2        2      -12  5   -2    -2        3
  13   5   2      3        3      -13  5   -2    -3        2
  14   5   2      4        4      -14  5   -2    -4        1

  30.   A    B  A/B  A rem B  A mod B    A   B  A/B  A rem B  A mod B
  10  -5   -2     0        0      -10 -5    2     0        0
  11  -5   -2     1       -4      -11 -5    2    -1       -1
  12  -5   -2     2       -3      -12 -5    2    -2       -2
  13  -5   -2     3       -2      -13 -5    2    -3       -3
  14  -5   -2     4       -1      -14 -5    2    -4       -4

    Examples

  31. Examples of expressions involving multiplying operators: 
  32. I : Integer := 1;
J : Integer := 2;
K : Integer := 3;

  33. X : Real := 1.0;       --  see section Floating Point Types
Y : Real := 2.0;

  34. F : Fraction := 0.25;  --  see section Fixed Point Types
G : Fraction := 0.5;

  35. Expression     Value  Result Type

I*J            2      same as I and J, that is, Integer
K/J            1      same as K and J, that is, Integer
K mod J        1      same as K and J, that is, Integer

X/Y            0.5    same as X and Y, that is, Real
F/2            0.125  same as F, that is, Fraction

3*F            0.75   same as F, that is, Fraction
0.75*G         0.375  universal_fixed, implicitly convertible
                      to any fixed point type
Fraction(F*G)  0.125  Fraction, as stated by the conversion
Real(J)*Y      4.0    Real, the type of both operands after
                      conversion of J

Highest Precedence Operators

Static Semantics

  1. The highest precedence unary operator abs (absolute value) is predefined for every specific numeric type T, with the following specification: 
  2. function "abs"(Right : T) return T
  3. The highest precedence unary operator not (logical negation) is predefined for every boolean type T, every modular type T, and for every one-dimensional array type T whose components are of a boolean type, with the following specification: 
  4. function "not"(Right : T) return T
  5. The result of the operator not for a modular type is defined as the difference between the high bound of the base range of the type and the value of the operand. For a binary modulus, this corresponds to a bit-wise complement of the binary representation of the value of the operand.
  6. The operator not that applies to a one-dimensional array of boolean components yields a one-dimensional boolean array with the same bounds; each component of the result is obtained by logical negation of the corresponding component of the operand (that is, the component that has the same index value). A check is made that each component of the result belongs to the component subtype; the exception Constraint_Error is raised if this check fails.
  7. The highest precedence exponentiation operator ** is predefined for every specific integer type T with the following specification: 
  8. function "**"(Left : T; Right : Natural) return T
  9. Exponentiation is also predefined for every specific floating point type as well as root_real, with the following specification (where T is root_real or the floating point type): 
  10. function "**"(Left : T; Right : Integer'Base) return T
  11. The right operand of an exponentiation is the exponent. The expression X**N with the value of the exponent N positive is equivalent to the expression X*X*...X (with N-1 multiplications) except that the multiplications are associated in an arbitrary order. With N equal to zero, the result is one. With the value of N negative (only defined for a floating point operand), the result is the reciprocal of the result using the absolute value of N as the exponent.

    Implementation Permissions

  12. The implementation of exponentiation for the case of a negative exponent is allowed to raise Constraint_Error if the intermediate result of the repeated multiplications is outside the safe range of the type, even though the final result (after taking the reciprocal) would not be. (The best machine approximation to the final result in this case would generally be 0.0.) NOTES
  13. (19) As implied by the specification given above for exponentiation of an integer type, a check is made that the exponent is not negative. Constraint_Error is raised if this check fails.

Type Conversions

  1. Explicit type conversions, both value conversions and view conversions, are allowed between closely related types as defined below. This clause also defines rules for value and view conversions to a particular subtype of a type, both explicit ones and those implicit in other constructs.

    Syntax 

  2. type_conversion ::=
     subtype_mark(expression)
   | subtype_mark(name)
  3. The target subtype of a type_conversion is the subtype denoted by the subtype_mark. The operand of a type_conversion is the expression or name within the parentheses; its type is the operand type.
  4. One type is convertible to a second type if a type_conversion with the first type as operand type and the second type as target type is legal according to the rules of this clause. Two types are convertible if each is convertible to the other.
  5. A type_conversion whose operand is the name of an object is called a view conversion if its target type is tagged, or if it appears as an actual parameter of mode out or in out; other type_conversions are called value conversions.

    Name Resolution Rules

  6. The operand of a type_conversion is expected to be of any type.
  7. The operand of a view conversion is interpreted only as a name; the operand of a value conversion is interpreted as an expression.

    Legality Rules

  8. If the target type is a numeric type, then the operand type shall be a numeric type.
  9. If the target type is an array type, then the operand type shall be an array type. Further:
    1. The types shall have the same dimensionality;
    2. Corresponding index types shall be convertible; and
    3. The component subtypes shall statically match.
  1. If the target type is a general access type, then the operand type shall be an access-to-object type. Further:
    1. If the target type is an access-to-variable type, then the operand type shall be an access-to-variable type;
    2. If the target designated type is tagged, then the operand designated type shall be convertible to the target designated type;
    3. If the target designated type is not tagged, then the designated types shall be the same, and either the designated subtypes shall statically match or the target designated subtype shall be discriminated and unconstrained; and
    4. The accessibility level of the operand type shall not be statically deeper than that of the target type. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, this rule applies also in the private part of an instance of a generic unit.
  1. If the target type is an access-to-subprogram type, then the operand type shall be an access-to-subprogram type. Further:
    1. The designated profiles shall be subtype-conformant.
    2. The accessibility level of the operand type shall not be statically deeper than that of the target type. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, this rule applies also in the private part of an instance of a generic unit. If the operand type is declared within a generic body, the target type shall be declared within the generic body.
  1. If the target type is not included in any of the above four cases, there shall be a type that is an ancestor of both the target type and the operand type. Further, if the target type is tagged, then either:
    1. The operand type shall be covered by or descended from the target type; or
    2. The operand type shall be a class-wide type that covers the target type.
  1. In a view conversion for an untagged type, the target type shall be convertible (back) to the operand type.

    Static Semantics

  2. A type_conversion that is a value conversion denotes the value that is the result of converting the value of the operand to the target subtype.
  3. A type_conversion that is a view conversion denotes a view of the object denoted by the operand. This view is a variable of the target type if the operand denotes a variable; otherwise it is a constant of the target type.
  4. The nominal subtype of a type_conversion is its target subtype.

    Dynamic Semantics

  5. For the evaluation of a type_conversion that is a value conversion, the operand is evaluated, and then the value of the operand is converted to a corresponding value of the target type, if any. If there is no value of the target type that corresponds to the operand value, Constraint_Error is raised; this can only happen on conversion to a modular type, and only when the operand value is outside the base range of the modular type. Additional rules follow:
    1. Numeric Type Conversion
      1. If the target and the operand types are both integer types, then the result is the value of the target type that corresponds to the same mathematical integer as the operand.
      2. If the target type is a decimal fixed point type, then the result is truncated (toward 0) if the value of the operand is not a multiple of the small of the target type.
      3. If the target type is some other real type, then the result is within the accuracy of the target type (see section Numeric Performance Requirements, for implementations that support the Numerics Annex).
      4. If the target type is an integer type and the operand type is real, the result is rounded to the nearest integer (away from zero if exactly halfway between two integers).
    1. Enumeration Type Conversion
      1. The result is the value of the target type with the same position number as that of the operand value.
    1. Array Type Conversion
      1. If the target subtype is a constrained array subtype, then a check is made that the length of each dimension of the value of the operand equals the length of the corresponding dimension of the target subtype. The bounds of the result are those of the target subtype.
      2. If the target subtype is an unconstrained array subtype, then the bounds of the result are obtained by converting each bound of the value of the operand to the corresponding index type of the target type. For each nonnull index range, a check is made that the bounds of the range belong to the corresponding index subtype.
      3. In either array case, the value of each component of the result is that of the matching component of the operand value, see section Relational Operators and Membership Tests.
    1. Composite (Non-Array) Type Conversion
      1. The value of each nondiscriminant component of the result is that of the matching component of the operand value.
      2. The tag of the result is that of the operand. If the operand type is class-wide, a check is made that the tag of the operand identifies a (specific) type that is covered by or descended from the target type.
      3. For each discriminant of the target type that corresponds to a discriminant of the operand type, its value is that of the corresponding discriminant of the operand value; if it corresponds to more than one discriminant of the operand type, a check is made that all these discriminants are equal in the operand value.
      4. For each discriminant of the target type that corresponds to a discriminant that is specified by the derived_type_definition for some ancestor of the operand type (or if class-wide, some ancestor of the specific type identified by the tag of the operand), its value in the result is that specified by the derived_type_definition.
      5. For each discriminant of the operand type that corresponds to a discriminant that is specified by the derived_type_definition for some ancestor of the target type, a check is made that in the operand value it equals the value specified for it.
      6. For each discriminant of the result, a check is made that its value belongs to its subtype.
    1. Access Type Conversion
      1. For an access-to-object type, a check is made that the accessibility level of the operand type is not deeper than that of the target type.
      2. If the target type is an anonymous access type, a check is made that the value of the operand is not null; if the target is not an anonymous access type, then the result is null if the operand value is null.
      3. If the operand value is not null, then the result designates the same object (or subprogram) as is designated by the operand value, but viewed as being of the target designated subtype (or profile); any checks associated with evaluating a conversion to the target designated subtype are performed.
  1. After conversion of the value to the target type, if the target subtype is constrained, a check is performed that the value satisfies this constraint.
  2. For the evaluation of a view conversion, the operand name is evaluated, and a new view of the object denoted by the operand is created, whose type is the target type; if the target type is composite, checks are performed as above for a value conversion.
  3. The properties of this new view are as follows:
    1. If the target type is composite, the bounds or discriminants (if any) of the view are as defined above for a value conversion; each nondiscriminant component of the view denotes the matching component of the operand object; the subtype of the view is constrained if either the target subtype or the operand object is constrained, or if the operand type is a descendant of the target type, and has discriminants that were not inherited from the target type;
    2. If the target type is tagged, then an assignment to the view assigns to the corresponding part of the object denoted by the operand; otherwise, an assignment to the view assigns to the object, after converting the assigned value to the subtype of the object (which might raise Constraint_Error);
    3. Reading the value of the view yields the result of converting the value of the operand object to the target subtype (which might raise Constraint_Error), except if the object is of an access type and the view conversion is passed as an out parameter; in this latter case, the value of the operand object is used to initialize the formal parameter without checking against any constraint of the target subtype (see section Parameter Associations).
  1. If an Accessibility_Check fails, Program_Error is raised. Any other check associated with a conversion raises Constraint_Error if it fails.
  2. Conversion to a type is the same as conversion to an unconstrained subtype of the type. NOTES
  3. (20) In addition to explicit type_conversions, type conversions are performed implicitly in situations where the expected type and the actual type of a construct differ, as is permitted by the type resolution rules, see section The Context of Overload Resolution. For example, an integer literal is of the type universal_integer, and is implicitly converted when assigned to a target of some specific integer type. Similarly, an actual parameter of a specific tagged type is implicitly converted when the corresponding formal parameter is of a class-wide type.
  4. Even when the expected and actual types are the same, implicit subtype conversions are performed to adjust the array bounds (if any) of an operand to match the desired target subtype, or to raise Constraint_Error if the (possibly adjusted) value does not satisfy the constraints of the target subtype.
  5. (21) A ramification of the overload resolution rules is that the operand of an (explicit) type_conversion cannot be the literal null, an allocator, an aggregate, a string_literal, a character_literal, or an attribute_reference for an Access or Unchecked_Access attribute. Similarly, such an expression enclosed by parentheses is not allowed. A qualified_expression, see section Qualified Expressions, can be used instead of such a type_conversion.
  6. (22) The constraint of the target subtype has no effect for a type_conversion of an elementary type passed as an out parameter. Hence, it is recommended that the first subtype be specified as the target to minimize confusion (a similar recommendation applies to renaming and generic formal in out objects).

    Examples

  7. Examples of numeric type conversion: 
  8. Real(2*J)      --  value is converted to floating point
Integer(1.6)   --  value is 2
Integer(-0.4)  --  value is 0
  9. Example of conversion between derived types: 
  10. type A_Form is new B_Form;

  11. X : A_Form;
Y : B_Form;

  12. X := A_Form(Y);
Y := B_Form(X);  --  the reverse conversion
  13. Examples of conversions between array types: 
  14. type Sequence is array (Integer range <>) of Integer;
subtype Dozen is Sequence(1 .. 12);
Ledger : array(1 .. 100) of Integer;

  15. Sequence(Ledger)            --  bounds are those of Ledger
Sequence(Ledger(31 .. 42))  --  bounds are 31 and 42
Dozen(Ledger(31 .. 42))     --  bounds are those of Dozen

Qualified Expressions

  1. A qualified_expression is used to state explicitly the type, and to verify the subtype, of an operand that is either an expression or an aggregate.

    Syntax 

  2. qualified_expression ::=
   subtype_mark'(expression) | subtype_mark'aggregate

    Name Resolution Rules

  3. The operand (the expression or aggregate) shall resolve to be of the type determined by the subtype_mark, or a universal type that covers it.

    Dynamic Semantics

  4. The evaluation of a qualified_expression evaluates the operand (and if of a universal type, converts it to the type determined by the subtype_mark) and checks that its value belongs to the subtype denoted by the subtype_mark. The exception Constraint_Error is raised if this check fails. NOTES
  5. (23) When a given context does not uniquely identify an expected type, a qualified_expression can be used to do so. In particular, if an overloaded name or aggregate is passed to an overloaded subprogram, it might be necessary to qualify the operand to resolve its type.

    Examples

  6. Examples of disambiguating expressions using qualification: 
  7. type Mask is (Fix, Dec, Exp, Signif);
type Code is (Fix, Cla, Dec, Tnz, Sub);

  8. Print (Mask'(Dec));  --  Dec is of type Mask
Print (Code'(Dec));  --  Dec is of type Code

  9. for J in Code'(Fix) .. Code'(Dec) loop ...
-- qualification needed for either Fix or Dec

for J in Code range Fix .. Dec loop ...
-- qualification unnecessary

for J in Code'(Fix) .. Dec loop ...
-- qualification unnecessary for Dec

  10. Dozen'(1 | 3 | 5 | 7 => 2, others => 0) --  see section Type Conversions

Allocators

  1. The evaluation of an allocator creates an object and yields an access value that designates the object.

    Syntax 

  2. allocator ::=
   new subtype_indication | new qualified_expression

    Name Resolution Rules

  3. The expected type for an allocator shall be a single access-to-object type whose designated type covers the type determined by the subtype_mark of the subtype_indication or qualified_expression.

    Legality Rules

  4. An initialized allocator is an allocator with a qualified_expression. An uninitialized allocator is one with a subtype_indication. In the subtype_indication of an uninitialized allocator, a constraint is permitted only if the subtype_mark denotes an unconstrained composite subtype; if there is no constraint, then the subtype_mark shall denote a definite subtype.
  5. If the type of the allocator is an access-to-constant type, the allocator shall be an initialized allocator. If the designated type is limited, the allocator shall be an uninitialized allocator.

    Static Semantics

  6. If the designated type of the type of the allocator is elementary, then the subtype of the created object is the designated subtype. If the designated type is composite, then the created object is always constrained; if the designated subtype is constrained, then it provides the constraint of the created object; otherwise, the object is constrained by its initial value (even if the designated subtype is unconstrained with defaults).

    Dynamic Semantics

  7. For the evaluation of an allocator, the elaboration of the subtype_indication or the evaluation of the qualified_expression is performed first. For the evaluation of an initialized allocator, an object of the designated type is created and the value of the qualified_expression is converted to the designated subtype and assigned to the object.
  8. For the evaluation of an uninitialized allocator:
    1. If the designated type is elementary, an object of the designated subtype is created and any implicit initial value is assigned;
    2. If the designated type is composite, an object of the designated type is created with tag, if any, determined by the subtype_mark of the subtype_indication; any per-object constraints on subcomponents are elaborated and any implicit initial values for the subcomponents of the object are obtained as determined by the subtype_indication and assigned to the corresponding subcomponents. A check is made that the value of the object belongs to the designated subtype. Constraint_Error is raised if this check fails. This check and the initialization of the object are performed in an arbitrary order.
  1. If the created object contains any tasks, they are activated (see section Task Execution - Task Activation). Finally, an access value that designates the created object is returned. NOTES
  2. (24) Allocators cannot create objects of an abstract type (see section Abstract Types and Subprograms).
  3. (25) If any part of the created object is controlled, the initialization includes calls on corresponding Initialize or Adjust procedures (see section User-Defined Assignment and Finalization).
  4. (26) As explained in section Storage Management, the storage for an object allocated by an allocator comes from a storage pool (possibly user defined). The exception Storage_Error is raised by an allocator if there is not enough storage. Instances of Unchecked_Deallocation may be used to explicitly reclaim storage.
  5. (27) Implementations are permitted, but not required, to provide garbage collection, see section Pragma Controlled.

    Examples

  6. Examples of allocators: 
  7. new Cell'(0, null, null)
-- initialized explicitly, see section Incomplete Type Declarations

new Cell'(Value => 0, Succ => null, Pred => null)
-- initialized explicitly

new Cell
-- not initialized

  8. new Matrix(1 .. 10, 1 .. 20)
-- the bounds only are given

new Matrix'(1 .. 10 => (1 .. 20 => 0.0))
-- initialized explicitly

  9. new Buffer(100)
-- the discriminant only is given

new Buffer'(Size => 80, Pos => 0, Value => (1 .. 80 => 'A'))
-- initialized explicitly

  10. Expr_Ptr'(new Literal)
-- allocator for access-to-class-wide type, see section Type Extensions

Expr_Ptr'(new Literal'(Expression with 3.5))
-- initialized explicitly

Static Expressions and Static Subtypes

  1. Certain expressions of a scalar or string type are defined to be static. Similarly, certain discrete ranges are defined to be static, and certain scalar and string subtypes are defined to be static subtypes. Static means determinable at compile time, using the declared properties or values of the program entities.
  2. A static expression is a scalar or string expression that is one of the following:
    1. a numeric_literal;
    2. a string_literal of a static string subtype;
    3. a name that denotes the declaration of a named number or a static constant;
    4. a function_call whose function_name or function_prefix statically denotes a static function, and whose actual parameters, if any (whether given explicitly or by default), are all static expressions;
    5. an attribute_reference that denotes a scalar value, and whose prefix denotes a static scalar subtype;
    6. an attribute_reference whose prefix statically denotes a statically constrained array object or array subtype, and whose attribute_designator is First, Last, or Length, with an optional dimension;
    7. a type_conversion whose subtype_mark denotes a static scalar subtype, and whose operand is a static expression;
    8. a qualified_expression whose subtype_mark denotes a static (scalar or string) subtype, and whose operand is a static expression;
    9. a membership test whose simple_expression is a static expression, and whose range is a static range or whose subtype_mark denotes a static (scalar or string) subtype;
    10. a short-circuit control form both of whose relations are static expressions;
    11. a static expression enclosed in parentheses.
  1. A name statically denotes an entity if it denotes the entity and:
    1. It is a direct_name, expanded name, or character_literal, and it denotes a declaration other than a renaming_declaration; or
    2. It is an attribute_reference whose prefix statically denotes some entity; or
    3. It denotes a renaming_declaration with a name that statically denotes the renamed entity.
  1. A static function is one of the following:
    1. a predefined operator whose parameter and result types are all scalar types none of which are descendants of formal scalar types;
    2. a predefined concatenation operator whose result type is a string type;
    3. an enumeration literal;
    4. a language-defined attribute that is a function, if the prefix denotes a static scalar subtype, and if the parameter and result types are scalar.
  1. In any case, a generic formal subprogram is not a static function.
  2. A static constant is a constant view declared by a full constant declaration or an object_renaming_declaration with a static nominal subtype, having a value defined by a static scalar expression or by a static string expression whose value has a length not exceeding the maximum length of a string_literal in the implementation.
  3. A static range is a range whose bounds are static expressions, or a range_attribute_reference that is equivalent to such a range. A static discrete_range is one that is a static range or is a subtype_indication that defines a static scalar subtype. The base range of a scalar type is a static range, unless the type is a descendant of a formal scalar type.
  4. A static subtype is either a static scalar subtype or a static string subtype. A static scalar subtype is an unconstrained scalar subtype whose type is not a descendant of a formal scalar type, or a constrained scalar subtype formed by imposing a compatible static constraint on a static scalar subtype. A static string subtype is an unconstrained string subtype whose index subtype and component subtype are static (and whose type is not a descendant of a formal array type), or a constrained string subtype formed by imposing a compatible static constraint on a static string subtype. In any case, the subtype of a generic formal object of mode in out, and the result subtype of a generic formal function, are not static.
  5. The different kinds of static constraint are defined as follows:
    1. A null constraint is always static;
    2. A scalar constraint is static if it has no range_constraint, or one with a static range;
    3. An index constraint is static if each discrete_range is static, and each index subtype of the corresponding array type is static;
    4. A discriminant constraint is static if each expression of the constraint is static, and the subtype of each discriminant is static.
  1. A subtype is statically constrained if it is constrained, and its constraint is static. An object is statically constrained if its nominal subtype is statically constrained, or if it is a static string constant.

    Legality Rules

  2. A static expression is evaluated at compile time except when it is part of the right operand of a static short-circuit control form whose value is determined by its left operand. This evaluation is performed exactly, without performing Overflow_Checks. For a static expression that is evaluated:
    1. The expression is illegal if its evaluation fails a language-defined check other than Overflow_Check.
    2. If the expression is not part of a larger static expression, then its value shall be within the base range of its expected type. Otherwise, the value may be arbitrarily large or small.
    3. If the expression is of type universal_real and its expected type is a decimal fixed point type, then its value shall be a multiple of the small of the decimal type.
  1. The last two restrictions above do not apply if the expected type is a descendant of a formal scalar type (or a corresponding actual type in an instance).

    Implementation Requirements

  2. For a real static expression that is not part of a larger static expression, and whose expected type is not a descendant of a formal scalar type, the implementation shall round or truncate the value (according to the Machine_Rounds attribute of the expected type) to the nearest machine number of the expected type; if the value is exactly half-way between two machine numbers, any rounding shall be performed away from zero. If the expected type is a descendant of a formal scalar type, no special rounding or truncating is required -- normal accuracy rules apply, see section Numerics (normative). NOTES
  3. (28) An expression can be static even if it occurs in a context where staticness is not required.
  4. (29) A static (or run-time) type_conversion from a real type to an integer type performs rounding. If the operand value is exactly half-way between two integers, the rounding is performed away from zero.

    Examples

  5. Examples of static expressions: 
  6. 1 + 1       -- 2
abs(-10)*3  -- 30

  7. Kilo : constant := 1000;
Mega : constant := Kilo*Kilo;   -- 1_000_000
Long : constant := Float'Digits*2;

  8. Half_Pi    : constant := Pi/2;
--  see section Number Declarations.

Deg_To_Rad : constant := Half_Pi/90;

Rad_To_Deg : constant := 1.0/Deg_To_Rad;
-- equivalent to 1.0/((3.14159_26536/2)/90)

Statically Matching Constraints and Subtypes

Static Semantics

  1. A constraint statically matches another constraint if both are null constraints, both are static and have equal corresponding bounds or discriminant values, or both are nonstatic and result from the same elaboration of a constraint of a subtype_indication or the same evaluation of a range of a discrete_subtype_definition.
  2. A subtype statically matches another subtype of the same type if they have statically matching constraints. Two anonymous access subtypes statically match if their designated subtypes statically match.
  3. Two ranges of the same type statically match if both result from the same evaluation of a range, or if both are static and have equal corresponding bounds.
  4. A constraint is statically compatible with a scalar subtype if it statically matches the constraint of the subtype, or if both are static and the constraint is compatible with the subtype. A constraint is statically compatible with an access or composite subtype if it statically matches the constraint of the subtype, or if the subtype is unconstrained. One subtype is statically compatible with a second subtype if the constraint of the first is statically compatible with the second subtype.

Statements

  1. A statement defines an action to be performed upon its execution.
  2. This section describes the general rules applicable to all statements. Some statements are discussed in later sections: Procedure_call_statements and return_statements are described in section Subprograms. Entry_call_statements, requeue_statements, delay_statements, accept_statements, select_statements, and abort_statements are described in section Tasks and Synchronization. Raise_statements are described in section Exceptions, and code_statements in section Representation Issues. The remaining forms of statements are presented in this section.

Simple and Compound Statements - Sequences of Statements

  1. A statement is either simple or compound. A simple_statement encloses no other statement. A compound_statement can enclose simple_statements and other compound_statements.

    Syntax 

  2. sequence_of_statements ::= statement {statement}

  3. statement ::=
   {label} simple_statement | {label} compound_statement

  4. simple_statement ::= null_statement
   | assignment_statement   | exit_statement
   | goto_statement         | procedure_call_statement
   | return_statement       | entry_call_statement
   | requeue_statement      | delay_statement
   | abort_statement        | raise_statement
   | code_statement

  5. compound_statement ::=
     if_statement           | case_statement
   | loop_statement         | block_statement
   | accept_statement       | select_statement

  6. null_statement ::= null;

  7. label ::= <<label_statement_identifier>>

  8. statement_identifier ::= direct_name
    1. The direct_name of a statement_identifier shall be an identifier (not an operator_symbol).

Name Resolution Rules

  1. The direct_name of a statement_identifier shall resolve to denote its corresponding implicit declaration (see below).

    Legality Rules

  2. Distinct identifiers shall be used for all statement_identifiers that appear in the same body, including inner block_statements but excluding inner program units.

    Static Semantics

  3. For each statement_identifier, there is an implicit declaration (with the specified identifier) at the end of the declarative_part of the innermost block_statement or body that encloses the statement_identifier. The implicit declarations occur in the same order as the statement_identifiers occur in the source text. If a usage name denotes such an implicit declaration, the entity it denotes is the label, loop_statement, or block_statement with the given statement_identifier.

    Dynamic Semantics

  4. The execution of a null_statement has no effect.
  5. A transfer of control is the run-time action of an exit_statement, return_statement, goto_statement, or requeue_statement, selection of a terminate_alternative, raising of an exception, or an abort, which causes the next action performed to be one other than what would normally be expected from the other rules of the language. As explained in section Completion and Finalization, a transfer of control can cause the execution of constructs to be completed and then left, which may trigger finalization.
  6. The execution of a sequence_of_statements consists of the execution of the individual statements in succession until the sequence_ is completed. NOTES
  7. (1) A statement_identifier that appears immediately within the declarative region of a named loop_statement or an accept_statement is nevertheless implicitly declared immediately within the declarative region of the innermost enclosing body or block_statement; in other words, the expanded name for a named statement is not affected by whether the statement occurs inside or outside a named loop or an accept_statement -- only nesting within block_statements is relevant to the form of its expanded name.

    Examples

  8. Examples of labeled statements: 
  9. <<Here>> <<Ici>> <<Aqui>> <<Hier>> null;

  10. <<After>> X := 1;

Assignment Statements

  1. An assignment_statement replaces the current value of a variable with the result of evaluating an expression.

    Syntax 

  2. assignment_statement ::= variable_name := expression;
  3. The execution of an assignment_statement includes the evaluation of the expression and the assignment of the value of the expression into the target. An assignment operation (as opposed to an assignment_statement) is performed in other contexts as well, including object initialization and by-copy parameter passing. The target of an assignment operation is the view of the object to which a value is being assigned; the target of an assignment_statement is the variable denoted by the variable_name.

    Name Resolution Rules

  4. The variable_name of an assignment_statement is expected to be of any nonlimited type. The expected type for the expression is the type of the target.

    Legality Rules

  5. The target denoted by the variable_name shall be a variable.
  6. If the target is of a tagged class-wide type T'Class, then the expression shall either be dynamically tagged, or of type T and tag-indeterminate, see section Dispatching Operations of Tagged Types.

    Dynamic Semantics

  7. For the execution of an assignment_statement, the variable_name and the expression are first evaluated in an arbitrary order.
  8. When the type of the target is class-wide:
    1. If the expression is tag-indeterminate, see section Dispatching Operations of Tagged Types, then the controlling tag value for the expression is the tag of the target;
    2. Otherwise (the expression is dynamically tagged), a check is made that the tag of the value of the expression is the same as that of the target; if this check fails, Constraint_Error is raised.
  1. The value of the expression is converted to the subtype of the target. The conversion might raise an exception, see section Type Conversions.
  2. In cases involving controlled types, the target is finalized, and an anonymous object might be used as an intermediate in the assignment, as described in section Completion and Finalization. In any case, the converted value of the expression is then assigned to the target, which consists of the following two steps:
    1. The value of the target becomes the converted value.
    2. If any part of the target is controlled, its value is adjusted as explained in section User-Defined Assignment and Finalization.
    NOTES
  1. (2) The tag of an object never changes; in particular, an assignment_statement does not change the tag of the target.
  2. (3) The values of the discriminants of an object designated by an access value cannot be changed (not even by assigning a complete value to the object itself) since such objects are always constrained; however, subcomponents of such objects may be unconstrained.

    Examples

  3. Examples of assignment statements: 
  4. Value := Max_Value - 1;
Shade := Blue;

  5. Next_Frame(F)(M, N) := 2.5;  --  see section Indexed Components
U := Dot_Product(V, W);      --  see section Subprogram Bodies

  6. Writer := (Status => Open, Unit => Printer, Line_Count => 60);
--  see section Variant Parts and Discrete Choices

Next_Car.all := (72074, null);
--  see section Incomplete Type Declarations
  7. Examples involving scalar subtype conversions: 
  8. I, J : Integer range 1 .. 10 := 5;
K    : Integer range 1 .. 20 := 15;
 ...

  9. I := J;  --  identical ranges
K := J;  --  compatible ranges
J := K;  --  will raise Constraint_Error if K > 10
  10. Examples involving array subtype conversions: 
  11. A : String(1 .. 31);
B : String(3 .. 33);
 ...

  12. A := B;  --  same number of components

  13. A(1 .. 9)  := "tar sauce";
A(4 .. 12) := A(1 .. 9);  --  A(1 .. 12) = "tartar sauce"
    NOTES
  14. (4) Notes on the examples: Assignment_statements are allowed even in the case of overlapping slices of the same array, because the variable_name and expression are both evaluated before copying the value into the variable. In the above example, an implementation yielding A(1 .. 12) = "tartartartar" would be incorrect.

If Statements

  1. An if_statement selects for execution at most one of the enclosed sequences_of_statements, depending on the (truth) value of one or more corresponding conditions.

    Syntax 

  2. if_statement ::=
    if condition then
       sequence_of_statements
    {elsif condition then
       sequence_of_statements}
    [else
       sequence_of_statements]
    end if;

  3. condition ::= boolean_expression

    Name Resolution Rules

  4. A condition is expected to be of any boolean type.

    Dynamic Semantics

  5. For the execution of an if_statement, the condition specified after if, and any conditions specified after elsif, are evaluated in succession (treating a final else as elsif True then), until one evaluates to True or all conditions are evaluated and yield False. If a condition evaluates to True, then the corresponding sequence_of_statements is executed; otherwise none of them is executed.

    Examples

  6. Examples of if statements: 
  7. if Month = December and Day = 31 then
   Month := January;
   Day   := 1;
   Year  := Year + 1;
end if;

  8. if Line_Too_Short then
   raise Layout_Error;
elsif Line_Full then
   New_Line;
   Put(Item);
else
   Put(Item);
end if;

  9. if My_Car.Owner.Vehicle /= My_Car then  --  see section Incomplete Type Declarations
   Report ("Incorrect data");
end if;

Case Statements

  1. A case_statement selects for execution one of a number of alternative sequences_of_statements; the chosen alternative is defined by the value of an expression.

    Syntax 

  2. case_statement ::=
   case expression is
      case_statement_alternative
      {case_statement_alternative}
   end case;

  3. case_statement_alternative ::=
   when discrete_choice_list =>
      sequence_of_statements

    Name Resolution Rules

  4. The expression is expected to be of any discrete type. The expected type for each discrete_choice is the type of the expression.

    Legality Rules

  5. The expressions and discrete_ranges given as discrete_choices of a case_statement shall be static. A discrete_choice others, if present, shall appear alone and in the last discrete_choice_list.
  6. The possible values of the expression shall be covered as follows:
    1. If the expression is a name (including a type_conversion or a function_call) having a static and constrained nominal subtype, or is a qualified_expression whose subtype_mark denotes a static and constrained scalar subtype, then each non-others discrete_choice shall cover only values in that subtype, and each value of that subtype shall be covered by some discrete_choice (either explicitly or by others).
    2. If the type of the expression is root_integer, universal_integer, or a descendant of a formal scalar type, then the case_statement shall have an others discrete_choice.
    3. Otherwise, each value of the base range of the type of the expression shall be covered (either explicitly or by others).
  1. Two distinct discrete_choices of a case_statement shall not cover the same value.

    Dynamic Semantics

  2. For the execution of a case_statement the expression is first evaluated.
  3. If the value of the expression is covered by the discrete_choice_list of some case_statement_alternative, then the sequence_of_statements of the _alternative is executed.
  4. Otherwise (the value is not covered by any discrete_choice_list, perhaps due to being outside the base range), Constraint_Error is raised. NOTES
  5. (5) The execution of a case_statement chooses one and only one alternative. Qualification of the expression of a case_statement by a static subtype can often be used to limit the number of choices that need be given explicitly.

    Examples

  6. Examples of case statements: 
  7. case Sensor is
   when Elevation  => Record_Elevation(Sensor_Value);
   when Azimuth    => Record_Azimuth  (Sensor_Value);
   when Distance   => Record_Distance (Sensor_Value);
   when others     => null;
end case;

  8. case Today is
   when Mon        => Compute_Initial_Balance;
   when Fri        => Compute_Closing_Balance;
   when Tue .. Thu => Generate_Report(Today);
   when Sat .. Sun => null;
end case;

  9. case Bin_Number(Count) is
   when 1      => Update_Bin(1);
   when 2      => Update_Bin(2);
   when 3 | 4  =>
      Empty_Bin(1);
      Empty_Bin(2);
   when others => raise Error;
end case;

Loop Statements

  1. A loop_statement includes a sequence_of_statements that is to be executed repeatedly, zero or more times.

    Syntax 

  2. loop_statement ::=
   [loop_statement_identifier:]
      [iteration_scheme] loop
         sequence_of_statements
      end loop [loop_identifier];

  3. iteration_scheme ::= while condition
   | for loop_parameter_specification

  4. loop_parameter_specification ::=
   defining_identifier in [reverse] discrete_subtype_definition
    1. If a loop_statement has a loop_statement_identifier, then the identifier shall be repeated after the end loop; otherwise, there shall not be an identifier after the end loop.

Static Semantics

  1. A loop_parameter_specification declares a loop parameter, which is an object whose subtype is that defined by the discrete_subtype_definition.

    Dynamic Semantics

  2. For the execution of a loop_statement, the sequence_of_statements is executed repeatedly, zero or more times, until the loop_statement is complete. The loop_statement is complete when a transfer of control occurs that transfers control out of the loop, or, in the case of an iteration_scheme, as specified below.
  3. For the execution of a loop_statement with a while iteration_scheme, the condition is evaluated before each execution of the sequence_of_statements; if the value of the condition is True, the sequence_of_statements is executed; if False, the execution of the loop_statement is complete.
  4. For the execution of a loop_statement with a for iteration_scheme, the loop_parameter_specification is first elaborated. This elaboration creates the loop parameter and elaborates the discrete_subtype_definition. If the discrete_subtype_definition defines a subtype with a null range, the execution of the loop_statement is complete. Otherwise, the sequence_of_statements is executed once for each value of the discrete subtype defined by the discrete_subtype_definition (or until the loop is left as a consequence of a transfer of control). Prior to each such iteration, the corresponding value of the discrete subtype is assigned to the loop parameter. These values are assigned in increasing order unless the reserved word reverse is present, in which case the values are assigned in decreasing order. NOTES
  5. (6) A loop parameter is a constant; it cannot be updated within the sequence_of_statements of the loop, see section Objects and Named Numbers.
  6. (7) An object_declaration should not be given for a loop parameter, since the loop parameter is automatically declared by the loop_parameter_specification. The scope of a loop parameter extends from the loop_parameter_specification to the end of the loop_statement, and the visibility rules are such that a loop parameter is only visible within the sequence_of_statements of the loop.
  7. (8) The discrete_subtype_definition of a for loop is elaborated just once. Use of the reserved word reverse does not alter the discrete subtype defined, so that the following iteration_schemes are not equivalent; the first has a null range. 
  8. for J in reverse 1 ..  0
for J in 0 .. 1

    Examples

  9. Example of a loop statement without an iteration scheme: 
  10. loop
   Get(Current_Character);
   exit when Current_Character = '*';
end loop;
  11. Example of a loop statement with a while iteration scheme: 
  12. while Bid(N).Price < Cut_Off.Price loop
   Record_Bid(Bid(N).Price);
   N := N + 1;
end loop;
  13. Example of a loop statement with a for iteration scheme: 
  14. for J in Buffer'Range loop  --  works even with a null range
   if Buffer(J) /= Space then
      Put(Buffer(J));
   end if;
end loop;
  15. Example of a loop statement with a name: 
  16. Summation:
   while Next /= Head loop  --  see section Incomplete Type Declarations
      Sum  := Sum + Next.Value;
      Next := Next.Succ;
   end loop Summation;

Block Statements

  1. A block_statement encloses a handled_sequence_of_statements optionally preceded by a declarative_part.

    Syntax 

  2. block_statement ::=
   [block_statement_identifier:]
      [declare
         declarative_part]
      begin
         handled_sequence_of_statements
      end [block_identifier];
    1. If a block_statement has a block_statement_identifier, then the identifier shall be repeated after the end; otherwise, there shall not be an identifier after the end.

Static Semantics

  1. A block_statement that has no explicit declarative_part has an implicit empty declarative_part.

    Dynamic Semantics

  2. The execution of a block_statement consists of the elaboration of its declarative_part followed by the execution of its handled_sequence_of_statements.

    Examples

  3. Example of a block statement with a local variable: 
  4. Swap:
   declare
      Temp : Integer;
   begin
      Temp := V; V := U; U := Temp;
   end Swap;

Exit Statements

  1. An exit_statement is used to complete the execution of an enclosing loop_statement; the completion is conditional if the exit_statement includes a condition.

    Syntax 

  2. exit_statement ::= exit [loop_name] [when condition];

    Name Resolution Rules

  3. The loop_name, if any, in an exit_statement shall resolve to denote a loop_statement.

    Legality Rules

  4. Each exit_statement applies to a loop_statement; this is the loop_statement being exited. An exit_statement with a name is only allowed within the loop_statement denoted by the name, and applies to that loop_statement. An exit_statement without a name is only allowed within a loop_statement, and applies to the innermost enclosing one. An exit_statement that applies to a given loop_statement shall not appear within a body or accept_statement, if this construct is itself enclosed by the given loop_statement.

    Dynamic Semantics

  5. For the execution of an exit_statement, the condition, if present, is first evaluated. If the value of the condition is True, or if there is no condition, a transfer of control is done to complete the loop_statement. If the value of the condition is False, no transfer of control takes place. NOTES
  6. (9) Several nested loops can be exited by an exit_statement that names the outer loop.

    Examples

  7. Examples of loops with exit statements: 
  8. for N in 1 .. Max_Num_Items loop
   Get_New_Item(New_Item);
   Merge_Item(New_Item, Storage_File);
   exit when New_Item = Terminal_Item;
end loop;

  9. Main_Cycle:
   loop
      --  initial statements
      exit Main_Cycle when Found;
      --  final statements
   end loop Main_Cycle;

Goto Statements

  1. A goto_statement specifies an explicit transfer of control from this statement to a target statement with a given label.

    Syntax 

  2. goto_statement ::= goto label_name;

    Name Resolution Rules

  3. The label_name shall resolve to denote a label; the statement with that label is the target statement.

    Legality Rules

  4. The innermost sequence_of_statements that encloses the target statement shall also enclose the goto_statement. Furthermore, if a goto_statement is enclosed by an accept_statement or a body, then the target statement shall not be outside this enclosing construct.

    Dynamic Semantics

  5. The execution of a goto_statement transfers control to the target statement, completing the execution of any compound_statement that encloses the goto_statement but does not enclose the target. NOTES
  6. (10) The above rules allow transfer of control to a statement of an enclosing sequence_of_statements but not the reverse. Similarly, they prohibit transfers of control such as between alternatives of a case_statement, if_statement, or select_statement; between exception_handlers; or from an exception_handler of a handled_sequence_of_statements back to its sequence_of_statements.

    Examples

  7. Example of a loop containing a goto statement: 
  8. <<Sort>>
for I in 1 .. N-1 loop
   if A(I) > A(I+1) then
      Exchange(A(I), A(I+1));
      goto Sort;
   end if;
end loop;

Subprograms

  1. A subprogram is a program unit or intrinsic operation whose execution is invoked by a subprogram call. There are two forms of subprogram: procedures and functions. A procedure call is a statement; a function call is an expression and returns a value. The definition of a subprogram can be given in two parts: a subprogram declaration defining its interface, and a subprogram_body defining its execution. Operators and enumeration literals are functions.
  2. A callable entity is a subprogram or entry, see section Tasks and Synchronization. A callable entity is invoked by a call; that is, a subprogram call or entry call. A callable construct is a construct that defines the action of a call upon a callable entity: a subprogram_body, entry_body, or accept_statement.

Subprogram Declarations

  1. A subprogram_declaration declares a procedure or function.

    Syntax 

  2. subprogram_declaration ::= subprogram_specification;

  3. abstract_subprogram_declaration ::=
   subprogram_specification is abstract;

  4. subprogram_specification ::=
     procedure defining_program_unit_name parameter_profile
   | function defining_designator parameter_and_result_profile

  5. designator ::= [parent_unit_name . ]identifier | operator_symbol

  6. defining_designator ::=
   defining_program_unit_name | defining_operator_symbol

  7. defining_program_unit_name ::=
   [parent_unit_name . ]defining_identifier
    1. The optional parent_unit_name is only allowed for library units (see section Compilation Units - Library Units). 
  1. operator_symbol ::= string_literal
    1. The sequence of characters in an operator_symbol shall correspond to an operator belonging to one of the six classes of operators defined in clause section Operators and Expression Evaluation (spaces are not allowed and the case of letters is not significant). 
  1. defining_operator_symbol ::= operator_symbol

  2. parameter_profile ::= [formal_part]

  3. parameter_and_result_profile ::= [formal_part] return subtype_mark

  4. formal_part ::=
   (parameter_specification {; parameter_specification{)

  5. parameter_specification ::=
    defining_identifier_list : mode subtype_mark
      [:= default_expression]
  | defining_identifier_list : access_definition
      [:= default_expression]

  6. mode ::= [in] | in out | out

    Name Resolution Rules

  7. A formal parameter is an object directly visible within a subprogram_body that represents the actual parameter passed to the subprogram in a call; it is declared by a parameter_specification. For a formal parameter, the expected type for its default_expression, if any, is that of the formal parameter.

    Legality Rules

  8. The parameter mode of a formal parameter conveys the direction of information transfer with the actual parameter: in, in out, or out. Mode in is the default, and is the mode of a parameter defined by an access_definition. The formal parameters of a function, if any, shall have the mode in.
  9. A default_expression is only allowed in a parameter_specification for a formal parameter of mode in.
  10. A subprogram_declaration or a generic_subprogram_declaration requires a completion: a body, a renaming_declaration, see section Renaming Declarations, or a pragma Import, see section Interfacing Pragmas. A completion is not allowed for an abstract_subprogram_declaration.
  11. A name that denotes a formal parameter is not allowed within the formal_part in which it is declared, nor within the formal_part of a corresponding body or accept_statement.

    Static Semantics

  12. The profile of (a view of) a callable entity is either a parameter_profile or parameter_and_result_profile; it embodies information about the interface to that entity -- for example, the profile includes information about parameters passed to the callable entity. All callable entities have a profile -- enumeration literals, other subprograms, and entries. An access-to-subprogram type has a designated profile. Associated with a profile is a calling convention. A subprogram_declaration declares a procedure or a function, as indicated by the initial reserved word, with name and profile as given by its specification.
  13. The nominal subtype of a formal parameter is the subtype denoted by the subtype_mark, or defined by the access_definition, in the parameter_specification.
  14. An access parameter is a formal in parameter specified by an access_definition. An access parameter is of an anonymous general access-to-variable type, see section Access Types. Access parameters allow dispatching calls to be controlled by access values.
  15. The subtypes of a profile are:
    1. For any non-access parameters, the nominal subtype of the parameter.
    2. For any access parameters, the designated subtype of the parameter type.
    3. For any result, the result subtype.
  1. The types of a profile are the types of those subtypes.
  2. A subprogram declared by an abstract_subprogram_declaration is abstract; a subprogram declared by a subprogram_declaration is not (see section Abstract Types and Subprograms).

    Dynamic Semantics

  3. The elaboration of a subprogram_declaration or an abstract_subprogram_declaration has no effect. NOTES
  4. (1) A parameter_specification with several identifiers is equivalent to a sequence of single parameter_specifications, as explained in 3.3.
  5. (2) Abstract subprograms do not have bodies, and cannot be used in a nondispatching call, see section Abstract Types and Subprograms.
  6. (3) The evaluation of default_expressions is caused by certain calls, as described in section Parameter Associations. They are not evaluated during the elaboration of the subprogram declaration.
  7. (4) Subprograms can be called recursively and can be called concurrently from multiple tasks.

    Examples

  8. Examples of subprogram declarations: 
  9. procedure Traverse_Tree;
procedure Increment(X : in out Integer);
procedure Right_Indent(Margin : out Line_Size); --  see section Integer Types
procedure Switch(From, To : in out Link);       --  see section Incomplete Type Declarations

  10. function Random return Probability;             --  see section Floating Point Types

  11. function Min_Cell(X : Link) return Cell;        --  see section Incomplete Type Declarations
function Next_Frame(K : Positive) return Frame; --  see section Access Types
function Dot_Product(Left, Right : Vector) return Real;
--  see section Array Types

  12. function "*"(Left, Right : Matrix) return Matrix;
--  see section Array Types
  13. Examples of in parameters with default expressions: 
  14. procedure Print_Header
  (Pages  : in Natural;
   Header : in Line    :=  (1 .. Line'Last => ' '); --  see section Array Types
   Center : in Boolean := True);

Formal Parameter Modes

  1. A parameter_specification declares a formal parameter of mode in, in out, or out.

    Static Semantics

  2. A parameter is passed either by copy or by reference. When a parameter is passed by copy, the formal parameter denotes a separate object from the actual parameter, and any information transfer between the two occurs only before and after executing the subprogram. When a parameter is passed by reference, the formal parameter denotes (a view of) the object denoted by the actual parameter; reads and updates of the formal parameter directly reference the actual parameter object.
  3. A type is a by-copy type if it is an elementary type, or if it is a descendant of a private type whose full type is a by-copy type. A parameter of a by-copy type is passed by copy.
  4. A type is a by-reference type if it is a descendant of one of the following:
    1. a tagged type;
    2. a task or protected type;
    3. a nonprivate type with the reserved word limited in its declaration;
    4. a composite type with a subcomponent of a by-reference type;
    5. a private type whose full type is a by-reference type.
  1. A parameter of a by-reference type is passed by reference. Each value of a by-reference type has an associated object. For a parenthesized expression, qualified_expression, or type_conversion, this object is the one associated with the operand.
  2. For parameters of other types, it is unspecified whether the parameter is passed by copy or by reference.

    Bounded (Run-Time) Errors

  3. If one name denotes a part of a formal parameter, and a second name denotes a part of a distinct formal parameter or an object that is not part of a formal parameter, then the two names are considered distinct access paths. If an object is of a type for which the parameter passing mechanism is not specified, then it is a bounded error to assign to the object via one access path, and then read the value of the object via a distinct access path, unless the first access path denotes a part of a formal parameter that no longer exists at the point of the second access (due to leaving the corresponding callable construct). The possible consequences are that Program_Error is raised, or the newly assigned value is read, or some old value of the object is read. NOTES
  4. (5) A formal parameter of mode in is a constant view, see section Objects and Named Numbers, it cannot be updated within the subprogram_body.

Subprogram Bodies

  1. A subprogram_body specifies the execution of a subprogram.

    Syntax 

  2. subprogram_body ::=
   subprogram_specification is
      declarative_part
   begin
      handled_sequence_of_statements
   end [designator];
    1. If a designator appears at the end of a subprogram_body, it shall repeat the defining_designator of the subprogram_specification.

Legality Rules

  1. In contrast to other bodies, a subprogram_body need not be the completion of a previous declaration, in which case the body declares the subprogram. If the body is a completion, it shall be the completion of a subprogram_declaration or generic_subprogram_declaration. The profile of a subprogram_body that completes a declaration shall conform fully to that of the declaration.

    Static Semantics

  2. A subprogram_body is considered a declaration. It can either complete a previous declaration, or itself be the initial declaration of the subprogram.

    Dynamic Semantics

  3. The elaboration of a non-generic subprogram_body has no other effect than to establish that the subprogram can from then on be called without failing the Elaboration_Check.
  4. The execution of a subprogram_body is invoked by a subprogram call. For this execution the declarative_part is elaborated, and the handled_sequence_of_statements is then executed.

    Examples

  5. Example of procedure body: 
  6. procedure Push(E : in Element_Type; S : in out Stack) is
begin
   if S.Index = S.Size then
      raise Stack_Overflow;
   else
      S.Index := S.Index + 1;
      S.Space(S.Index) := E;
   end if;
end Push;
  7. Example of a function body: 
  8. function Dot_Product(Left, Right : Vector) return Real is
   Sum : Real := 0.0;
begin
   Check(Left'First = Right'First and Left'Last = Right'Last);
   for J in Left'Range loop
      Sum := Sum + Left(J)*Right(J);
   end loop;
   return Sum;
end Dot_Product;

Conformance Rules

  1. When subprogram profiles are given in more than one place, they are required to conform in one of four ways: type conformance, mode conformance, subtype conformance, or full conformance.

    Static Semantics

  2. As explained in section Interfacing Pragmas, a convention can be specified for an entity. For a callable entity or access-to-subprogram type, the convention is called the calling convention. The following conventions are defined by the language:
    1. The default calling convention for any subprogram not listed below is Ada. A pragma Convention, Import, or Export may be used to override the default calling convention, see section Interfacing Pragmas.
    2. The Intrinsic calling convention represents subprograms that are "built in" to the compiler. The default calling convention is Intrinsic for the following:
        1. an enumeration literal;
        2. a "/=" operator declared implicitly due to the declaration of "=" (see section Overloading of Operators);
        3. any other implicitly declared subprogram unless it is a dispatching operation of a tagged type;
        4. an inherited subprogram of a generic formal tagged type with unknown discriminants;
        5. an attribute that is a subprogram;
        6. a subprogram declared immediately within a protected_body.
      1. The Access attribute is not allowed for Intrinsic subprograms.
    1. The default calling convention is protected for a protected subprogram, and for an access-to-subprogram type with the reserved word protected in its definition.
    2. The default calling convention is entry for an entry.
  1. Of these four conventions, only Ada and Intrinsic are allowed as a convention_identifier in a pragma Convention, Import, or Export.
  2. Two profiles are type conformant if they have the same number of parameters, and both have a result if either does, and corresponding parameter and result types are the same, or, for access parameters, corresponding designated types are the same.
  3. Two profiles are mode conformant if they are type-conformant, and corresponding parameters have identical modes, and, for access parameters, the designated subtypes statically match.
  4. Two profiles are subtype conformant if they are mode-conformant, corresponding subtypes of the profile statically match, and the associated calling conventions are the same. The profile of a generic formal subprogram is not subtype-conformant with any other profile.
  5. Two profiles are fully conformant if they are subtype-conformant, and corresponding parameters have the same names and have default_expressions that are fully conformant with one another.
  6. Two expressions are fully conformant if, after replacing each use of an operator with the equivalent function_call:
    1. each constituent construct of one corresponds to an instance of the same syntactic category in the other, except that an expanded name may correspond to a direct_name (or character_literal) or to a different expanded name in the other; and
    2. each direct_name, character_literal, and selector_name that is not part of the prefix of an expanded name in one denotes the same declaration as the corresponding direct_name, character_literal, or selector_name in the other; and
    3. each primary that is a literal in one has the same value as the corresponding literal in the other.
  1. Two known_discriminant_parts are fully conformant if they have the same number of discriminants, and discriminants in the same positions have the same names, statically matching subtypes, and default_expressions that are fully conformant with one another.
  2. Two discrete_subtype_definitions are fully conformant if they are both subtype_indications or are both ranges, the subtype_marks (if any) denote the same subtype, and the corresponding simple_expressions of the ranges (if any) fully conform.

    Implementation Permissions

  3. An implementation may declare an operator declared in a language-defined library unit to be intrinsic.

Inline Expansion of Subprograms

  1. Subprograms may be expanded in line at the call site.

    Syntax

  2. The form of a pragma Inline, which is a program unit pragma (see section Pragmas and Program Units) is as follows: 
  3. pragma Inline(name {, name{);

    Legality Rules

  4. The pragma shall apply to one or more callable entities or generic subprograms.

    Static Semantics

  5. If a pragma Inline applies to a callable entity, this indicates that inline expansion is desired for all calls to that entity. If a pragma Inline applies to a generic subprogram, this indicates that inline expansion is desired for all calls to all instances of that generic subprogram.

    Implementation Permissions

  6. For each call, an implementation is free to follow or to ignore the recommendation expressed by the pragma. NOTES
  7. (6) The name in a pragma Inline can denote more than one entity in the case of overloading. Such a pragma applies to all of the denoted entities.

Subprogram Calls

  1. A subprogram call is either a procedure_call_statement or a function_call; it invokes the execution of the subprogram_body. The call specifies the association of the actual parameters, if any, with formal parameters of the subprogram.

    Syntax 

  2. procedure_call_statement ::=
     procedure_name;
   | procedure_prefix actual_parameter_part;

  3. function_call ::=
     function_name
   | function_prefix actual_parameter_part

  4. actual_parameter_part ::=
   (parameter_association {, parameter_association{)

  5. parameter_association ::=
   [formal_parameter_selector_name =>] explicit_actual_parameter

  6. explicit_actual_parameter ::= expression | variable_name
    1. A parameter_association is named or positional according to whether or not the formal_parameter_selector_name is specified. Any positional associations shall precede any named associations. Named associations are not allowed if the prefix in a subprogram call is an attribute_reference.

Name Resolution Rules

  1. The name or prefix given in a procedure_call_statement shall resolve to denote a callable entity that is a procedure, or an entry renamed as (viewed as) a procedure. The name or prefix given in a function_call shall resolve to denote a callable entity that is a function. When there is an actual_parameter_part, the prefix can be an implicit_dereference of an access-to-subprogram value.
  2. A subprogram call shall contain at most one association for each formal parameter. Each formal parameter without an association shall have a default_expression (in the profile of the view denoted by the name or prefix). This rule is an overloading rule, see section The Context of Overload Resolution.

    Dynamic Semantics

  3. For the execution of a subprogram call, the name or prefix of the call is evaluated, and each parameter_association is evaluated, see section Parameter Associations. If a default_expression is used, an implicit parameter_association is assumed for this rule. These evaluations are done in an arbitrary order. The subprogram_body is then executed. Finally, if the subprogram completes normally, then after it is left, any necessary assigning back of formal to actual parameters occurs, see section Parameter Associations.
  4. The exception Program_Error is raised at the point of a function_call if the function completes normally without executing a return_statement.
  5. A function_call denotes a constant, as defined in section Return Statements, the nominal subtype of the constant is given by the result subtype of the function.

    Examples

  6. Examples of procedure calls: 
  7. Traverse_Tree;                   --  see section Subprogram Declarations
Print_Header(128, Title, True);  --  see section Subprogram Declarations

  8. Switch(From => X, To => Next);
--  see section Subprogram Declarations.

Print_Header(128, Header => Title, Center => True);
--  see section Subprogram Declarations.

Print_Header(Header => Title, Center => True, Pages => 128);
--  see section Subprogram Declarations.
  9. Examples of function calls: 
  10. Dot_Product(U, V)   --  see section Subprogram Declarations, and section Subprogram Bodies.
Clock               --  see section Delay Statements, Duration, and Time.
F.all
--  presuming F is of an access-to-subprogram type
--  see section Access Types.
  11. Examples of procedures with default expressions: 
  12. procedure Activate(Process : in Process_Name;
                   After   : in Process_Name := No_Process;
                   Wait    : in Duration := 0.0;
                   Prior   : in Boolean := False);

  13. procedure Pair(Left, Right : in Person_Name := new Person);
--  see section Incomplete Type Declarations.
  14. Examples of their calls: 
  15. Activate(X);
Activate(X, After => Y);
Activate(X, Wait => 60.0, Prior => True);
Activate(X, Y, 10.0, False);

  16. Pair;
Pair(Left => new Person, Right => new Person);
    NOTES
  17. (7) If a default_expression is used for two or more parameters in a multiple parameter_specification, the default_expression is evaluated once for each omitted parameter. Hence in the above examples, the two calls of Pair are equivalent.

    Examples

  18. Examples of overloaded subprograms: 
  19. procedure Put(X : in Integer);
procedure Put(X : in String);

  20. procedure Set(Tint   : in Color);
procedure Set(Signal : in Light);
  21. Examples of their calls: 
  22. Put(28);
Put("no possible ambiguity here");

  23. Set(Tint   => Red);
Set(Signal => Red);
Set(Color'(Red));

  24. --  Set(Red) would be ambiguous since Red may
--  denote a value either of type Color or of type Light

Parameter Associations

  1. A parameter association defines the association between an actual parameter and a formal parameter.

    Name Resolution Rules

  2. The formal_parameter_selector_name of a parameter_association shall resolve to denote a parameter_specification of the view being called.
  3. The actual parameter is either the explicit_actual_parameter given in a parameter_association for a given formal parameter, or the corresponding default_expression if no parameter_association is given for the formal parameter. The expected type for an actual parameter is the type of the corresponding formal parameter.
  4. If the mode is in, the actual is interpreted as an expression; otherwise, the actual is interpreted only as a name, if possible.

    Legality Rules

  5. If the mode is in out or out, the actual shall be a name that denotes a variable.
  6. The type of the actual parameter associated with an access parameter shall be convertible, see section Type Conversions, to its anonymous access type.

    Dynamic Semantics

  7. For the evaluation of a parameter_association:
    1. The actual parameter is first evaluated.
    2. For an access parameter, the access_definition is elaborated, which creates the anonymous access type.
    3. For a parameter (of any mode) that is passed by reference, see section Formal Parameter Modes, a view conversion of the actual parameter to the nominal subtype of the formal parameter is evaluated, and the formal parameter denotes that conversion.
    4. For an in or in out parameter that is passed by copy, see section Formal Parameter Modes, the formal parameter object is created, and the value of the actual parameter is converted to the nominal subtype of the formal parameter and assigned to the formal.
    5. For an out parameter that is passed by copy, the formal parameter object is created, and:
      1. For an access type, the formal parameter is initialized from the value of the actual, without a constraint check;
      2. For a composite type with discriminants or that has implicit initial values for any subcomponents, see section Object Declarations, the behavior is as for an in out parameter passed by copy.
      3. For any other type, the formal parameter is uninitialized. If composite, a view conversion of the actual parameter to the nominal subtype of the formal is evaluated (which might raise Constraint_Error), and the actual subtype of the formal is that of the view conversion. If elementary, the actual subtype of the formal is given by its nominal subtype.
  1. A formal parameter of mode in out or out with discriminants is constrained if either its nominal subtype or the actual parameter is constrained.
  2. After normal completion and leaving of a subprogram, for each in out or out parameter that is passed by copy, the value of the formal parameter is converted to the subtype of the variable given as the actual parameter and assigned to it. These conversions and assignments occur in an arbitrary order.

Return Statements

  1. A return_statement is used to complete the execution of the innermost enclosing subprogram_body, entry_body, or accept_statement.

    Syntax 

  2. return_statement ::= return [expression];

    Name Resolution Rules

  3. The expression, if any, of a return_statement is called the return expression. The result subtype of a function is the subtype denoted by the subtype_mark after the reserved word return in the profile of the function. The expected type for a return expression is the result type of the corresponding function.

    Legality Rules

  4. A return_statement shall be within a callable construct, and it applies to the innermost one. A return_statement shall not be within a body that is within the construct to which the return_statement applies.
  5. A function body shall contain at least one return_statement that applies to the function body, unless the function contains code_statements. A return_statement shall include a return expression if and only if it applies to a function body.

    Dynamic Semantics

  6. For the execution of a return_statement, the expression (if any) is first evaluated and converted to the result subtype.
  7. If the result type is class-wide, then the tag of the result is the tag of the value of the expression.
  8. If the result type is a specific tagged type:
    1. If it is limited, then a check is made that the tag of the value of the return expression identifies the result type. Constraint_Error is raised if this check fails.
    2. If it is nonlimited, then the tag of the result is that of the result type.
  1. A type is a return-by-reference type if it is a descendant of one of the following:
    1. a tagged limited type;
    2. a task or protected type;
    3. a nonprivate type with the reserved word limited in its declaration;
    4. a composite type with a subcomponent of a return-by-reference type;
    5. a private type whose full type is a return-by-reference type.
  1. If the result type is a return-by-reference type, then a check is made that the return expression is one of the following:
    1. a name that denotes an object view whose accessibility level is not deeper than that of the master that elaborated the function body; or
    2. a parenthesized expression or qualified_expression whose operand is one of these kinds of expressions.
  1. The exception Program_Error is raised if this check fails.
  2. For a function with a return-by-reference result type the result is returned by reference; that is, the function call denotes a constant view of the object associated with the value of the return expression. For any other function, the result is returned by copy; that is, the converted value is assigned into an anonymous constant created at the point of the return_statement, and the function call denotes that object.
  3. Finally, a transfer of control is performed which completes the execution of the callable construct to which the return_statement applies, and returns to the caller.

    Examples

  4. Examples of return statements: 
  5. return;
-- in a procedure body, entry_body, or accept_statement

return Key_Value(Last_Index);
-- in a function body

Overloading of Operators

  1. An operator is a function whose designator is an operator_symbol. Operators, like other functions, may be overloaded.

    Name Resolution Rules

  2. Each use of a unary or binary operator is equivalent to a function_call with function_prefix being the corresponding operator_symbol, and with (respectively) one or two positional actual parameters being the operand(s) of the operator (in order).

    Legality Rules

  3. The subprogram_specification of a unary or binary operator shall have one or two parameters, respectively. A generic function instantiation whose designator is an operator_symbol is only allowed if the specification of the generic function has the corresponding number of parameters.
  4. Default_expressions are not allowed for the parameters of an operator (whether the operator is declared with an explicit subprogram_specification or by a generic_instantiation).
  5. An explicit declaration of "/=" shall not have a result type of the predefined type Boolean.

    Static Semantics

  6. A declaration of "=" whose result type is Boolean implicitly declares a declaration of "/=" that gives the complementary result. NOTES
  7. (8) The operators "+" and "-" are both unary and binary operators, and hence may be overloaded with both one- and two-parameter functions.

    Examples

  8. Examples of user-defined operators: 
  9. function "+" (Left, Right : Matrix) return Matrix;
function "+" (Left, Right : Vector) return Vector;

--  assuming that A, B, and C are of the type Vector
--  the following two statements are equivalent:

A := B + C;
A := "+"(B, C);

Packages

  1. Packages are program units that allow the specification of groups of logically related entities. Typically, a package contains the declaration of a type (often a private type or private extension) along with the declarations of primitive subprograms of the type, which can be called from outside the package, while their inner workings remain hidden from outside users.

Package Specifications and Declarations

  1. A package is generally provided in two parts: a package_specification and a package_body. Every package has a package_specification, but not all packages have a package_body.

    Syntax 

  2. package_declaration ::= package_specification;

  3. package_specification ::=
   package defining_program_unit_name is
      {basic_declarative_item}
   [private
      {basic_declarative_item}]
   end [[parent_unit_name.]identifier]
    1. If an identifier or parent_unit_name.identifier appears at the end of a package_specification, then this sequence of lexical elements shall repeat the defining_program_unit_name.

Legality Rules

  1. A package_declaration or generic_package_declaration requires a completion (a body) if it contains any declarative_item that requires a completion, but whose completion is not in its package_specification.

    Static Semantics

  2. The first list of declarative_items of a package_specification of a package other than a generic formal package is called the visible part of the package. The optional list of declarative_items after the reserved word private (of any package_specification) is called the private part of the package. If the reserved word private does not appear, the package has an implicit empty private part.
  3. An entity declared in the private part of a package is visible only within the declarative region of the package itself (including any child units -- see section Compilation Units - Library Units. In contrast, expanded names denoting entities declared in the visible part can be used even outside the package; furthermore, direct visibility of such entities can be achieved by means of use_clauses, see section Selected Components, and section Use Clauses.

    Dynamic Semantics

  4. The elaboration of a package_declaration consists of the elaboration of its basic_declarative_items in the given order. NOTES
  5. (1) The visible part of a package contains all the information that another program unit is able to know about the package.
  6. (2) If a declaration occurs immediately within the specification of a package, and the declaration has a corresponding completion that is a body, then that body has to occur immediately within the body of the package.

    Examples

  7. Example of a package declaration: 
  8. package Rational_Numbers is

  9. type Rational is
   record
      Numerator   : Integer;
      Denominator : Positive;
   end record;

  10.    function "="(X,Y : Rational) return Boolean;

  11.    function "/"  (X,Y : Integer)  return Rational;
   --  to construct a rational number

  12.    function "+"  (X,Y : Rational) return Rational;
   function "-"  (X,Y : Rational) return Rational;
   function "*"  (X,Y : Rational) return Rational;
   function "/"  (X,Y : Rational) return Rational;
end Rational_Numbers;
  13. There are also many examples of package declarations in the predefined language environment, see section Predefined Language Environment (normative).

Package Bodies

  1. In contrast to the entities declared in the visible part of a package, the entities declared in the package_body are visible only within the package_body itself. As a consequence, a package with a package_body can be used for the construction of a group of related subprograms in which the logical operations available to clients are clearly isolated from the internal entities.

    Syntax 

  2. package_body ::=
   package body defining_program_unit_name is
      declarative_part
   [begin
      handled_sequence_of_statements]
   end [[parent_unit_name.]identifier];
    1. If an identifier or parent_unit_name.identifier appears at the end of a package_body, then this sequence of lexical elements shall repeat the defining_program_unit_name.

Legality Rules

  1. A package_body shall be the completion of a previous package_declaration or generic_package_declaration. A library package_declaration or library generic_package_declaration shall not have a body unless it requires a body; pragma Elaborate_Body can be used to require a library_unit_declaration to have a body, see section Elaboration Control, if it would not otherwise require one.

    Static Semantics

  2. In any package_body without statements there is an implicit null_statement. For any package_declaration without an explicit completion, there is an implicit package_body containing a single null_statement. For a noninstance, nonlibrary package, this body occurs at the end of the declarative_part of the innermost enclosing program unit or block_statement; if there are several such packages, the order of the implicit package_bodies is unspecified. (For an instance, the implicit package_body occurs at the place of the instantiation (see section Generic Instantiation). For a library package, the place is partially determined by the elaboration dependences, see section Program Structure and Compilation Issues.

    Dynamic Semantics

  3. For the elaboration of a nongeneric package_body, its declarative_part is first elaborated, and its handled_sequence_of_statements is then executed. NOTES
  4. (3) A variable declared in the body of a package is only visible within this body and, consequently, its value can only be changed within the package_body. In the absence of local tasks, the value of such a variable remains unchanged between calls issued from outside the package to subprograms declared in the visible part. The properties of such a variable are similar to those of a "static" variable of C.
  5. (4) The elaboration of the body of a subprogram explicitly declared in the visible part of a package is caused by the elaboration of the body of the package. Hence a call of such a subprogram by an outside program unit raises the exception Program_Error if the call takes place before the elaboration of the package_body, see section Declarative Parts.

    Examples

  6. Example of a package body, see section Package Specifications and Declarations 
  7. package body Rational_Numbers is

  8.    procedure Same_Denominator (X,Y : in out Rational) is
   begin
      --  reduces X and Y to the same denominator:
      ...
   end Same_Denominator;

  9.    function "="(X,Y : Rational) return Boolean is
      U : Rational := X;
      V : Rational := Y;
   begin
      Same_Denominator (U,V);
      return U.Numerator = V.Numerator;
   end "=";

  10.    function "/" (X,Y : Integer) return Rational is
   begin
      if Y > 0 then
         return (Numerator => X,  Denominator => Y);
      else
         return (Numerator => -X, Denominator => -Y);
      end if;
   end "/";

  11.    function "+" (X,Y : Rational) return Rational is ...  end "+";
   function "-" (X,Y : Rational) return Rational is ...  end "-";
   function "*" (X,Y : Rational) return Rational is ...  end "*";
   function "/" (X,Y : Rational) return Rational is ...  end "/";

  12. end Rational_Numbers;

Private Types and Private Extensions

  1. The declaration (in the visible part of a package) of a type as a private type or private extension serves to separate the characteristics that can be used directly by outside program units (that is, the logical properties) from other characteristics whose direct use is confined to the package (the details of the definition of the type itself). See section Type Extensions, for an overview of type extensions.

    Syntax 

  2. private_type_declaration ::=
   type defining_identifier [discriminant_part] is
     [[abstract] tagged] [limited] private;

  3. private_extension_declaration ::=
   type defining_identifier [discriminant_part] is
     [abstract] new ancestor_subtype_indication with private;

    Legality Rules

  4. A private_type_declaration or private_extension_declaration declares a partial view of the type; such a declaration is allowed only as a declarative_item of the visible part of a package, and it requires a completion, which shall be a full_type_declaration that occurs as a declarative_item of the private part of the package. The view of the type declared by the full_type_declaration is called the full view. A generic formal private type or a generic formal private extension is also a partial view.
  5. A type shall be completely defined before it is frozen, see section Completions of Declarations, and section Freezing Rules. Thus, neither the declaration of a variable of a partial view of a type, nor the creation by an allocator of an object of the partial view are allowed before the full declaration of the type. Similarly, before the full declaration, the name of the partial view cannot be used in a generic_instantiation or in a representation item.
  6. A private type is limited if its declaration includes the reserved word limited; a private extension is limited if its ancestor type is limited. If the partial view is nonlimited, then the full view shall be nonlimited. If a tagged partial view is limited, then the full view shall be limited. On the other hand, if an untagged partial view is limited, the full view may be limited or nonlimited.
  7. If the partial view is tagged, then the full view shall be tagged. On the other hand, if the partial view is untagged, then the full view may be tagged or untagged. In the case where the partial view is untagged and the full view is tagged, no derivatives of the partial view are allowed within the immediate scope of the partial view; derivatives of the full view are allowed.
  8. The ancestor subtype of a private_extension_declaration is the subtype defined by the ancestor_subtype_indication; the ancestor type shall be a specific tagged type. The full view of a private extension shall be derived (directly or indirectly) from the ancestor type. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, the requirement that the ancestor be specific applies also in the private part of an instance of a generic unit.
  9. If the declaration of a partial view includes a known_discriminant_part, then the full_type_declaration shall have a fully conforming (explicit) known_discriminant_part, see section Conformance Rules. The ancestor subtype may be unconstrained; the parent subtype of the full view is required to be constrained, see section Discriminants.
  10. If a private extension inherits known discriminants from the ancestor subtype, then the full view shall also inherit its discriminants from the ancestor subtype, and the parent subtype of the full view shall be constrained if and only if the ancestor subtype is constrained.
  11. If a partial view has unknown discriminants, then the full_type_declaration may define a definite or an indefinite subtype, with or without discriminants.
  12. If a partial view has neither known nor unknown discriminants, then the full_type_declaration shall define a definite subtype.
  13. If the ancestor subtype of a private extension has constrained discriminants, then the parent subtype of the full view shall impose a statically matching constraint on those discriminants.

    Static Semantics

  14. A private_type_declaration declares a private type and its first subtype. Similarly, a private_extension_declaration declares a private extension and its first subtype.
  15. A declaration of a partial view and the corresponding full_type_declaration define two views of a single type. The declaration of a partial view together with the visible part define the operations that are available to outside program units; the declaration of the full view together with the private part define other operations whose direct use is possible only within the declarative region of the package itself. Moreover, within the scope of the declaration of the full view, the characteristics of the type are determined by the full view; in particular, within its scope, the full view determines the classes that include the type, which components, entries, and protected subprograms are visible, what attributes and other predefined operations are allowed, and whether the first subtype is static (see section Private Operations).
  16. A private extension inherits components (including discriminants unless there is a new discriminant_part specified) and user-defined primitive subprograms from its ancestor type, in the same way that a record extension inherits components and user-defined primitive subprograms from its parent type, see section Derived Types and Classes.

    Dynamic Semantics

  17. The elaboration of a private_type_declaration creates a partial view of a type. The elaboration of a private_extension_declaration elaborates the ancestor_subtype_indication, and creates a partial view of a type. NOTES
  18. (5) The partial view of a type as declared by a private_type_declaration is defined to be a composite view (in 3.2). The full view of the type might or might not be composite. A private extension is also composite, as is its full view.
  19. (6) Declaring a private type with an unknown_discriminant_part is a way of preventing clients from creating uninitialized objects of the type; they are then forced to initialize each object by calling some operation declared in the visible part of the package. If such a type is also limited, then no objects of the type can be declared outside the scope of the full_type_declaration, restricting all object creation to the package defining the type. This allows complete control over all storage allocation for the type. Objects of such a type can still be passed as parameters, however.
  20. (7) The ancestor type specified in a private_extension_declaration and the parent type specified in the corresponding declaration of a record extension given in the private part need not be the same -- the parent type of the full view can be any descendant of the ancestor type. In this case, for a primitive subprogram that is inherited from the ancestor type and not overridden, the formal parameter names and default expressions (if any) come from the corresponding primitive subprogram of the specified ancestor type, while the body comes from the corresponding primitive subprogram of the parent type of the full view (see section Dispatching Operations of Tagged Types).

    Examples

  21. Examples of private type declarations: 
  22. type Key is private;
type File_Name is limited private;
  23. Example of a private extension declaration: 
  24. type List is new Ada.Finalization.Controlled with private;

Private Operations

  1. For a type declared in the visible part of a package or generic package, certain operations on the type do not become visible until later in the package -- either in the private part or the body. Such private operations are available only inside the declarative region of the package or generic package.

    Static Semantics

  2. The predefined operators that exist for a given type are determined by the classes to which the type belongs. For example, an integer type has a predefined "+" operator. In most cases, the predefined operators of a type are declared immediately after the definition of the type; the exceptions are explained below. Inherited subprograms are also implicitly declared immediately after the definition of the type, except as stated below.
  3. For a composite type, the characteristics, see section Private Types and Private Extensions of the type are determined in part by the characteristics of its component types. At the place where the composite type is declared, the only characteristics of component types used are those characteristics visible at that place. If later within the immediate scope of the composite type additional characteristics become visible for a component type, then any corresponding characteristics become visible for the composite type. Any additional predefined operators are implicitly declared at that place.
  4. The corresponding rule applies to a type defined by a derived_type_definition, if there is a place within its immediate scope where additional characteristics of its parent type become visible.
  5. For example, an array type whose component type is limited private becomes nonlimited if the full view of the component type is nonlimited and visible at some later place within the immediate scope of the array type. In such a case, the predefined "=" operator is implicitly declared at that place, and assignment is allowed after that place.
  6. Inherited primitive subprograms follow a different rule. For a derived_type_definition, each inherited primitive subprogram is implicitly declared at the earliest place, if any, within the immediate scope of the type_declaration, but after the type_declaration, where the corresponding declaration from the parent is visible. If there is no such place, then the inherited subprogram is not declared at all. An inherited subprogram that is not declared at all cannot be named in a call and cannot be overridden, but for a tagged type, it is possible to dispatch to it.
  7. For a private_extension_declaration, each inherited subprogram is declared immediately after the private_extension_declaration if the corresponding declaration from the ancestor is visible at that place. Otherwise, the inherited subprogram is not declared for the private extension, though it might be for the full type.
  8. The Class attribute is defined for tagged subtypes in 3.9. In addition, for every subtype S of an untagged private type whose full view is tagged, the following attribute is defined:
  9. S'Class 
    Denotes the class-wide subtype corresponding to the full view
of S. This attribute is allowed only from the beginning of
the private part in which the full view is declared, until
the declaration of the full view. After the full view, the
Class attribute of the full view can be used.
    NOTES
  10. (8) Because a partial view and a full view are two different views of one and the same type, outside of the defining package the characteristics of the type are those defined by the visible part. Within these outside program units the type is just a private type or private extension, and any language rule that applies only to another class of types does not apply. The fact that the full declaration might implement a private type with a type of a particular class (for example, as an array type) is relevant only within the declarative region of the package itself including any child units.
  11. The consequences of this actual implementation are, however, valid everywhere. For example: any default initialization of components takes place; the attribute Size provides the size of the full view; finalization is still done for controlled components of the full view; task dependence rules still apply to components that are task objects.
  12. (9) Partial views provide assignment (unless the view is limited), membership tests, selected components for the selection of discriminants and inherited components, qualification, and explicit conversion.
  13. (10) For a subtype S of a partial view, S'Size is defined, see section Representation Attributes. For an object A of a partial view, the attributes A'Size and A'Address are defined, see section Representation Attributes. The Position, First_Bit, and Last_Bit attributes are also defined for discriminants and inherited components.

    Examples

  14. Example of a type with private operations: 
  15. package Key_Manager is
   type Key is private;
   Null_Key : constant Key;
   -- a deferred constant declaration, see section Deferred Constants
   procedure Get_Key(K : out Key);
   function "<" (X, Y : Key) return Boolean;
private
   type Key is new Natural;
   Null_Key : constant Key := Key'First;
end Key_Manager;

  16. package body Key_Manager is
   Last_Key : Key := Null_Key;
   procedure Get_Key(K : out Key) is
   begin
      Last_Key := Last_Key + 1;
      K := Last_Key;
   end Get_Key;

  17.    function "<" (X, Y : Key) return Boolean is
   begin
      return Natural(X) < Natural(Y);
   end "<";
end Key_Manager;
    NOTES
  18. (11) Notes on the example: Outside of the package Key_Manager, the operations available for objects of type Key include assignment, the comparison for equality or inequality, the procedure Get_Key and the operator "<"; they do not include other relational operators such as ">=", or arithmetic operators.
  19. The explicitly declared operator "<" hides the predefined operator "<" implicitly declared by the full_type_declaration. Within the body of the function, an explicit conversion of X and Y to the subtype Natural is necessary to invoke the "<" operator of the parent type. Alternatively, the result of the function could be written as not (X >= Y), since the operator ">=" is not redefined.
  20. The value of the variable Last_Key, declared in the package body, remains unchanged between calls of the procedure Get_Key (See also the NOTES of section Package Bodies)

Deferred Constants

  1. Deferred constant declarations may be used to declare constants in the visible part of a package, but with the value of the constant given in the private part. They may also be used to declare constants imported from other languages, see section Interface to Other Languages (normative).

    Legality Rules

  2. A deferred constant declaration is an object_declaration with the reserved word constant but no initialization expression. The constant declared by a deferred constant declaration is called a deferred constant. A deferred constant declaration requires a completion, which shall be a full constant declaration (called the full declaration of the deferred constant), or a pragma Import (see section Interface to Other Languages (normative)).
  3. A deferred constant declaration that is completed by a full constant declaration shall occur immediately within the visible part of a package_ specification. For this case, the following additional rules apply to the corresponding full declaration:
    1. The full declaration shall occur immediately within the private part of the same package;
    2. The deferred and full constants shall have the same type;
    3. If the subtype defined by the subtype_indication in the deferred declaration is constrained, then the subtype defined by the subtype_indication in the full declaration shall match it statically. On the other hand, if the subtype of the deferred constant is unconstrained, then the full declaration is still allowed to impose a constraint. The constant itself will be constrained, like all constants;
    4. If the deferred constant declaration includes the reserved word aliased, then the full declaration shall also.
  1. A deferred constant declaration that is completed by a pragma Import need not appear in the visible part of a package_specification, and has no full constant declaration.
  2. The completion of a deferred constant declaration shall occur before the constant is frozen, see section Deferred Constants.

    Dynamic Semantics

  3. The elaboration of a deferred constant declaration elaborates the subtype_indication or (only allowed in the case of an imported constant) the array_type_definition. NOTES
  4. (12) The full constant declaration for a deferred constant that is of a given private type or private extension is not allowed before the corresponding full_type_declaration. This is a consequence of the freezing rules for types, see section Freezing Rules.

    Examples

  5. Examples of deferred constant declarations: 
  6. Null_Key : constant Key;      --  see section Private Operations

  7. CPU_Identifier : constant String(1..8);
pragma Import(Assembler, CPU_Identifier, Link_Name => "CPU_ID");
--  see section Interfacing Pragmas

Limited Types

  1. A limited type is (a view of) a type for which the assignment operation is not allowed. A nonlimited type is a (view of a) type for which the assignment operation is allowed.

    Legality Rules

  2. If a tagged record type has any limited components, then the reserved word limited shall appear in its record_type_definition.

    Static Semantics

  3. A type is limited if it is a descendant of one of the following:
    1. a type with the reserved word limited in its definition;
    2. a task or protected type;
    3. a composite type with a limited component.
  1. Otherwise, the type is nonlimited.
  2. There are no predefined equality operators for a limited type. NOTES
  3. (13) The following are consequences of the rules for limited types:
    1. An initialization expression is not allowed in an object_declaration if the type of the object is limited.
    2. A default expression is not allowed in a component_declaration if the type of the record component is limited.
    3. An initialized allocator is not allowed if the designated type is limited.
    4. A generic formal parameter of mode in must not be of a limited type.
  1. (14) Aggregates are not available for a limited composite type. Concatenation is not available for a limited array type.
  2. (15) The rules do not exclude a default_expression for a formal parameter of a limited type; they do not exclude a deferred constant of a limited type if the full declaration of the constant is of a nonlimited type.
  3. (16) As illustrated in section Private Operations, an untagged limited type can become nonlimited under certain circumstances.

    Examples

  4. Example of a package with a limited type: 
  5. package IO_Package is
   type File_Name is limited private;

  6.    procedure Open (F : in out File_Name);
   procedure Close(F : in out File_Name);
   procedure Read (F : in File_Name; Item : out Integer);
   procedure Write(F : in File_Name; Item : in  Integer);
private
   type File_Name is
      limited record
         Internal_Name : Integer := 0;
      end record;
end IO_Package;

  7. package body IO_Package is
   Limit : constant := 200;
   type File_Descriptor is record  ...  end record;
   Directory : array (1 .. Limit) of File_Descriptor;
   ...
   procedure Open (F : in out File_Name) is  ...  end;
   procedure Close(F : in out File_Name) is  ...  end;
   procedure Read (F : in File_Name; Item : out Integer) is ... end;
   procedure Write(F : in File_Name; Item : in  Integer) is ... end;
begin
   ...
end IO_Package;
    NOTES
  8. (17) Notes on the example: In the example above, an outside subprogram making use of IO_Package may obtain a file name by calling Open and later use it in calls to Read and Write. Thus, outside the package, a file name obtained from Open acts as a kind of password; its internal properties (such as containing a numeric value) are not known and no other operations (such as addition or comparison of internal names) can be performed on a file name. Most importantly, clients of the package cannot make copies of objects of type File_Name.
  9. This example is characteristic of any case where complete control over the operations of a type is desired. Such packages serve a dual purpose. They prevent a user from making use of the internal structure of the type. They also implement the notion of an encapsulated data type where the only operations on the type are those given in the package specification.
  10. The fact that the full view of File_Name is explicitly declared limited means that parameter passing and function return will always be by reference, see section Formal Parameter Modes, and section Return Statements.

User-Defined Assignment and Finalization

  1. Three kinds of actions are fundamental to the manipulation of objects: initialization, finalization, and assignment. Every object is initialized, either explicitly or by default, after being created (for example, by an object_declaration or allocator). Every object is finalized before being destroyed (for example, by leaving a subprogram_body containing an object_declaration, or by a call to an instance of Unchecked_Deallocation). An assignment operation is used as part of assignment_statements, explicit initialization, parameter passing, and other operations.
  2. Default definitions for these three fundamental operations are provided by the language, but a controlled type gives the user additional control over parts of these operations. In particular, the user can define, for a controlled type, an Initialize procedure which is invoked immediately after the normal default initialization of a controlled object, a Finalize procedure which is invoked immediately before finalization of any of the components of a controlled object, and an Adjust procedure which is invoked as the last step of an assignment to a (nonlimited) controlled object.

    Static Semantics

  3. The following language-defined library package exists: 
  4. package Ada.Finalization is
    pragma Preelaborate(Finalization);

  5.     type Controlled is abstract tagged private;

  6.     procedure Initialize(Object : in out Controlled);
    procedure Adjust                 (Object : in out Controlled);
    procedure Finalize               (Object : in out Controlled);

  7.     type Limited_Controlled is abstract tagged limited private;

  8.     procedure Initialize(Object : in out Limited_Controlled);
    procedure Finalize  (Object : in out Limited_Controlled);
private
    ... -- not specified by the language
end Ada.Finalization;
  9. A controlled type is a descendant of Controlled or Limited_Controlled. The (default) implementations of Initialize, Adjust, and Finalize have no effect. The predefined "=" operator of type Controlled always returns True, since this operator is incorporated into the implementation of the predefined equality operator of types derived from Controlled, as explained in section Relational Operators and Membership Tests. The type Limited_Controlled is like Controlled, except that it is limited and it lacks the primitive subprogram Adjust.

    Dynamic Semantics

  10. During the elaboration of an object_declaration, for every controlled subcomponent of the object that is not assigned an initial value (as defined in 3.3.1), Initialize is called on that subcomponent. Similarly, if the object as a whole is controlled and is not assigned an initial value, Initialize is called on the object. The same applies to the evaluation of an allocator, as explained in section Allocators.
  11. For an extension_aggregate whose ancestor_part is a subtype_mark, Initialize is called on all controlled subcomponents of the ancestor part; if the type of the ancestor part is itself controlled, the Initialize procedure of the ancestor type is called, unless that Initialize procedure is abstract.
  12. Initialize and other initialization operations are done in an arbitrary order, except as follows. Initialize is applied to an object after initialization of its subcomponents, if any (including both implicit initialization and Initialize calls). If an object has a component with an access discriminant constrained by a per-object expression, Initialize is applied to this component after any components that do not have such discriminants. For an object with several components with such a discriminant, Initialize is applied to them in order of their component_declarations. For an allocator, any task activations follow all calls on Initialize.
  13. When a target object with any controlled parts is assigned a value, either when created or in a subsequent assignment_statement, the assignment operation proceeds as follows:
    1. The value of the target becomes the assigned value.
    2. The value of the target is adjusted.
  1. To adjust the value of a (nonlimited) composite object, the values of the components of the object are first adjusted in an arbitrary order, and then, if the object is controlled, Adjust is called. Adjusting the value of an elementary object has no effect, nor does adjusting the value of a composite object with no controlled parts.
  2. For an assignment_statement, after the name and expression have been evaluated, and any conversion (including constraint checking) has been done, an anonymous object is created, and the value is assigned into it; that is, the assignment operation is applied. (Assignment includes value adjustment.) The target of the assignment_statement is then finalized. The value of the anonymous object is then assigned into the target of the assignment_statement. Finally, the anonymous object is finalized. As explained below, the implementation may eliminate the intermediate anonymous object, so this description subsumes the one given in section Assignment Statements.

    Implementation Permissions

  3. An implementation is allowed to relax the above rules (for nonlimited controlled types) in the following ways:
    1. For an assignment_statement that assigns to an object the value of that same object, the implementation need not do anything.
    2. For an assignment_statement for a noncontrolled type, the implementation may finalize and assign each component of the variable separately (rather than finalizing the entire variable and assigning the entire new value) unless a discriminant of the variable is changed by the assignment.
    3. For an aggregate or function call whose value is assigned into a target object, the implementation need not create a separate anonymous object if it can safely create the value of the aggregate or function call directly in the target object. Similarly, for an assignment_statement, the implementation need not create an anonymous object if the value being assigned is the result of evaluating a name denoting an object (the source object) whose storage cannot overlap with the target. If the source object might overlap with the target object, then the implementation can avoid the need for an intermediary anonymous object by exercising one of the above permissions and perform the assignment one component at a time (for an overlapping array assignment), or not at all (for an assignment where the target and the source of the assignment are the same object). Even if an anonymous object is created, the implementation may move its value to the target object as part of the assignment without re-adjusting so long as the anonymous object has no aliased subcomponents.

Completion and Finalization

  1. This subclause defines completion and leaving of the execution of constructs and entities. A master is the execution of a construct that includes finalization of local objects after it is complete (and after waiting for any local tasks -- see section Task Dependence - Termination of Tasks.), but before leaving. Other constructs and entities are left immediately upon completion.

    Dynamic Semantics

  2. The execution of a construct or entity is complete when the end of that execution has been reached, or when a transfer of control, see section Simple and Compound Statements - Sequences of Statements, causes it to be abandoned. Completion due to reaching the end of execution, or due to the transfer of control of an exit_, return_, goto_, or requeue_statement or of the selection of a terminate_alternative is normal completion. Completion is abnormal otherwise -- when control is transferred out of a construct due to abort or the raising of an exception.
  3. After execution of a construct or entity is complete, it is left, meaning that execution continues with the next action, as defined for the execution that is taking place. Leaving an execution happens immediately after its completion, except in the case of a master: the execution of a task_body, a block_statement, a subprogram_body, an entry_body, or an accept_statement. A master is finalized after it is complete, and before it is left.
  4. For the finalization of a master, dependent tasks are first awaited, as explained in section Task Dependence - Termination of Tasks. Then each object whose accessibility level is the same as that of the master is finalized if the object was successfully initialized and still exists. These actions are performed whether the master is left by reaching the last statement or via a transfer of control. When a transfer of control causes completion of an execution, each included master is finalized in order, from innermost outward.
  5. For the finalization of an object:
    1. If the object is of an elementary type, finalization has no effect;
    2. If the object is of a controlled type, the Finalize procedure is called;
    3. If the object is of a protected type, the actions defined in section Protected Units and Protected Objects are performed;
    4. If the object is of a composite type, then after performing the above actions, if any, every component of the object is finalized in an arbitrary order, except as follows: if the object has a component with an access discriminant constrained by a per-object expression, this component is finalized before any components that do not have such discriminants; for an object with several components with such a discriminant, they are finalized in the reverse of the order of their component_declarations.
  1. Immediately before an instance of Unchecked_Deallocation reclaims the storage of an object, the object is finalized. If an instance of Unchecked_Deallocation is never applied to an object created by an allocator, the object will still exist when the corresponding master completes, and it will be finalized then.
  2. The order in which the finalization of a master performs finalization of objects is as follows: Objects created by declarations in the master are finalized in the reverse order of their creation. For objects that were created by allocators for an access type whose ultimate ancestor is declared in the master, this rule is applied as though each such object that still exists had been created in an arbitrary order at the first freezing point, see section Freezing Rules, of the ultimate ancestor type.
  3. The target of an assignment statement is finalized before copying in the new value, as explained in section User-Defined Assignment and Finalization.
  4. The anonymous objects created by function calls and by aggregates are finalized no later than the end of the innermost enclosing declarative_item or statement; if that is a compound_statement, they are finalized before starting the execution of any statement within the compound_statement.

    Bounded (Run-Time) Errors

  5. It is a bounded error for a call on Finalize or Adjust to propagate an exception. The possible consequences depend on what action invoked the Finalize or Adjust operation:
    1. For a Finalize invoked as part of an assignment_statement, Program_Error is raised at that point.
    2. For an Adjust invoked as part of an assignment operation, any other adjustments due to be performed are performed, and then Program_Error is raised.
    3. For a Finalize invoked as part of a call on an instance of Unchecked_Deallocation, any other finalizations due to be performed are performed, and then Program_Error is raised.
    4. For a Finalize invoked by the transfer of control of an exit_, return_, goto_, or requeue_statement, Program_Error is raised no earlier than after the finalization of the master being finalized when the exception occurred, and no later than the point where normal execution would have continued. Any other finalizations due to be performed up to that point are performed before raising Program_Error.
    5. For a Finalize invoked by a transfer of control that is due to raising an exception, any other finalizations due to be performed for the same master are performed; Program_Error is raised immediately after leaving the master.
    6. For a Finalize invoked by a transfer of control due to an abort or selection of a terminate alternative, the exception is ignored; any other finalizations due to be performed are performed.
    NOTES
  1. (18) The rules in section Program Structure and Compilation Issues, imply that immediately prior to partition termination, Finalize operations are applied to library-level controlled objects (including those created by allocators of library-level access types, except those already finalized). This occurs after waiting for library-level tasks to terminate.
  2. (19) A constant is only constant between its initialization and finalization. Both initialization and finalization are allowed to change the value of a constant.
  3. (20) Abort is deferred during certain operations related to controlled types, as explained in section Abort of a Task - Abort of a Sequence of Statements. Those rules prevent an abort from causing a controlled object to be left in an ill-defined state.
  4. (21) The Finalize procedure is called upon finalization of a controlled object, even if Finalize was called earlier, either explicitly or as part of an assignment; hence, if a controlled type is visibly controlled (implying that its Finalize primitive is directly callable), or is nonlimited (implying that assignment is allowed), its Finalize procedure should be designed to have no ill effect if it is applied a second time to the same object.

Visibility Rules

  1. The rules defining the scope of declarations and the rules defining which identifiers, character_literals, and operator_symbols are visible at (or from) various places in the text of the program are described in this section. The formulation of these rules uses the notion of a declarative region.
  2. As explained in section Declarations and Types, a declaration declares a view of an entity and associates a defining name with that view. The view comprises an identification of the viewed entity, and possibly additional properties. A usage name denotes a declaration. It also denotes the view declared by that declaration, and denotes the entity of that view. Thus, two different usage names might denote two different views of the same entity; in this case they denote the same entity.

Declarative Region

Static Semantics

  1. For each of the following constructs, there is a portion of the program text called its declarative region, within which nested declarations can occur:
    1. any declaration, other than that of an enumeration type, that is not a completion of a previous declaration;
    2. a block_statement;
    3. a loop_statement;
    4. an accept_statement;
    5. an exception_handler.
  1. The declarative region includes the text of the construct together with additional text determined (recursively), as follows:
    1. If a declaration is included, so is its completion, if any.
    2. If the declaration of a library unit (including Standard -- see section Compilation Units - Library Units, is included, so are the declarations of any child units (and their completions, by the previous rule). The child declarations occur after the declaration.
    3. If a body_stub is included, so is the corresponding subunit.
    4. If a type_declaration is included, then so is a corresponding record_representation_clause, if any.
  1. The declarative region of a declaration is also called the declarative region of any view or entity declared by the declaration.
  2. A declaration occurs immediately within a declarative region if this region is the innermost declarative region that encloses the declaration (the immediately enclosing declarative region), not counting the declarative region (if any) associated with the declaration itself.
  3. A declaration is local to a declarative region if the declaration occurs immediately within the declarative region. An entity is local to a declarative region if the entity is declared by a declaration that is local to the declarative region.
  4. A declaration is global to a declarative region if the declaration occurs immediately within another declarative region that encloses the declarative region. An entity is global to a declarative region if the entity is declared by a declaration that is global to the declarative region. NOTES
  5. (1) The children of a parent library unit are inside the parent's declarative region, even though they do not occur inside the parent's declaration or body. This implies that one can use (for example) "P.Q" to refer to a child of P whose defining name is Q, and that after "use P;" Q can refer (directly) to that child.
  6. (2) As explained above and in section Compilation Units - Library Units, all library units are descendants of Standard, and so are contained in the declarative region of Standard. They are not inside the declaration or body of Standard, but they are inside its declarative region.
  7. (3) For a declarative region that comes in multiple parts, the text of the declarative region does not contain any text that might appear between the parts. Thus, when a portion of a declarative region is said to extend from one place to another in the declarative region, the portion does not contain any text that might appear between the parts of the declarative region.

Scope of Declarations

  1. For each declaration, the language rules define a certain portion of the program text called the scope of the declaration. The scope of a declaration is also called the scope of any view or entity declared by the declaration. Within the scope of an entity, and only there, there are places where it is legal to refer to the declared entity. These places are defined by the rules of visibility and overloading.

    Static Semantics

  2. The immediate scope of a declaration is a portion of the declarative region immediately enclosing the declaration. The immediate scope starts at the beginning of the declaration, except in the case of an overloadable declaration, in which case the immediate scope starts just after the place where the profile of the callable entity is determined (which is at the end of the _specification for the callable entity, or at the end of the generic_instantiation if an instance). The immediate scope extends to the end of the declarative region, with the following exceptions:
    1. The immediate scope of a library_item includes only its semantic dependents.
    2. The immediate scope of a declaration in the private part of a library unit does not include the visible part of any public descendant of that library unit.
  1. The visible part of (a view of) an entity is a portion of the text of its declaration containing declarations that are visible from outside. The private part of (a view of) an entity that has a visible part contains all declarations within the declaration of (the view of) the entity, except those in the visible part; these are not visible from outside. Visible and private parts are defined only for these kinds of entities: callable entities, other program units, and composite types.
    1. The visible part of a view of a callable entity is its profile.
    2. The visible part of a composite type other than a task or protected type consists of the declarations of all components declared (explicitly or implicitly) within the type_declaration.
    3. The visible part of a generic unit includes the generic_formal_part. For a generic package, it also includes the first list of basic_declarative_items of the package_specification. For a generic subprogram, it also includes the profile.
    4. The visible part of a package, task unit, or protected unit consists of declarations in the program unit's declaration other than those following the reserved word private, if any; see section Package Specifications and Declarations, and section Formal Packages, for packages, see section Task Units and Task Objects, for task units, and section Protected Units and Protected Objects, for protected units.
  1. The scope of a declaration always contains the immediate scope of the declaration. In addition, for a given declaration that occurs immediately within the visible part of an outer declaration, or is a public child of an outer declaration, the scope of the given declaration extends to the end of the scope of the outer declaration, except that the scope of a library_item includes only its semantic dependents.
  2. The immediate scope of a declaration is also the immediate scope of the entity or view declared by the declaration. Similarly, the scope of a declaration is also the scope of the entity or view declared by the declaration. NOTES
  3. (4) There are notations for denoting visible declarations that are not directly visible. For example, parameter_specifications are in the visible part of a subprogram_declaration so that they can be used in named-notation calls appearing outside the called subprogram. For another example, declarations of the visible part of a package can be denoted by expanded names appearing outside the package, and can be made directly visible by a use_clause.

Visibility

  1. The visibility rules, given below, determine which declarations are visible and directly visible at each place within a program. The visibility rules apply to both explicit and implicit declarations.

    Static Semantics

  2. A declaration is defined to be directly visible at places where a name consisting of only an identifier or operator_symbol is sufficient to denote the declaration; that is, no selected_component notation or special context (such as preceding => in a named association) is necessary to denote the declaration. A declaration is defined to be visible wherever it is directly visible, as well as at other places where some name (such as a selected_component) can denote the declaration.
  3. The syntactic category direct_name is used to indicate contexts where direct visibility is required. The syntactic category selector_name is used to indicate contexts where visibility, but not direct visibility, is required.
  4. There are two kinds of direct visibility: immediate visibility and use-visibility. A declaration is immediately visible at a place if it is directly visible because the place is within its immediate scope. A declaration is use-visible if it is directly visible because of a use_clause, see section Use Clauses. Both conditions can apply.
  5. A declaration can be hidden, either from direct visibility, or from all visibility, within certain parts of its scope. Where hidden from all visibility, it is not visible at all (neither using a direct_name nor a selector_name). Where hidden from direct visibility, only direct visibility is lost; visibility using a selector_name is still possible.
  6. Two or more declarations are overloaded if they all have the same defining name and there is a place where they are all directly visible.
  7. The declarations of callable entities (including enumeration literals) are overloadable, meaning that overloading is allowed for them.
  8. Two declarations are homographs if they have the same defining name, and, if both are overloadable, their profiles are type conformant. An inner declaration hides any outer homograph from direct visibility.
  9. Two homographs are not generally allowed immediately within the same declarative region unless one overrides the other (see Legality Rules below). A declaration overrides another homograph that occurs immediately within the same declarative region in the following cases:
    1. An explicit declaration overrides an implicit declaration of a primitive subprogram, regardless of which declaration occurs first;
    2. The implicit declaration of an inherited operator overrides that of a predefined operator;
    3. An implicit declaration of an inherited subprogram overrides a previous implicit declaration of an inherited subprogram.
    4. For an implicit declaration of a primitive subprogram in a generic unit, there is a copy of this declaration in an instance. However, a whole new set of primitive subprograms is implicitly declared for each type declared within the visible part of the instance. These new declarations occur immediately after the type declaration, and override the copied ones. The copied ones can be called only from within the instance; the new ones can be called only from outside the instance, although for tagged types, the body of a new one can be executed by a call to an old one.
  1. A declaration is visible within its scope, except where hidden from all visibility, as follows:
    1. An overridden declaration is hidden from all visibility within the scope of the overriding declaration.
    2. A declaration is hidden from all visibility until the end of the declaration, except:
      1. For a record type or record extension, the declaration is hidden from all visibility only until the reserved word record;
      2. For a package_declaration, task declaration, protected declaration, generic_package_declaration, or subprogram_body, the declaration is hidden from all visibility only until the reserved word is of the declaration.
    1. If the completion of a declaration is a declaration, then within the scope of the completion, the first declaration is hidden from all visibility. Similarly, a discriminant_specification or parameter_specification is hidden within the scope of a corresponding discriminant_specification or parameter_specification of a corresponding completion, or of a corresponding accept_statement.
    2. The declaration of a library unit (including a library_unit_renaming_declaration) is hidden from all visibility except at places that are within its declarative region or within the scope of a with_clause that mentions it. For each declaration or renaming of a generic unit as a child of some parent generic package, there is a corresponding declaration nested immediately within each instance of the parent. Such a nested declaration is hidden from all visibility except at places that are within the scope of a with_clause that mentions the child.
  1. A declaration with a defining_identifier or defining_operator_symbol is immediately visible (and hence directly visible) within its immediate scope except where hidden from direct visibility, as follows:
    1. A declaration is hidden from direct visibility within the immediate scope of a homograph of the declaration, if the homograph occurs within an inner declarative region;
    2. A declaration is also hidden from direct visibility where hidden from all visibility.

Name Resolution Rules

  1. A direct_name shall resolve to denote a directly visible declaration whose defining name is the same as the direct_name. A selector_name shall resolve to denote a visible declaration whose defining name is the same as the selector_name.
  2. These rules on visibility and direct visibility do not apply in a context_clause, a parent_unit_name, or a pragma that appears at the place of a compilation_unit. For those contexts, see the rules in section Environment-Level Visibility Rules.

    Legality Rules

  3. An explicit declaration is illegal if there is a homograph occurring immediately within the same declarative region that is visible at the place of the declaration, and is not hidden from all visibility by the explicit declaration. Similarly, the context_clause for a subunit is illegal if it mentions (in a with_clause) some library unit, and there is a homograph of the library unit that is visible at the place of the corresponding stub, and the homograph and the mentioned library unit are both declared immediately within the same declarative region. These rules also apply to dispatching operations declared in the visible part of an instance of a generic unit. However, they do not apply to other overloadable declarations in an instance; such declarations may have type conformant profiles in the instance, so long as the corresponding declarations in the generic were not type conformant. NOTES
  4. (5) Visibility for compilation units follows from the definition of the environment in section The Compilation Process, except that it is necessary to apply a with_clause to obtain visibility to a library_unit_declaration or library_unit_renaming_declaration.
  5. (6) In addition to the visibility rules given above, the meaning of the occurrence of a direct_name or selector_name at a given place in the text can depend on the overloading rules, see section The Context of Overload Resolution.
  6. (7) Not all contexts where an identifier, character_literal, or operator_symbol are allowed require visibility of a corresponding declaration. Contexts where visibility is not required are identified by using one of these three syntactic categories directly in a syntax rule, rather than using direct_name or selector_name.

Use Clauses

  1. A use_package_clause achieves direct visibility of declarations that appear in the visible part of a package; a use_type_clause achieves direct visibility of the primitive operators of a type.

    Syntax 

  2. use_clause ::= use_package_clause | use_type_clause

  3. use_package_clause ::= use package_name {, package_name};

  4. use_type_clause ::= use type subtype_mark {, subtype_mark};

    Legality Rules

  5. A package_name of a use_package_clause shall denote a package.

    Static Semantics

  6. For each use_clause, there is a certain region of text called the scope of the use_clause. For a use_clause within a context_clause of a library_unit_declaration or library_unit_renaming_declaration, the scope is the entire declarative region of the declaration. For a use_clause within a context_clause of a body, the scope is the entire body and any subunits (including multiply nested subunits). The scope does not include context_clauses themselves.
  7. For a use_clause immediately within a declarative region, the scope is the portion of the declarative region starting just after the use_clause and extending to the end of the declarative region. However, the scope of a use_clause in the private part of a library unit does not include the visible part of any public descendant of that library unit.
  8. For each package denoted by a package_name of a use_package_clause whose scope encloses a place, each declaration that occurs immediately within the declarative region of the package is potentially use-visible at this place if the declaration is visible at this place. For each type T or T'Class determined by a subtype_mark of a use_type_clause whose scope encloses a place, the declaration of each primitive operator of type T is potentially use-visible at this place if its declaration is visible at this place.
  9. A declaration is use-visible if it is potentially use-visible, except in these naming-conflict cases:
    1. A potentially use-visible declaration is not use-visible if the place considered is within the immediate scope of a homograph of the declaration.
    2. Potentially use-visible declarations that have the same identifier are not use-visible unless each of them is an overloadable declaration.

Dynamic Semantics

  1. The elaboration of a use_clause has no effect.

    Examples

  2. Example of a use clause in a context clause: 
  3. with Ada.Calendar; use Ada;

  4. Example of a use type clause:

  5. use type Rational_Numbers.Rational;  --  see section Package Specifications and Declarations
Two_Thirds: Rational_Numbers.Rational := 2/3;

Renaming Declarations

  1. A renaming_declaration declares another name for an entity, such as an object, exception, package, subprogram, entry, or generic unit. Alternatively, a subprogram_renaming_declaration can be the completion of a previous subprogram_declaration.

    Syntax 

  2. renaming_declaration ::=
      object_renaming_declaration
    | exception_renaming_declaration
    | package_renaming_declaration
    | subprogram_renaming_declaration
    | generic_renaming_declaration

    Dynamic Semantics

  3. The elaboration of a renaming_declaration evaluates the name that follows the reserved word renames and thereby determines the view and entity denoted by this name (the renamed view and renamed entity). A name that denotes the renaming_declaration denotes (a new view of) the renamed entity. NOTES
  4. (8) Renaming may be used to resolve name conflicts and to act as a shorthand. Renaming with a different identifier or operator_symbol does not hide the old name; the new name and the old name need not be visible at the same places.
  5. (9) A task or protected object that is declared by an explicit object_declaration can be renamed as an object. However, a single task or protected object cannot be renamed since the corresponding type is anonymous (meaning it has no nameable subtypes). For similar reasons, an object of an anonymous array or access type cannot be renamed.
  6. (10) A subtype defined without any additional constraint can be used to achieve the effect of renaming another subtype (including a task or protected subtype) as in 
  7. subtype Mode is Ada.Text_IO.File_Mode;

Object Renaming Declarations

  1. An object_renaming_declaration is used to rename an object.

    Syntax 

  2. object_renaming_declaration ::=
   defining_identifier : subtype_mark renames object_name;

    Name Resolution Rules

  3. The type of the object_name shall resolve to the type determined by the subtype_mark.

    Legality Rules

  4. The renamed entity shall be an object.
  5. The renamed entity shall not be a subcomponent that depends on discriminants of a variable whose nominal subtype is unconstrained, unless this subtype is indefinite, or the variable is aliased. A slice of an array shall not be renamed if this restriction disallows renaming of the array.

    Static Semantics

  6. An object_renaming_declaration declares a new view of the renamed object whose properties are identical to those of the renamed view. Thus, the properties of the renamed object are not affected by the renaming_declaration. In particular, its value and whether or not it is a constant are unaffected; similarly, the constraints that apply to an object are not affected by renaming (any constraint implied by the subtype_mark of the object_renaming_declaration is ignored).

    Examples

  7. Example of renaming an object: 
  8. declare
   L : Person renames Leftmost_Person;  --  see section Incomplete Type Declarations
begin
   L.Age := L.Age + 1;
end;

Exception Renaming Declarations

  1. An exception_renaming_declaration is used to rename an exception.

    Syntax 

  2. exception_renaming_declaration ::=
   defining_identifier : exception renames exception_name;

    Legality Rules

  3. The renamed entity shall be an exception.

    Static Semantics

  4. An exception_renaming_declaration declares a new view of the renamed exception.

    Examples

  5. Example of renaming an exception: 
  6. EOF : exception renames Ada.IO_Exceptions.End_Error;
--  see section Exceptions in Input-Output

Package Renaming Declarations

  1. A package_renaming_declaration is used to rename a package.

    Syntax 

  2. package_renaming_declaration ::=
   package defining_program_unit_name renames package_name;

    Legality Rules

  3. The renamed entity shall be a package.

    Static Semantics

  4. A package_renaming_declaration declares a new view of the renamed package.

    Examples

  5. Example of renaming a package: 
  6. package TM renames Table_Manager;

Subprogram Renaming Declarations

  1. A subprogram_renaming_declaration can serve as the completion of a subprogram_declaration; such a renaming_declaration is called a renaming-as-body. A subprogram_renaming_declaration that is not a completion is called a renaming-as-declaration, and is used to rename a subprogram (possibly an enumeration literal) or an entry.

    Syntax 

  2. subprogram_renaming_declaration ::=
   subprogram_specification renames callable_entity_name;

    Name Resolution Rules

  3. The expected profile for the callable_entity_name is the profile given in the subprogram_specification.

    Legality Rules

  4. The profile of a renaming-as-declaration shall be mode-conformant with that of the renamed callable entity.
  5. The profile of a renaming-as-body shall be subtype-conformant with that of the renamed callable entity, and shall conform fully to that of the declaration it completes. If the renaming-as-body completes that declaration before the subprogram it declares is frozen, the subprogram it declares takes its convention from the renamed subprogram; otherwise the convention of the renamed subprogram shall not be Intrinsic.
  6. A name that denotes a formal parameter of the subprogram_specification is not allowed within the callable_entity_name.

    Static Semantics

  7. A renaming-as-declaration declares a new view of the renamed entity. The profile of this new view takes its subtypes, parameter modes, and calling convention from the original profile of the callable entity, while taking the formal parameter names and default_expressions from the profile given in the subprogram_renaming_declaration. The new view is a function or procedure, never an entry.

    Dynamic Semantics

  8. For a call on a renaming of a dispatching subprogram that is overridden, if the overriding occurred before the renaming, then the body executed is that of the overriding declaration, even if the overriding declaration is not visible at the place of the renaming; otherwise, the inherited or predefined subprogram is called. NOTES
  9. (11) A procedure can only be renamed as a procedure. A function whose defining_designator is either an identifier or an operator_symbol can be renamed with either an identifier or an operator_symbol; for renaming as an operator, the subprogram specification given in the renaming_declaration is subject to the rules given in section Overloading of Operators, for operator declarations. Enumeration literals can be renamed as functions; similarly, attribute_references that denote functions (such as references to Succ and Pred) can be renamed as functions. An entry can only be renamed as a procedure; the new name is only allowed to appear in contexts that allow a procedure name. An entry of a family can be renamed, but an entry family cannot be renamed as a whole.
  10. (12) The operators of the root numeric types cannot be renamed because the types in the profile are anonymous, so the corresponding specifications cannot be written; the same holds for certain attributes, such as Pos.
  11. (13) Calls with the new name of a renamed entry are procedure_call_statements and are not allowed at places where the syntax requires an entry_call_statement in conditional_ and timed_entry_calls, nor in an asynchronous_select; similarly, the Count attribute is not available for the new name.
  12. (14) The primitiveness of a renaming-as-declaration is determined by its profile, and by where it occurs, as for any declaration of (a view of) a subprogram; primitiveness is not determined by the renamed view. In order to perform a dispatching call, the subprogram name has to denote a primitive subprogram, not a non-primitive renaming of a primitive subprogram.

    Examples

  13. Examples of subprogram renaming declarations: 
  14. procedure My_Write(C : in Character) renames Pool(K).Write;
--  see section Selected Components

  15. function Real_Plus(Left, Right : Real   ) return Real    renames "+";
function Int_Plus (Left, Right : Integer) return Integer renames "+";

  16. function Rouge return Color renames Red;  --  see section Enumeration Types
function Rot   return Color renames Red;
function Rosso return Color renames Rouge;

  17. function Next(X : Color) return Color renames Color'Succ;
--  see section Enumeration Types
  18. Example of a subprogram renaming declaration with new parameter names: 
  19. function "*" (X,Y : Vector) return Real renames Dot_Product;
--  see section Subprogram Declarations
  20. Example of a subprogram renaming declaration with a new default expression: 
  21. function Minimum(L : Link := Head) return Cell renames Min_Cell;
--  see section Subprogram Declarations

Generic Renaming Declarations

    A generic_renaming_declaration is used to rename a generic unit.

    Syntax 

  1. generic_renaming_declaration ::=
    generic package defining_program_unit_name renames
      generic_package_name;
  | generic procedure defining_program_unit_name renames
      generic_procedure_name;
  | generic function defining_program_unit_name renames
      generic_function_name;

    Legality Rules

  2. The renamed entity shall be a generic unit of the corresponding kind.

    Static Semantics

  3. A generic_renaming_declaration declares a new view of the renamed generic unit. NOTES
  4. (15) Although the properties of the new view are the same as those of the renamed view, the place where the generic_renaming_declaration occurs may affect the legality of subsequent renamings and instantiations that denote the generic_renaming_declaration, in particular if the renamed generic unit is a library unit, see section Compilation Units - Library Units.

    Examples

  5. Example of renaming a generic unit: 
  6. generic package Enum_IO renames Ada.Text_IO.Enumeration_IO;
--  see section Input-Output for Enumeration Types

The Context of Overload Resolution

  1. Because declarations can be overloaded, it is possible for an occurrence of a usage name to have more than one possible interpretation; in most cases, ambiguity is disallowed. This clause describes how the possible interpretations resolve to the actual interpretation.
  2. Certain rules of the language (the Name Resolution Rules) are considered "overloading rules". If a possible interpretation violates an overloading rule, it is assumed not to be the intended interpretation; some other possible interpretation is assumed to be the actual interpretation. On the other hand, violations of non-overloading rules do not affect which interpretation is chosen; instead, they cause the construct to be illegal. To be legal, there usually has to be exactly one acceptable interpretation of a construct that is a "complete context", not counting any nested complete contexts.
  3. The syntax rules of the language and the visibility rules given in section Visibility, determine the possible interpretations. Most type checking rules (rules that require a particular type, or a particular class of types, for example) are overloading rules. Various rules for the matching of formal and actual parameters are overloading rules.

    Name Resolution Rules

  4. Overload resolution is applied separately to each complete context, not counting inner complete contexts. Each of the following constructs is a complete context:
    1. A context_item.
    2. declarative_item or declaration.
    3. A statement.
    4. A pragma_argument_association.
    5. The expression of a case_statement.
  1. An (overall) interpretation of a complete context embodies its meaning, and includes the following information about the constituents of the complete context, not including constituents of inner complete contexts:
    1. for each constituent of the complete context, to which syntactic categories it belongs, and by which syntax rules; and
    2. for each usage name, which declaration it denotes (and, therefore, which view and which entity it denotes); and
    3. for a complete context that is a declarative_item, whether or not it is a completion of a declaration, and (if so) which declaration it completes.
  1. A possible interpretation is one that obeys the syntax rules and the visibility rules. An acceptable interpretation is a possible interpretation that obeys the overloading rules, that is, those rules that specify an expected type or expected profile, or specify how a construct shall resolve or be interpreted.
  2. The interpretation of a constituent of a complete context is determined from the overall interpretation of the complete context as a whole. Thus, for example, "interpreted as a function_call," means that the construct's interpretation says that it belongs to the syntactic category function_call.
  3. Each occurrence of a usage name denotes the declaration determined by its interpretation. It also denotes the view declared by its denoted declaration, except in the following cases:
    1. If a usage name appears within the declarative region of a type_declaration and denotes that same type_declaration, then it denotes the current instance of the type (rather than the type itself). The current instance of a type is the object or value of the type that is associated with the execution that evaluates the usage name.
    2. If a usage name appears within the declarative region of a generic_declaration (but not within its generic_formal_part) and it denotes that same generic_declaration, then it denotes the current instance of the generic unit (rather than the generic unit itself). See also section Generic Instantiation.
  1. A usage name that denotes a view also denotes the entity of that view.
  2. The expected type for a given expression, name, or other construct determines, according to the type resolution rules given below, the types considered for the construct during overload resolution. The type resolution rules provide support for class-wide programming, universal numeric literals, dispatching operations, and anonymous access types:
    1. If a construct is expected to be of any type in a class of types, or of the universal or class-wide type for a class, then the type of the construct shall resolve to a type in that class or to a universal type that covers the class.
    2. If the expected type for a construct is a specific type T, then the type of the construct shall resolve either to T, or:
      1. to T'Class; or
      2. to a universal type that covers T; or
      3. when T is an anonymous access type, see section Access Types, with designated type D, to an access-to-variable type whose designated type is D'Class or is covered by D.
  1. In certain contexts, such as in a subprogram_renaming_declaration, the Name Resolution Rules define an expected profile for a given name; in such cases, the name shall resolve to the name of a callable entity whose profile is type conformant with the expected profile.

    Legality Rules

  2. When the expected type for a construct is required to be a single type in a given class, the type expected for the construct shall be determinable solely from the context in which the construct appears, excluding the construct itself, but using the requirement that it be in the given class; the type of the construct is then this single expected type. Furthermore, the context shall not be one that expects any type in some class that contains types of the given class; in particular, the construct shall not be the operand of a type_conversion.
  3. A complete context shall have at least one acceptable interpretation; if there is exactly one, then that one is chosen.
  4. There is a preference for the primitive operators (and ranges) of the root numeric types root_integer and root_real. In particular, if two acceptable interpretations of a constituent of a complete context differ only in that one is for a primitive operator (or range) of the type root_integer or root_real, and the other is not, the interpretation using the primitive operator (or range) of the root numeric type is preferred.
  5. For a complete context, if there is exactly one overall acceptable interpretation where each constituent's interpretation is the same as or preferred (in the above sense) over those in all other overall acceptable interpretations, then that one overall acceptable interpretation is chosen. Otherwise, the complete context is ambiguous.
  6. A complete context other than a pragma_argument_association shall not be ambiguous.
  7. A complete context that is a pragma_argument_association is allowed to be ambiguous (unless otherwise specified for the particular pragma), but only if every acceptable interpretation of the pragma argument is as a name that statically denotes a callable entity. Such a name denotes all of the declarations determined by its interpretations, and all of the views declared by these declarations. NOTES
  8. (16) If a usage name has only one acceptable interpretation, then it denotes the corresponding entity. However, this does not mean that the usage name is necessarily legal since other requirements exist which are not considered for overload resolution; for example, the fact that an expression is static, whether an object is constant, mode and subtype conformance rules, freezing rules, order of elaboration, and so on.
  9. Similarly, subtypes are not considered for overload resolution (the violation of a constraint does not make a program illegal but raises an exception during program execution).

Tasks and Synchronization

  1. The execution of an Ada program consists of the execution of one or more tasks. Each task represents a separate thread of control that proceeds independently and concurrently between the points where it interacts with other tasks. The various forms of task interaction are described in this section, and include:
    1. the activation and termination of a task;
    2. a call on a protected subprogram of a protected object, providing exclusive read-write access, or concurrent read-only access to shared data;
    3. a call on an entry, either of another task, allowing for synchronous communication with that task, or of a protected object, allowing for asynchronous communication with one or more other tasks using that same protected object;
    4. a timed operation, including a simple delay statement, a timed entry call or accept, or a timed asynchronous select statement (see next item);
    5. an asynchronous transfer of control as part of an asynchronous select statement, where a task stops what it is doing and begins execution at a different point in response to the completion of an entry call or the expiration of a delay;
    6. an abort statement, allowing one task to cause the termination of another task.
  1. In addition, tasks can communicate indirectly by reading and updating (unprotected) shared variables, presuming the access is properly synchronized through some other kind of task interaction.

    Static Semantics

  2. The properties of a task are defined by a corresponding task declaration and task_body, which together define a program unit called a task unit.

    Dynamic Semantics

  3. Over time, tasks proceed through various states. A task is initially inactive; upon activation, and prior to its termination it is either blocked (as part of some task interaction) or ready to run. While ready, a task competes for the available execution resources that it requires to run. NOTES
  4. (1) Concurrent task execution may be implemented on multicomputers, multiprocessors, or with interleaved execution on a single physical processor. On the other hand, whenever an implementation can determine that the required semantic effects can be achieved when parts of the execution of a given task are performed by different physical processors acting in parallel, it may choose to perform them in this way.

Task Units and Task Objects

  1. A task unit is declared by a task declaration, which has a corresponding task_body. A task declaration may be a task_type_declaration, in which case it declares a named task type; alternatively, it may be a single_task_declaration, in which case it defines an anonymous task type, as well as declaring a named task object of that type.

    Syntax 

  2. task_type_declaration ::=
   task type defining_identifier [known_discriminant_part]
     [is task_definition];

  3. single_task_declaration ::=
   task defining_identifier [is task_definition];

  4. task_definition ::=
      {task_item}
   [ private
      {task_item}]
   end [task_identifier]

  5. task_item ::= entry_declaration | representation_clause

  6. task_body ::=
   task body defining_identifier is
      declarative_part
   begin
      handled_sequence_of_statements
   end [task_identifier];
    1. If a task_identifier appears at the end of a task_definition or task_body, it shall repeat the defining_identifier.

Legality Rules

  1. A task declaration requires a completion, which shall be a task_body, and every task_body shall be the completion of some task declaration.

    Static Semantics

  2. A task_definition defines a task type and its first subtype. The first list of task_items of a task_definition, together with the known_discriminant_part, if any, is called the visible part of the task unit. The optional list of task_items after the reserved word private is called the private part of the task unit.

    Dynamic Semantics

  3. The elaboration of a task declaration elaborates the task_definition. The elaboration of a single_task_declaration also creates an object of an (anonymous) task type.
  4. The elaboration of a task_definition creates the task type and its first subtype; it also includes the elaboration of the entry_declarations in the given order.
  5. As part of the initialization of a task object, any representation_clauses and any per-object constraints associated with entry_declarations of the corresponding task_definition are elaborated in the given order.
  6. The elaboration of a task_body has no effect other than to establish that tasks of the type can from then on be activated without failing the Elaboration_Check.
  7. The execution of a task_body is invoked by the activation of a task of the corresponding type, see section Task Execution - Task Activation.
  8. The content of a task object of a given task type includes:
    1. The values of the discriminants of the task object, if any;
    2. An entry queue for each entry of the task object;
    3. A representation of the state of the associated task.
    NOTES
  1. (2) Within the declaration or body of a task unit, the name of the task unit denotes the current instance of the unit, see section The Context of Overload Resolution, rather than the first subtype of the corresponding task type (and thus the name cannot be used as a subtype_mark).
  2. (3) The notation of a selected_component can be used to denote a discriminant of a task, see section Selected Components. Within a task unit, the name of a discriminant of the task type denotes the corresponding discriminant of the current instance of the unit.
  3. (4) A task type is a limited type, see section Limited Types, and hence has neither an assignment operation nor predefined equality operators. If an application needs to store and exchange task identities, it can do so by defining an access type designating the corresponding task objects and by using access values for identification purposes. Assignment is available for such an access type as for any access type. Alternatively, if the implementation supports the Systems Programming Annex, the Identity attribute can be used for task identification, see section Task Identification and Attributes.

    Examples

  4. Examples of declarations of task types: 
  5. task type Server is
   entry Next_Work_Item(WI : in Work_Item);
   entry Shut_Down;
end Server;

  6. task type Keyboard_Driver(ID : Keyboard_ID := New_ID) is
   entry Read (C : out Character);
   entry Write(C : in  Character);
end Keyboard_Driver;
  7. Examples of declarations of single tasks: 
  8. task Controller is
   entry Request(Level)(D : Item);  --  a family of entries
end Controller;

  9. task Parser is
   entry Next_Lexeme(L : in  Lexical_Element);
   entry Next_Action(A : out Parser_Action);
end;

  10. task User;  --  has no entries
  11. Examples of task objects: 
  12. Agent    : Server;
Teletype : Keyboard_Driver(TTY_ID);
Pool     : array(1 .. 10) of Keyboard_Driver;
  13. Example of access type designating task objects: 
  14. type Keyboard is access Keyboard_Driver;
Terminal : Keyboard := new Keyboard_Driver(Term_ID);

Task Execution - Task Activation

Dynamic Semantics

  1. The execution of a task of a given task type consists of the execution of the corresponding task_body. The initial part of this execution is called the activation of the task; it consists of the elaboration of the declarative_part of the task_body. Should an exception be propagated by the elaboration of its declarative_part, the activation of the task is defined to have failed, and it becomes a completed task.
  2. A task object (which represents one task) can be created either as part of the elaboration of an object_declaration occurring immediately within some declarative region, or as part of the evaluation of an allocator. All tasks created by the elaboration of object_declarations of a single declarative region (including subcomponents of the declared objects) are activated together. Similarly, all tasks created by the evaluation of a single allocator are activated together. The activation of a task is associated with the innermost allocator or object_declaration that is responsible for its creation.
  3. For tasks created by the elaboration of object_declarations of a given declarative region, the activations are initiated within the context of the handled_sequence_of_statements (and its associated exception_handlers if any -- see section Exception Handlers, just prior to executing the statements of the _sequence. For a package without an explicit body or an explicit handled_sequence_of_statements, an implicit body or an implicit null_statement is assumed, as defined in section Package Bodies.
  4. For tasks created by the evaluation of an allocator, the activations are initiated as the last step of evaluating the allocator, after completing any initialization for the object created by the allocator, and prior to returning the new access value.
  5. The task that created the new tasks and initiated their activations (the activator) is blocked until all of these activations complete (successfully or not). Once all of these activations are complete, if the activation of any of the tasks has failed (due to the propagation of an exception), Tasking_Error is raised in the activator, at the place at which it initiated the activations. Otherwise, the activator proceeds with its execution normally. Any tasks that are aborted prior to completing their activation are ignored when determining whether to raise Tasking_Error.
  6. Should the task that created the new tasks never reach the point where it would initiate the activations (due to an abort or the raising of an exception), the newly created tasks become terminated and are never activated. NOTES
  7. (5) An entry of a task can be called before the task has been activated.
  8. (6) If several tasks are activated together, the execution of any of these tasks need not await the end of the activation of the other tasks.
  9. (7) A task can become completed during its activation either because of an exception or because it is aborted, see section Abort of a Task - Abort of a Sequence of Statements.

    Examples

  10. Example of task activation: 
  11. procedure P is
   A, B : Server;    --  elaborate the task objects A, B
   C    : Server;    --  elaborate the task object C
begin
   --  the tasks A, B, C are activated together
   --  before the first statement
   ...
end;

Task Dependence - Termination of Tasks

Dynamic Semantics

  1. Each task (other than an environment task -- see section Program Execution, depends on one or more masters, see section Completion and Finalization, as follows:
    1. If the task is created by the evaluation of an allocator for a given access type, it depends on each master that includes the elaboration of the declaration of the ultimate ancestor of the given access type.
    2. If the task is created by the elaboration of an object_declaration, it depends on each master that includes this elaboration.
  1. Furthermore, if a task depends on a given master, it is defined to depend on the task that executes the master, and (recursively) on any master of that task.
  2. A task is said to be completed when the execution of its corresponding task_body is completed. A task is said to be terminated when any finalization of the task_body has been performed, see section Completion and Finalization. The first step of finalizing a master (including a task_body) is to wait for the termination of any tasks dependent on the master. The task executing the master is blocked until all the dependents have terminated. Any remaining finalization is then performed and the master is left.
  3. Completion of a task (and the corresponding task_body) can occur when the task is blocked at a select_statement with an an open terminate_alternative, see section Selective Accept, the open terminate_alternative is selected if and only if the following conditions are satisfied:
    1. The task depends on some completed master;
    2. Each task that depends on the master considered is either already terminated or similarly blocked at a select_statement with an open terminate_alternative.
  1. When both conditions are satisfied, the task considered becomes completed, together with all tasks that depend on the master considered that are not yet completed. NOTES
  2. (8) The full view of a limited private type can be a task type, or can have subcomponents of a task type. Creation of an object of such a type creates dependences according to the full type.
  3. (9) An object_renaming_declaration defines a new view of an existing entity and hence creates no further dependence.
  4. (10) The rules given for the collective completion of a group of tasks all blocked on select_statements with open terminate_alternatives ensure that the collective completion can occur only when there are no remaining active tasks that could call one of the tasks being collectively completed.
  5. (11) If two or more tasks are blocked on select_statements with open terminate_alternatives, and become completed collectively, their finalization actions proceed concurrently.
  6. (12) The completion of a task can occur due to any of the following:
    1. the raising of an exception during the elaboration of the declarative_part of the corresponding task_body;
    2. the completion of the handled_sequence_of_statements of the corresponding task_body;
    3. the selection of an open terminate_alternative of a select_statement in the corresponding task_body;
    4. the abort of the task.

Examples

  1. Example of task dependence: 
  2. declare
   type Global is access Server; --  see section Task Units and Task Objects
   A, B : Server;
   G    : Global;
begin
   --  activation of A and B
   declare
      type Local is access Server;
      X : Global := new Server;  --  activation of X.all
      L : Local  := new Server;  --  activation of L.all
      C : Server;
   begin
      --  activation of C
      G := X;  --  both G and X designate the same task object
      ...
   end;  --  await termination of C and L.all (but not X.all)
   ...
end;  --  await termination of A, B, and G.all

Protected Units and Protected Objects

  1. A protected object provides coordinated access to shared data, through calls on its visible protected operations, which can be protected subprograms or protected entries. A protected unit is declared by a protected declaration, which has a corresponding protected_body. A protected declaration may be a protected_type_declaration, in which case it declares a named protected type; alternatively, it may be a single_protected_declaration, in which case it defines an anonymous protected type, as well as declaring a named protected object of that type.

    Syntax 

  2. protected_type_declaration ::=
   protected type defining_identifier [known_discriminant_part] is
     protected_definition;

  3. single_protected_declaration ::=
   protected defining_identifier is protected_definition;

  4. protected_definition ::=
      { protected_operation_declaration }
   [ private
      { protected_element_declaration } ]
   end [protected_identifier]

  5. protected_operation_declaration ::=
     subprogram_declaration
   | entry_declaration
   | representation_clause

  6. protected_element_declaration ::=
   protected_operation_declaration | component_declaration

  7. protected_body ::=
   protected body defining_identifier is
      { protected_operation_item }
   end [protected_identifier];

  8. protected_operation_item ::=
     subprogram_declaration
   | subprogram_body
   | entry_body
   | representation_clause
    1. If a protected_identifier appears at the end of a protected_definition or protected_body, it shall repeat the defining_identifier.

Legality Rules

  1. A protected declaration requires a completion, which shall be a protected_body, and every protected_body shall be the completion of some protected declaration.

    Static Semantics

  2. A protected_definition defines a protected type and its first subtype. The list of protected_operation_declarations of a protected_definition, together with the known_discriminant_part, if any, is called the visible part of the protected unit. The optional list of protected_element_declarations after the reserved word private is called the private part of the protected unit.

    Dynamic Semantics

  3. The elaboration of a protected declaration elaborates the protected_definition. The elaboration of a single_protected_declaration also creates an object of an (anonymous) protected type.
  4. The elaboration of a protected_definition creates the protected type and its first subtype; it also includes the elaboration of the component_declarations and protected_operation_declarations in the given order.
  5. As part of the initialization of a protected object, any per-object constraints, see section Record Types, are elaborated.
  6. The elaboration of a protected_body has no other effect than to establish that protected operations of the type can from then on be called without failing the Elaboration_Check.
  7. The content of an object of a given protected type includes:
    1. The values of the components of the protected object, including (implicitly) an entry queue for each entry declared for the protected object;
    2. A representation of the state of the execution resource associated with the protected object (one such resource is associated with each protected object).
  1. The execution resource associated with a protected object has to be acquired to read or update any components of the protected object; it can be acquired (as part of a protected action -- see section Protected Subprograms and Protected Actions, either for concurrent read-only access, or for exclusive read-write access.
  2. As the first step of the finalization of a protected object, each call remaining on any entry queue of the object is removed from its queue and Program_Error is raised at the place of the corresponding entry_call_statement. NOTES
  3. (13) Within the declaration or body of a protected unit, the name of the protected unit denotes the current instance of the unit, see section The Context of Overload Resolution, rather than the first subtype of the corresponding protected type (and thus the name cannot be used as a subtype_mark).
  4. (14) A selected_component can be used to denote a discriminant of a protected object, see section Selected Components. Within a protected unit, the name of a discriminant of the protected type denotes the corresponding discriminant of the current instance of the unit.
  5. (15) A protected type is a limited type, see section Limited Types, and hence has neither an assignment operation nor predefined equality operators.
  6. (16) The bodies of the protected operations given in the protected_body define the actions that take place upon calls to the protected operations.
  7. (17) The declarations in the private part are only visible within the private part and the body of the protected unit.

    Examples

  8. Example of declaration of protected type and corresponding body: 
  9. protected type Resource is
   entry Seize;
   procedure Release;
private
   Busy : Boolean := False;
end Resource;

  10. protected body Resource is
   entry Seize when not Busy is
   begin
      Busy := True;
   end Seize;

  11.    procedure Release is
   begin
      Busy := False;
   end Release;
end Resource;
  12. Example of a single protected declaration and corresponding body: 
  13. protected Shared_Array is
   --  Index, Item, and Item_Array are global types
   function  Component    (N : in Index) return Item;
   procedure Set_Component(N : in Index; E : in  Item);
private
   Table : Item_Array(Index) := (others => Null_Item);
end Shared_Array;

  14. protected body Shared_Array is
   function Component(N : in Index) return Item is
   begin
      return Table(N);
   end Component;

  15.    procedure Set_Component(N : in Index; E : in Item) is
   begin
      Table(N) := E;
   end Set_Component;
end Shared_Array;
  16. Examples of protected objects: 
  17. Control  : Resource;
Flags    : array(1 .. 100) of Resource;

Intertask Communication

  1. The primary means for intertask communication is provided by calls on entries and protected subprograms. Calls on protected subprograms allow coordinated access to shared data objects. Entry calls allow for blocking the caller until a given condition is satisfied (namely, that the corresponding entry is open -- see section Entry Calls.), and then communicating data or control information directly with another task or indirectly via a shared protected object.

    Static Semantics

  2. Any call on an entry or on a protected subprogram identifies a target object for the operation, which is either a task (for an entry call) or a protected object (for an entry call or a protected subprogram call). The target object is considered an implicit parameter to the operation, and is determined by the operation name (or prefix) used in the call on the operation, as follows:
    1. If it is a direct_name or expanded name that denotes the declaration (or body) of the operation, then the target object is implicitly specified to be the current instance of the task or protected unit immediately enclosing the operation; such a call is defined to be an internal call;
    2. If it is a selected_component that is not an expanded name, then the target object is explicitly specified to be the task or protected object denoted by the prefix of the name; such a call is defined to be an external call;
    3. If the name or prefix is a dereference (implicit or explicit) of an access-to-protected-subprogram value, then the target object is determined by the prefix of the Access attribute_reference that produced the access value originally, and the call is defined to be an external call;
    4. If the name or prefix denotes a subprogram_renaming_declaration, then the target object is as determined by the name of the renamed entity.
  1. A corresponding definition of target object applies to a requeue_statement, see section Requeue Statements, with a corresponding distinction between an internal requeue and an external requeue.

    Dynamic Semantics

  2. Within the body of a protected operation, the current instance (see section The Context of Overload Resolution) of the immediately enclosing protected unit is determined by the target object specified (implicitly or explicitly) in the call (or requeue) on the protected operation.
  3. Any call on a protected procedure or entry of a target protected object is defined to be an update to the object, as is a requeue on such an entry.

Protected Subprograms and Protected Actions

  1. A protected subprogram is a subprogram declared immediately within a protected_definition. Protected procedures provide exclusive read-write access to the data of a protected object; protected functions provide concurrent read-only access to the data.

    Static Semantics

  2. Within the body of a protected function (or a function declared immediately within a protected_body), the current instance of the enclosing protected unit is defined to be a constant (that is, its subcomponents may be read but not updated). Within the body of a protected procedure (or a procedure declared immediately within a protected_body), and within an entry_body, the current instance is defined to be a variable (updating is permitted).

    Dynamic Semantics

  3. For the execution of a call on a protected subprogram, the evaluation of the name or prefix and of the parameter associations, and any assigning back of in out or out parameters, proceeds as for a normal subprogram call, see section Subprogram Calls. If the call is an internal call, see section Intertask Communication, the body of the subprogram is executed as for a normal subprogram call. If the call is an external call, then the body of the subprogram is executed as part of a new protected action on the target protected object; the protected action completes after the body of the subprogram is executed. A protected action can also be started by an entry call, see section Entry Calls.
  4. A new protected action is not started on a protected object while another protected action on the same protected object is underway, unless both actions are the result of a call on a protected function. This rule is expressible in terms of the execution resource associated with the protected object:
    1. Starting a protected action on a protected object corresponds to acquiring the execution resource associated with the protected object, either for concurrent read-only access if the protected action is for a call on a protected function, or for exclusive read-write access otherwise;
    2. Completing the protected action corresponds to releasing the associated execution resource.
  1. After performing an operation on a protected object other than a call on a protected function, but prior to completing the associated protected action, the entry queues (if any) of the protected object are serviced (see section Entry Calls).

    Bounded (Run-Time) Errors

  2. During a protected action, it is a bounded error to invoke an operation that is potentially blocking. The following are defined to be potentially blocking operations:
    1. a select_statement;
    2. an accept_statement;
    3. an entry_call_statement;
    4. a delay_statement;
    5. an abort_statement;
    6. task creation or activation;
    7. an external call on a protected subprogram (or an external requeue) with the same target object as that of the protected action;
    8. a call on a subprogram whose body contains a potentially blocking operation.
  1. If the bounded error is detected, Program_Error is raised. If not detected, the bounded error might result in deadlock or a (nested) protected action on the same target object.
  2. Certain language-defined subprograms are potentially blocking. In particular, the subprograms of the language-defined input-output packages that manipulate files (implicitly or explicitly) are potentially blocking. Other potentially blocking subprograms are identified where they are defined. When not specified as potentially blocking, a language-defined subprogram is nonblocking. NOTES
  3. (18) If two tasks both try to start a protected action on a protected object, and at most one is calling a protected function, then only one of the tasks can proceed. Although the other task cannot proceed, it is not considered blocked, and it might be consuming processing resources while it awaits its turn. There is no language-defined ordering or queuing presumed for tasks competing to start a protected action -- on a multiprocessor such tasks might use busy-waiting; for monoprocessor considerations, see section Priority Ceiling Locking.
  4. (19) The body of a protected unit may contain declarations and bodies for local subprograms. These are not visible outside the protected unit.
  5. (20) The body of a protected function can contain internal calls on other protected functions, but not protected procedures, because the current instance is a constant. On the other hand, the body of a protected procedure can contain internal calls on both protected functions and procedures.
  6. (21) From within a protected action, an internal call on a protected subprogram, or an external call on a protected subprogram with a different target object is not considered a potentially blocking operation.

    Examples

  7. Examples of protected subprogram calls, see section Protected Units and Protected Objects 
  8. Shared_Array.Set_Component(N, E);
E := Shared_Array.Component(M);
Control.Release;

Entries and Accept Statements

  1. Entry_declarations, with the corresponding entry_bodies or accept_statements, are used to define potentially queued operations on tasks and protected objects.

    Syntax 

  2. entry_declaration ::=
   entry defining_identifier [(discrete_subtype_definition)]
     parameter_profile;

  3. accept_statement ::=
   accept entry_direct_name [(entry_index)] parameter_profile
      [do handled_sequence_of_statements
   end [entry_identifier]];

  4. entry_index ::= expression

  5. entry_body ::=
   entry defining_identifier entry_body_formal_part entry_barrier is
      declarative_part
   begin
      handled_sequence_of_statements
   end [entry_identifier];

  6. entry_body_formal_part ::=
   [(entry_index_specification)] parameter_profile

  7. entry_barrier ::= when condition

  8. entry_index_specification ::=
   for defining_identifier in discrete_subtype_definition
    1. If an entry_identifier appears at the end of an accept_statement, it shall repeat the entry_direct_name. If an entry_identifier appears at the end of an entry_body, it shall repeat the defining_identifier.
    2. An entry_declaration is allowed only in a protected or task declaration.

Name Resolution Rules

  1. In an accept_statement, the expected profile for the entry_direct_name is that of the entry_declaration; the expected type for an entry_index is that of the subtype defined by the discrete_subtype_definition of the corresponding entry_declaration.
  2. Within the handled_sequence_of_statements of an accept_statement, if a selected_component has a prefix that denotes the corresponding entry_declaration, then the entity denoted by the prefix is the accept_statement, and the selected_component is interpreted as an expanded name, see section Selected Components, the selector_name of the selected_component has to be the identifier for some formal parameter of the accept_statement.

    Legality Rules

  3. An entry_declaration in a task declaration shall not contain a specification for an access parameter, see section Access Types.
  4. For an accept_statement, the innermost enclosing body shall be a task_body, and the entry_direct_name shall denote an entry_declaration in the corresponding task declaration; the profile of the accept_statement shall conform fully to that of the corresponding entry_declaration. An accept_statement shall have a parenthesized entry_index if and only if the corresponding entry_declaration has a discrete_subtype_definition.
  5. An accept_statement shall not be within another accept_statement that corresponds to the same entry_declaration, nor within an asynchronous_select inner to the enclosing task_body.
  6. An entry_declaration of a protected unit requires a completion, which shall be an entry_body, and every entry_body shall be the completion of an entry_declaration of a protected unit. The profile of the entry_body shall conform fully to that of the corresponding declaration.
  7. An entry_body_formal_part shall have an entry_index_specification if and only if the corresponding entry_declaration has a discrete_subtype_definition. In this case, the discrete_subtype_definitions of the entry_declaration and the entry_index_specification shall fully conform to one another (see section Conformance Rules).
  8. A name that denotes a formal parameter of an entry_body is not allowed within the entry_barrier of the entry_body.

    Static Semantics

  9. The parameter modes defined for parameters in the parameter_profile of an entry_declaration are the same as for a subprogram_declaration and have the same meaning, see section Formal Parameter Modes.
  10. An entry_declaration with a discrete_subtype_definition, see section Array Types, declares a family of distinct entries having the same profile, with one such entry for each value of the entry index subtype defined by the discrete_subtype_definition. A name for an entry of a family takes the form of an indexed_component, where the prefix denotes the entry_declaration for the family, and the index value identifies the entry within the family. The term single entry is used to refer to any entry other than an entry of an entry family.
  11. In the entry_body for an entry family, the entry_index_specification declares a named constant whose subtype is the entry index subtype defined by the corresponding entry_declaration; the value of the named entry index identifies which entry of the family was called.

    Dynamic Semantics

  12. For the elaboration of an entry_declaration for an entry family, if the discrete_subtype_definition contains no per-object expressions (see section Record Types) then the discrete_subtype_definition is elaborated. Otherwise, the elaboration of the entry_declaration consists of the evaluation of any expression of the discrete_subtype_definition that is not a per-object expression (or part of one). The elaboration of an entry_declaration for a single entry has no effect.
  13. The actions to be performed when an entry is called are specified by the corresponding accept_statements (if any) for an entry of a task unit, and by the corresponding entry_body for an entry of a protected unit.
  14. For the execution of an accept_statement, the entry_index, if any, is first evaluated and converted to the entry index subtype; this index value identifies which entry of the family is to be accepted. Further execution of the accept_statement is then blocked until a caller of the corresponding entry is selected, see section Entry Calls, whereupon the handled_sequence_of_statements, if any, of the accept_statement is executed, with the formal parameters associated with the corresponding actual parameters of the selected entry call. Upon completion of the handled_sequence_of_statements, the accept_statement completes and is left. When an exception is propagated from the handled_sequence_of_statements of an accept_statement, the same exception is also raised by the execution of the corresponding entry_call_statement.
  15. The above interaction between a calling task and an accepting task is called a rendezvous. After a rendezvous, the two tasks continue their execution independently.
  16. An entry_body is executed when the condition of the entry_barrier evaluates to True and a caller of the corresponding single entry, or entry of the corresponding entry family, has been selected (see section Entry Calls). For the execution of the entry_body, the declarative_part of the entry_body is elaborated, and the handled_sequence_of_statements of the body is executed, as for the execution of a subprogram_body. The value of the named entry index, if any, is determined by the value of the entry index specified in the entry_name of the selected entry call (or intermediate requeue_statement -- see section Requeue Statements. NOTES
  17. (22) A task entry has corresponding accept_statements (zero or more), whereas a protected entry has a corresponding entry_body (exactly one).
  18. (23) A consequence of the rule regarding the allowed placements of accept_statements is that a task can execute accept_statements only for its own entries.
  19. (24) A return_statement, see section Return Statements, or a requeue_statement (see section Requeue Statements) may be used to complete the execution of an accept_statement or an entry_body.
  20. (25) The condition in the entry_barrier may reference anything visible except the formal parameters of the entry. This includes the entry index (if any), the components (including discriminants) of the protected object, the Count attribute of an entry of that protected object, and data global to the protected unit.
  21. The restriction against referencing the formal parameters within an entry_barrier ensures that all calls of the same entry see the same barrier value. If it is necessary to look at the parameters of an entry call before deciding whether to handle it, the entry_barrier can be "when True" and the caller can be requeued (on some private entry) when its parameters indicate that it cannot be handled immediately.

    Examples

  22. Examples of entry declarations: 
  23. entry Read(V : out Item);
entry Seize;
entry Request(Level)(D : Item);  --  a family of entries
  24. Examples of accept statements: 
  25. accept Shut_Down;

  26. accept Read(V : out Item) do
   V := Local_Item;
end Read;

  27. accept Request(Low)(D : Item) do
   ...
end Request;

Entry Calls

  1. An entry_call_statement (an entry call) can appear in various contexts. A simple entry call is a stand-alone statement that represents an unconditional call on an entry of a target task or a protected object. Entry calls can also appear as part of select_statements, see section Select Statements.

    Syntax 

  2. entry_call_statement ::= entry_name [actual_parameter_part];

    Name Resolution Rules

  3. The entry_name given in an entry_call_statement shall resolve to denote an entry. The rules for parameter associations are the same as for subprogram calls, see section Subprogram Calls, and section Parameter Associations.

    Static Semantics

  4. The entry_name of an entry_call_statement specifies (explicitly or implicitly) the target object of the call, the entry or entry family, and the entry index, if any, see section Intertask Communication.

    Dynamic Semantics

  5. Under certain circumstances (detailed below), an entry of a task or protected object is checked to see whether it is open or closed:
    1. An entry of a task is open if the task is blocked on an accept_statement that corresponds to the entry, see section Entries and Accept Statements, or on a selective_accept, (see section Selective Accept) with an open accept_alternative that corresponds to the entry; otherwise it is closed.
    2. An entry of a protected object is open if the condition of the entry_barrier of the corresponding entry_body evaluates to True; otherwise it is closed. If the evaluation of the condition propagates an exception, the exception Program_Error is propagated to all current callers of all entries of the protected object.
  1. For the execution of an entry_call_statement, evaluation of the name and of the parameter associations is as for a subprogram call, see section Subprogram Calls. The entry call is then issued: For a call on an entry of a protected object, a new protected action is started on the object, see section Protected Subprograms and Protected Actions. The named entry is checked to see if it is open; if open, the entry call is said to be selected immediately, and the execution of the call proceeds as follows:
    1. For a call on an open entry of a task, the accepting task becomes ready and continues the execution of the corresponding accept_statement (see section Entries and Accept Statements).
    2. For a call on an open entry of a protected object, the corresponding entry_body is executed, see section Entries and Accept Statements, as part of the protected action.
  1. If the accept_statement or entry_body completes other than by a requeue (see section Requeue Statements) return is made to the caller (after servicing the entry queues -- see below); any necessary assigning back of formal to actual parameters occurs, as for a subprogram call, see section Parameter Associations, such assignments take place outside of any protected action.
  2. If the named entry is closed, the entry call is added to an entry queue (as part of the protected action, for a call on a protected entry), and the call remains queued until it is selected or cancelled; there is a separate (logical) entry queue for each entry of a given task or protected object (including each entry of an entry family).
  3. When a queued call is selected, it is removed from its entry queue. Selecting a queued call from a particular entry queue is called servicing the entry queue. An entry with queued calls can be serviced under the following circumstances:
    1. When the associated task reaches a corresponding accept_statement, or a selective_accept with a corresponding open accept_alternative;
    2. If after performing, as part of a protected action on the associated protected object, an operation on the object other than a call on a protected function, the entry is checked and found to be open.
  1. If there is at least one call on a queue corresponding to an open entry, then one such call is selected according to the entry queuing policy in effect (see below), and the corresponding accept_statement or entry_body is executed as above for an entry call that is selected immediately.
  2. The entry queuing policy controls selection among queued calls both for task and protected entry queues. The default entry queuing policy is to select calls on a given entry queue in order of arrival. If calls from two or more queues are simultaneously eligible for selection, the default entry queuing policy does not specify which queue is serviced first. Other entry queuing policies can be specified by pragmas (see section Entry Queuing Policies).
  3. For a protected object, the above servicing of entry queues continues until there are no open entries with queued calls, at which point the protected action completes.
  4. For an entry call that is added to a queue, and that is not the triggering_statement of an asynchronous_select, see section Asynchronous Transfer of Control, the calling task is blocked until the call is cancelled, or the call is selected and a corresponding accept_statement or entry_body completes without requeuing. In addition, the calling task is blocked during a rendezvous.
  5. An attempt can be made to cancel an entry call upon an abort (see section Abort of a Task - Abort of a Sequence of Statements) and as part of certain forms of select_statement, see section Timed Entry Calls, section Conditional Entry Calls, and section Asynchronous Transfer of Control. The cancellation does not take place until a point (if any) when the call is on some entry queue, and not protected from cancellation as part of a requeue, see section Requeue Statements, at such a point, the call is removed from the entry queue and the call completes due to the cancellation. The cancellation of a call on an entry of a protected object is a protected action, and as such cannot take place while any other protected action is occurring on the protected object. Like any protected action, it includes servicing of the entry queues (in case some entry barrier depends on a Count attribute).
  6. A call on an entry of a task that has already completed its execution raises the exception Tasking_Error at the point of the call; similarly, this exception is raised at the point of the call if the called task completes its execution or becomes abnormal before accepting the call or completing the rendezvous, see section Abort of a Task - Abort of a Sequence of Statements. This applies equally to a simple entry call and to an entry call as part of a select_statement.

    Implementation Permissions

  7. An implementation may perform the sequence of steps of a protected action using any thread of control; it need not be that of the task that started the protected action. If an entry_body completes without requeuing, then the corresponding calling task may be made ready without waiting for the entire protected action to complete.
  8. When the entry of a protected object is checked to see whether it is open, the implementation need not reevaluate the condition of the corresponding entry_barrier if no variable or attribute referenced by the condition (directly or indirectly) has been altered by the execution (or cancellation) of a protected procedure or entry call on the object since the condition was last evaluated.
  9. An implementation may evaluate the conditions of all entry_barriers of a given protected object any time any entry of the object is checked to see if it is open.
  10. When an attempt is made to cancel an entry call, the implementation need not make the attempt using the thread of control of the task (or interrupt) that initiated the cancellation; in particular, it may use the thread of control of the caller itself to attempt the cancellation, even if this might allow the entry call to be selected in the interim. NOTES
  11. (26) If an exception is raised during the execution of an entry_body, it is propagated to the corresponding caller, see section Exception Handling.
  12. (27) For a call on a protected entry, the entry is checked to see if it is open prior to queuing the call, and again thereafter if its Count attribute, see section Task and Entry Attributes, is referenced in some entry barrier.
  13. (28) In addition to simple entry calls, the language permits timed, conditional, and asynchronous entry calls, see section Timed Entry Calls, see section Conditional Entry Calls, and section Asynchronous Transfer of Control.
  14. (29) The condition of an entry_barrier is allowed to be evaluated by an implementation more often than strictly necessary, even if the evaluation might have side effects. On the other hand, an implementation need not reevaluate the condition if nothing it references was updated by an intervening protected action on the protected object, even if the condition references some global variable that might have been updated by an action performed from outside of a protected action.

    Examples

  15. Examples of entry calls: 
  16. Agent.Shut_Down;                     --  see section Task Units and Task Objects
Parser.Next_Lexeme(E);               --  see section Task Units and Task Objects
Pool(5).Read(Next_Char);             --  see section Task Units and Task Objects
Controller.Request(Low)(Some_Item);  --  see section Task Units and Task Objects
Flags(3).Seize;                      --  see section Protected Units and Protected Objects

Requeue Statements

  1. A requeue_statement can be used to complete an accept_statement or entry_body, while redirecting the corresponding entry call to a new (or the same) entry queue. Such a requeue can be performed with or without allowing an intermediate cancellation of the call, due to an abort or the expiration of a delay.

    Syntax 

  2. requeue_statement ::= requeue entry_name [with abort];

    Name Resolution Rules

  3. The entry_name of a requeue_statement shall resolve to denote an entry (the target entry) that either has no parameters, or that has a profile that is type conformant, see section Conformance Rules, with the profile of the innermost enclosing entry_body or accept_statement.

    Legality Rules

  4. A requeue_statement shall be within a callable construct that is either an entry_body or an accept_statement, and this construct shall be the innermost enclosing body or callable construct.
  5. If the target entry has parameters, then its profile shall be subtype conformant with the profile of the innermost enclosing callable construct.
  6. In a requeue_statement of an accept_statement of some task unit, either the target object shall be a part of a formal parameter of the accept_statement, or the accessibility level of the target object shall not be equal to or statically deeper than any enclosing accept_statement of the task unit. In a requeue_statement of an entry_body of some protected unit, either the target object shall be a part of a formal parameter of the entry_body, or the accessibility level of the target object shall not be statically deeper than that of the entry_declaration. Dynamic Semantics
  7. The execution of a requeue_statement proceeds by first evaluating the entry_name, including the prefix identifying the target task or protected object and the expression identifying the entry within an entry family, if any. The entry_body or accept_statement enclosing the requeue_statement is then completed, finalized, and left, see section Completion and Finalization.
  8. For the execution of a requeue on an entry of a target task, after leaving the enclosing callable construct, the named entry is checked to see if it is open and the requeued call is either selected immediately or queued, as for a normal entry call, see section Entry Calls.
  9. For the execution of a requeue on an entry of a target protected object, after leaving the enclosing callable construct:
    1. if the requeue is an internal requeue (that is, the requeue is back on an entry of the same protected object -- see section Intertask Communication.), the call is added to the queue of the named entry and the ongoing protected action continues, see section Protected Subprograms and Protected Actions;
    2. if the requeue is an external requeue (that is, the target protected object is not implicitly the same as the current object -- see section Intertask Communication.), a protected action is started on the target object and proceeds as for a normal entry call, see section Entry Calls.
  1. If the new entry named in the requeue_statement has formal parameters, then during the execution of the accept_statement or entry_body corresponding to the new entry, the formal parameters denote the same objects as did the corresponding formal parameters of the callable construct completed by the requeue. In any case, no parameters are specified in a requeue_statement; any parameter passing is implicit.
  2. If the requeue_statement includes the reserved words with abort (it is a requeue-with-abort), then:
    1. if the original entry call has been aborted, see section Abort of a Task - Abort of a Sequence of Statements, then the requeue acts as an abort completion point for the call, and the call is cancelled and no requeue is performed;
    2. if the original entry call was timed (or conditional), then the original expiration time is the expiration time for the requeued call.
  1. If the reserved words with abort do not appear, then the call remains protected against cancellation while queued as the result of the requeue_statement. NOTES
  2. (30) A requeue is permitted from a single entry to an entry of an entry family, or vice-versa. The entry index, if any, plays no part in the subtype conformance check between the profiles of the two entries; an entry index is part of the entry_name for an entry of a family.

    Examples

  3. Examples of requeue statements: 
  4. requeue Request(Medium) with abort;
--  requeue on a member of an entry family
--  of the current task, see section Task Units and Task Objects

  5. requeue Flags(I).Seize;
--  requeue on an entry of an array
--  component, see section Protected Units and Protected Objects

Delay Statements, Duration, and Time

  1. A delay_statement is used to block further execution until a specified expiration time is reached. The expiration time can be specified either as a particular point in time (in a delay_until_statement), or in seconds from the current time (in a delay_relative_statement). The language-defined package Calendar provides definitions for a type Time and associated operations, including a function Clock that returns the current time.

    Syntax 

  2. delay_statement ::= delay_until_statement | delay_relative_statement

  3. delay_until_statement ::= delay until delay_expression;

  4. delay_relative_statement ::= delay delay_expression;

    Name Resolution Rules

  5. The expected type for the delay_expression in a delay_relative_statement is the predefined type Duration. The delay_expression in a delay_until_statement is expected to be of any nonlimited type.

    Legality Rules

  6. There can be multiple time bases, each with a corresponding clock, and a corresponding time type. The type of the delay_expression in a delay_until_statement shall be a time type -- either the type Time defined in the language-defined package Calendar (see below), or some other implementation-defined time type, see section Monotonic Time.

    Static Semantics

  7. There is a predefined fixed point type named Duration, declared in the visible part of package Standard; a value of type Duration is used to represent the length of an interval of time, expressed in seconds. The type Duration is not specific to a particular time base, but can be used with any time base.
  8. A value of the type Time in package Calendar, or of some other implementation-defined time type, represents a time as reported by a corresponding clock.
  9. The following language-defined library package exists: 
  10. package Ada.Calendar is
  type Time is private;

  11.   subtype Year_Number  is Integer range 1901 ..  2099;
  subtype Month_Number is Integer range 1 ..  12;
  subtype Day_Number   is Integer range 1 ..  31;
  subtype Day_Duration is Duration range 0.0 ..  86_400.0;

  12.   function Clock return Time;

  13.   function Year   (Date : Time) return Year_Number;
  function Month  (Date : Time) return Month_Number;
  function Day    (Date : Time) return Day_Number;
  function Seconds(Date : Time) return Day_Duration;

  14.   procedure Split (Date  : in Time;
                   Year    : out Year_Number;
                   Month   : out Month_Number;
                   Day     : out Day_Number;
                   Seconds : out Day_Duration);

  15.   function Time_Of(Year  : Year_Number;
                   Month   : Month_Number;
                   Day     : Day_Number;
                   Seconds : Day_Duration := 0.0)
   return Time;

  16.   function "+" (Left : Time;   Right : Duration) return Time;
  function "+" (Left : Duration; Right : Time) return Time;
  function "-" (Left : Time;   Right : Duration) return Time;
  function "-" (Left : Time;   Right : Time) return Duration;

  17.   function "<" (Left, Right : Time) return Boolean;
  function "<="(Left, Right : Time) return Boolean;
  function ">" (Left, Right : Time) return Boolean;
  function ">="(Left, Right : Time) return Boolean;

  18.   Time_Error : exception;

  19. private
   ... -- not specified by the language
end Ada.Calendar;

    Dynamic Semantics

  20. For the execution of a delay_statement, the delay_expression is first evaluated. For a delay_until_statement, the expiration time for the delay is the value of the delay_expression, in the time base associated with the type of the expression. For a delay_relative_statement, the expiration time is defined as the current time, in the time base associated with relative delays, plus the value of the delay_expression converted to the type Duration, and then rounded up to the next clock tick. The time base associated with relative delays is as defined in section Delay Accuracy, or is implementation defined.
  21. The task executing a delay_statement is blocked until the expiration time is reached, at which point it becomes ready again. If the expiration time has already passed, the task is not blocked.
  22. If an attempt is made to cancel the delay_statement (as part of an asynchronous_select or abort -- see section Asynchronous Transfer of Control, and section Abort of a Task - Abort of a Sequence of Statements, the _statement is cancelled if the expiration time has not yet passed, thereby completing the delay_statement.
  23. The time base associated with the type Time of package Calendar is implementation defined. The function Clock of package Calendar returns a value representing the current time for this time base. The implementation-defined value of the named number System.Tick (see section The Package System) is an approximation of the length of the real-time interval during which the value of Calendar.Clock remains constant.
  24. The functions Year, Month, Day, and Seconds return the corresponding values for a given value of the type Time, as appropriate to an implementation-defined timezone; the procedure Split returns all four corresponding values. Conversely, the function Time_Of combines a year number, a month number, a day number, and a duration, into a value of type Time. The operators "+" and "-" for addition and subtraction of times and durations, and the relational operators for times, have the conventional meaning.
  25. If Time_Of is called with a seconds value of 86_400.0, the value returned is equal to the value of Time_Of for the next day with a seconds value of 0.0. The value returned by the function Seconds or through the Seconds parameter of the procedure Split is always less than 86_400.0.
  26. The exception Time_Error is raised by the function Time_Of if the actual parameters do not form a proper date. This exception is also raised by the operators "+" and "-" if the result is not representable in the type Time or Duration, as appropriate. This exception is also raised by the function Year or the procedure Split if the year number of the given date is outside of the range of the subtype Year_Number.

    Implementation Requirements

  27. The implementation of the type Duration shall allow representation of time intervals (both positive and negative) up to at least 86400 seconds (one day); Duration'Small shall not be greater than twenty milliseconds. The implementation of the type Time shall allow representation of all dates with year numbers in the range of Year_Number; it may allow representation of other dates as well (both earlier and later).

    Implementation Permissions

  28. An implementation may define additional time types, see section Monotonic Time.
  29. An implementation may raise Time_Error if the value of a delay_expression in a delay_until_statement of a select_statement represents a time more than 90 days past the current time. The actual limit, if any, is implementation-defined.

    Implementation Advice

  30. Whenever possible in an implementation, the value of Duration'Small should be no greater than 100 microseconds.
  31. The time base for delay_relative_statements should be monotonic; it need not be the same time base as used for Calendar.Clock. NOTES
  32. (31) A delay_relative_statement with a negative value of the delay_expression is equivalent to one with a zero value.
  33. (32) A delay_statement may be executed by the environment task; consequently delay_statements may be executed as part of the elaboration of a library_item or the execution of the main subprogram. Such statements delay the environment task, see section Program Execution.
  34. (33) A delay_statement is an abort completion point and a potentially blocking operation, even if the task is not actually blocked.
  35. (34) There is no necessary relationship between System.Tick (the resolution of the clock of package Calendar) and Duration'Small (the small of type Duration).
  36. (35) Additional requirements associated with delay_statements are given in section Delay Accuracy.

    Examples

  37. Example of a relative delay statement: 
  38. delay 3.0;  -- delay 3.0 seconds
  39. Example of a periodic task: 
  40. declare
   use Ada.Calendar;
   Next_Time : Time := Clock + Period;
                      -- Period is a global constant of type Duration
begin
   loop               -- repeated every Period seconds
      delay until Next_Time;
      ... -- perform some actions
      Next_Time := Next_Time + Period;
   end loop;
end;

Select Statements

  1. There are four forms of the select_statement. One form provides a selective wait for one or more select_alternatives. Two provide timed and conditional entry calls. The fourth provides asynchronous transfer of control.

    Syntax 

  2. select_statement ::=
     selective_accept
   | timed_entry_call
   | conditional_entry_call
   | asynchronous_select

    Examples

  3. Example of a select statement: 
  4. select
   accept Driver_Awake_Signal;
or
   delay 30.0*Seconds;
   Stop_The_Train;
end select;

Selective Accept

  1. This form of the select_statement allows a combination of waiting for, and selecting from, one or more alternatives. The selection may depend on conditions associated with each alternative of the selective_accept.

    Syntax 

  2. selective_accept ::=
   select
      [guard]
      select_alternative
 { or
      [guard]
      select_alternative }
    [ else
      sequence_of_statements ]
    end select;

  3. guard ::= when condition =>

  4. select_alternative ::=
     accept_alternative
   | delay_alternative
   | terminate_alternative

  5. accept_alternative ::=
   accept_statement [sequence_of_statements]

  6. delay_alternative ::=
   delay_statement [sequence_of_statements]

  7. terminate_alternative ::= terminate;
    1. A selective_accept shall contain at least one accept_alternative. In addition, it can contain:
      1. a terminate_alternative (only one); or
      2. one or more delay_alternatives; or
      3. an else part (the reserved word else followed by a sequence_of_statements).
    1. These three possibilities are mutually exclusive.

Legality Rules

  1. If a selective_accept contains more than one delay_alternative, then all shall be delay_relative_statements, or all shall be delay_until_statements for the same time type.

    Dynamic Semantics

  2. A select_alternative is said to be open if it is not immediately preceded by a guard, or if the condition of its guard evaluates to True. It is said to be closed otherwise.
  3. For the execution of a selective_accept, any guard conditions are evaluated; open alternatives are thus determined. For an open delay_alternative, the delay_expression is also evaluated. Similarly, for an open accept_alternative for an entry of a family, the entry_index is also evaluated. These evaluations are performed in an arbitrary order, except that a delay_expression or entry_index is not evaluated until after evaluating the corresponding condition, if any. Selection and execution of one open alternative, or of the else part, then completes the execution of the selective_accept; the rules for this selection are described below.
  4. Open accept_alternatives are first considered. Selection of one such alternative takes place immediately if the corresponding entry already has queued calls. If several alternatives can thus be selected, one of them is selected according to the entry queuing policy in effect (see section Entry Calls and section Entry Queuing Policies). When such an alternative is selected, the selected call is removed from its entry queue and the handled_sequence_of_statements (if any) of the corresponding accept_statement is executed; after the rendezvous completes any subsequent sequence_of_statements of the alternative is executed. If no selection is immediately possible (in the above sense) and there is no else part, the task blocks until an open alternative can be selected.
  5. Selection of the other forms of alternative or of an else part is performed as follows:
    1. An open delay_alternative is selected when its expiration time is reached if no accept_alternative or other delay_alternative can be selected prior to the expiration time. If several delay_alternatives have this same expiration time, one of them is selected according to the queuing policy in effect, see section Entry Queuing Policies, the default queuing policy chooses arbitrarily among the delay_alternatives whose expiration time has passed.
    2. The else part is selected and its sequence_of_statements is executed if no accept_alternative can immediately be selected; in particular, if all alternatives are closed.
    3. An open terminate_alternative is selected if the conditions stated at the end of clause (see section Task Dependence - Termination of Tasks) are satisfied.
  1. The exception Program_Error is raised if all alternatives are closed and there is no else part. NOTES
  2. (36) A selective_accept is allowed to have several open delay_alternatives. A selective_accept is allowed to have several open accept_alternatives for the same entry.

    Examples

  3. Example of a task body with a selective accept: 
  4. task body Server is
   Current_Work_Item : Work_Item;
begin
   loop
      select
         accept Next_Work_Item(WI : in Work_Item) do
            Current_Work_Item := WI;
          end;
          Process_Work_Item(Current_Work_Item);
      or
         accept Shut_Down;
         exit;       -- Premature shut down requested
      or
         terminate;  -- Normal shutdown at end of scope
      end select;
   end loop;
end Server;

Timed Entry Calls

  1. A timed_entry_call issues an entry call that is cancelled if the call (or a requeue-with-abort of the call) is not selected before the expiration time is reached.

    Syntax 

  2. timed_entry_call ::=
   select
      entry_call_alternative
   or
      delay_alternative
   end select;

  3. entry_call_alternative ::=
   entry_call_statement [sequence_of_statements]

    Dynamic Semantics

  4. For the execution of a timed_entry_call, the entry_name and the actual parameters are evaluated, as for a simple entry call, see section Entry Calls. The expiration time, see section Delay Statements, Duration, and Time for the call is determined by evaluating the delay_expression of the delay_alternative; the entry call is then issued.
  5. If the call is queued (including due to a requeue-with-abort), and not selected before the expiration time is reached, an attempt to cancel the call is made. If the call completes due to the cancellation, the optional sequence_of_statements of the delay_alternative is executed; if the entry call completes normally, the optional sequence_of_statements of the entry_call_alternative is executed.

    Examples

  6. Example of a timed entry call: 
  7. select
   Controller.Request(Medium)(Some_Item);
or
   delay 45.0;
   --  controller too busy, try something else
end select;

Conditional Entry Calls

  1. A conditional_entry_call issues an entry call that is then cancelled if it is not selected immediately (or if a requeue-with-abort of the call is not selected immediately).

    Syntax 

  2. conditional_entry_call ::=
   select
      entry_call_alternative
   else
      sequence_of_statements
   end select;

    Dynamic Semantics

  3. The execution of a conditional_entry_call is defined to be equivalent to the execution of a timed_entry_call with a delay_alternative specifying an immediate expiration time and the same sequence_of_statements as given after the reserved word else. NOTES
  4. (37) A conditional_entry_call may briefly increase the Count attribute of the entry, even if the conditional call is not selected.

    Examples

  5. Example of a conditional entry call: 
  6. procedure Spin(R : in Resource) is
begin
   loop
      select
         R.Seize;
         return;
      else
         null;  --  busy waiting
      end select;
   end loop;
end;

Asynchronous Transfer of Control

  1. An asynchronous select_statement provides asynchronous transfer of control upon completion of an entry call or the expiration of a delay.

    Syntax 

  2. asynchronous_select ::=
   select
      triggering_alternative
   then abort
      abortable_part
   end select;

  3. triggering_alternative ::=
   triggering_statement [sequence_of_statements]

  4. triggering_statement ::= entry_call_statement | delay_statement

  5. abortable_part ::= sequence_of_statements

    Dynamic Semantics

  6. For the execution of an asynchronous_select whose triggering_statement is an entry_call_statement, the entry_name and actual parameters are evaluated as for a simple entry call, see section Entry Calls, and the entry call is issued. If the entry call is queued (or requeued-with-abort), then the abortable_part is executed. If the entry call is selected immediately, and never requeued-with-abort, then the abortable_part is never started.
  7. For the execution of an asynchronous_select whose triggering_statement is a delay_statement, the delay_expression is evaluated and the expiration time is determined, as for a normal delay_statement. If the expiration time has not already passed, the abortable_part is executed.
  8. If the abortable_part completes and is left prior to completion of the triggering_statement, an attempt to cancel the triggering_statement is made. If the attempt to cancel succeeds, see section Entry Calls, and section Delay Statements, Duration, and Time, the asynchronous_select is complete.
  9. If the triggering_statement completes other than due to cancellation, the abortable_part is aborted (if started but not yet completed -- see section Abort of a Task - Abort of a Sequence of Statements). If the triggering_statement completes normally, the optional sequence_of_statements of the triggering_alternative is executed after the abortable_part is left.

    Examples

  10. Example of a main command loop for a command interpreter: 
  11. loop
    select
        Terminal.Wait_For_Interrupt;
        Put_Line("Interrupted");
    then abort
        -- This will be abandoned upon terminal interrupt
        Put_Line("-> ");
        Get_Line(Command, Last);
        Process_Command(Command(1..Last));
    end select;
end loop;
  12. Example of a time-limited calculation: 
  13. select
   delay 5.0;
   Put_Line("Calculation does not converge");
then abort
   -- This calculation should finish in 5.0 seconds;
   --  if not, it is assumed to diverge.
   Horribly_Complicated_Recursive_Function(X, Y);
end select;

Abort of a Task - Abort of a Sequence of Statements

  1. An abort_statement causes one or more tasks to become abnormal, thus preventing any further interaction with such tasks. The completion of the triggering_statement of an asynchronous_select causes a sequence_of_statements to be aborted.

    Syntax 

  2. abort_statement ::= abort task_name {, task_name};

    Name Resolution Rules

  3. Each task_name is expected to be of any task type; they need not all be of the same task type.

    Dynamic Semantics

  4. For the execution of an abort_statement, the given task_names are evaluated in an arbitrary order. Each named task is then aborted, which consists of making the task abnormal and aborting the execution of the corresponding task_body, unless it is already completed.
  5. When the execution of a construct is aborted (including that of a task_body or of a sequence_of_statements), the execution of every construct included within the aborted execution is also aborted, except for executions included within the execution of an abort-deferred operation; the execution of an abort-deferred operation continues to completion without being affected by the abort; the following are the abort-deferred operations:
    1. a protected action;
    2. waiting for an entry call to complete (after having initiated the attempt to cancel it -- see below);
    3. waiting for the termination of dependent tasks;
    4. the execution of an Initialize procedure as the last step of the default initialization of a controlled object;
    5. the execution of a Finalize procedure as part of the finalization of a controlled object;
    6. an assignment operation to an object with a controlled part.
  1. The last three of these are discussed further in section User-Defined Assignment and Finalization.
  2. When a master is aborted, all tasks that depend on that master are aborted.
  3. The order in which tasks become abnormal as the result of an abort_statement or the abort of a sequence_of_statements is not specified by the language.
  4. If the execution of an entry call is aborted, an immediate attempt is made to cancel the entry call, see section Entry Calls. If the execution of a construct is aborted at a time when the execution is blocked, other than for an entry call, at a point that is outside the execution of an abort-deferred operation, then the execution of the construct completes immediately. For an abort due to an abort_statement, these immediate effects occur before the execution of the abort_statement completes. Other than for these immediate cases, the execution of a construct that is aborted does not necessarily complete before the abort_statement completes. However, the execution of the aborted construct completes no later than its next abort completion point (if any) that occurs outside of an abort-deferred operation; the following are abort completion points for an execution:
    1. the point where the execution initiates the activation of another task;
    2. the end of the activation of a task;
    3. the start or end of the execution of an entry call, accept_statement, delay_statement, or abort_statement;
    4. the start of the execution of a select_statement, or of the sequence_of_statements of an exception_handler.

Bounded (Run-Time) Errors

  1. An attempt to execute an asynchronous_select as part of the execution of an abort-deferred operation is a bounded error. Similarly, an attempt to create a task that depends on a master that is included entirely within the execution of an abort-deferred operation is a bounded error. In both cases, Program_Error is raised if the error is detected by the implementation; otherwise the operations proceed as they would outside an abort-deferred operation, except that an abort of the abortable_part or the created task might or might not have an effect.

    Erroneous Execution

  2. If an assignment operation completes prematurely due to an abort, the assignment is said to be disrupted; the target of the assignment or its parts can become abnormal, and certain subsequent uses of the object can be erroneous, as explained in section Data Validity. NOTES
  3. (38) An abort_statement should be used only in situations requiring unconditional termination.
  4. (39) A task is allowed to abort any task it can name, including itself.
  5. (40) Additional requirements associated with abort are given in section Preemptive Abort.

Task and Entry Attributes

Dynamic Semantics

  1. For a prefix T that is of a task type (after any implicit dereference), the following attributes are defined:
  2. T'Callable 
    Yields the value True when the task denoted by T is callable,
and False otherwise; a task is callable unless it is
completed or abnormal. The value of this attribute is of the
predefined type Boolean.
  3. T'Terminated 
    Yields the value True if the task denoted by T is terminated,
and False otherwise. The value of this attribute is of the
predefined type Boolean.
  4. For a prefix E that denotes an entry of a task or protected unit, the following attribute is defined. This attribute is only allowed within the body of the task or protected unit, but excluding, in the case of an entry of a task unit, within any program unit that is, itself, inner to the body of the task unit.
  5. E'Count 
    Yields the number of calls presently queued on the entry E of
the current instance of the unit. The value of this
attribute is of the type universal_integer.
    NOTES
  6. (41) For the Count attribute, the entry can be either a single entry or an entry of a family. The name of the entry or entry family can be either a direct_name or an expanded name.
  7. (42) Within task units, algorithms interrogating the attribute E'Count should take precautions to allow for the increase of the value of this attribute for incoming entry calls, and its decrease, for example with timed_entry_calls. Also, a conditional_entry_call may briefly increase this value, even if the conditional call is not accepted.
  8. (43) Within protected units, algorithms interrogating the attribute E'Count in the entry_barrier for the entry E should take precautions to allow for the evaluation of the condition of the barrier both before and after queuing a given caller.

Shared Variables

Static Semantics

  1. If two different objects, including nonoverlapping parts of the same object, are independently addressable, they can be manipulated concurrently by two different tasks without synchronization. Normally, any two nonoverlapping objects are independently addressable. However, if packing, record layout, or Component_Size is specified for a given composite object, then it is implementation defined whether or not two nonoverlapping parts of that composite object are independently addressable.

    Dynamic Semantics

  2. Separate tasks normally proceed independently and concurrently with one another. However, task interactions can be used to synchronize the actions of two or more tasks to allow, for example, meaningful communication by the direct updating and reading of variables shared between the tasks. The actions of two different tasks are synchronized in this sense when an action of one task signals an action of the other task; an action A1 is defined to signal an action A2 under the following circumstances:
    1. If A1 and A2 are part of the execution of the same task, and the language rules require A1 to be performed before A2;
    2. If A1 is the action of an activator that initiates the activation of a task, and A2 is part of the execution of the task that is activated;
    3. If A1 is part of the activation of a task, and A2 is the action of waiting for completion of the activation;
    4. If A1 is part of the execution of a task, and A2 is the action of waiting for the termination of the task;
    5. If A1 is the action of issuing an entry call, and A2 is part of the corresponding execution of the appropriate entry_body or accept_statement.
    6. If A1 is part of the execution of an accept_statement or entry_body, and A2 is the action of returning from the corresponding entry call;
    7. If A1 is part of the execution of a protected procedure body or entry_body for a given protected object, and A2 is part of a later execution of an entry_body for the same protected object;
    8. If A1 signals some action that in turn signals A2.

Erroneous Execution

  1. Given an action of assigning to an object, and an action of reading or updating a part of the same object (or of a neighboring object if the two are not independently addressable), then the execution of the actions is erroneous unless the actions are sequential. Two actions are sequential if one of the following is true:
    1. One action signals the other;
    2. Both actions occur as part of the execution of the same task;
    3. Both actions occur as part of protected actions on the same protected object, and at most one of the actions is part of a call on a protected function of the protected object.
  1. A pragma Atomic or Atomic_Components may also be used to ensure that certain reads and updates are sequential -- see section Shared Variable Control.

Example of Tasking and Synchronization

Examples

  1. The following example defines a buffer protected object to smooth variations between the speed of output of a producing task and the speed of input of some consuming task. For instance, the producing task might have the following structure: 
  2. task Producer;

  3. task body Producer is
   Char : Character;
begin
   loop
      ... --  produce the next character Char
      Buffer.Write(Char);
      exit when Char = ASCII.EOT;
   end loop;
end Producer;
  4. and the consuming task might have the following structure: 
  5. task Consumer;

  6. task body Consumer is
   Char : Character;
begin
   loop
      Buffer.Read(Char);
      exit when Char = ASCII.EOT;
      ... --  consume the character Char
   end loop;
end Consumer;
  7. The buffer object contains an internal pool of characters managed in a round-robin fashion. The pool has two indices, an In_Index denoting the space for the next input character and an Out_Index denoting the space for the next output character. 
  8. protected Buffer is
   entry Read (C : out Character);
   entry Write(C : in  Character);
private
   Pool      : String(1 .. 100);
   Count     : Natural := 0;
   In_Index, Out_Index : Positive := 1;
end Buffer;

  9. protected body Buffer is
   entry Write(C : in Character)
      when Count < Pool'Length is
   begin
      Pool(In_Index) := C;
      In_Index := (In_Index mod Pool'Length) + 1;
      Count    := Count + 1;
   end Write;

  10.    entry Read(C : out Character)
      when Count > 0 is
   begin
      C := Pool(Out_Index);
      Out_Index := (Out_Index mod Pool'Length) + 1;
      Count     := Count - 1;
   end Read;
end Buffer;

Program Structure and Compilation Issues

  1. The overall structure of programs and the facilities for separate compilation are described in this section. A program is a set of partitions, each of which may execute in a separate address space, possibly on a separate computer.
  2. As explained below, a partition is constructed from library units. Syntactically, the declaration of a library unit is a library_item, as is the body of a library unit. An implementation may support a concept of a program library (or simply, a "library"), which contains library_items and their subunits. Library units may be organized into a hierarchy of children, grandchildren, and so on.
  3. This section has two clauses: (see section Separate Compilation) discusses compile-time issues related to separate compilation. (see section Program Execution) discusses issues related to what is traditionally known as "link time" and "run time" -- building and executing partitions.

Separate Compilation

  1. A program unit is either a package, a task unit, a protected unit, a protected entry, a generic unit, or an explicitly declared subprogram other than an enumeration literal. Certain kinds of program units can be separately compiled. Alternatively, they can appear physically nested within other program units.
  2. The text of a program can be submitted to the compiler in one or more compilations. Each compilation is a succession of compilation_units. A compilation_unit contains either the declaration, the body, or a renaming of a program unit. The representation for a compilation is implementation-defined.
  3. A library unit is a separately compiled program unit, and is always a package, subprogram, or generic unit. Library units may have other (logically nested) library units as children, and may have other program units physically nested within them. A root library unit, together with its children and grandchildren and so on, form a subsystem.

    Implementation Permissions

  4. An implementation may impose implementation-defined restrictions on compilations that contain multiple compilation_units.

Compilation Units - Library Units

  1. A library_item is a compilation unit that is the declaration, body, or renaming of a library unit. Each library unit (except Standard) has a parent unit, which is a library package or generic library package. A library unit is a child of its parent unit. The root library units are the children of the predefined library package Standard.

    Syntax 

  2. compilation ::= {compilation_unit}

  3. compilation_unit ::=
     context_clause library_item
   | context_clause subunit

  4. library_item ::= [private] library_unit_declaration
   | library_unit_body
   | [private] library_unit_renaming_declaration

  5. library_unit_declaration ::=
     subprogram_declaration | package_declaration
   | generic_declaration    | generic_instantiation

  6. library_unit_renaming_declaration ::=
     package_renaming_declaration
   | generic_renaming_declaration
   | subprogram_renaming_declaration

  7. library_unit_body ::= subprogram_body | package_body

  8. parent_unit_name ::= name
  9. A library unit is a program unit that is declared by a library_item. When a program unit is a library unit, the prefix "library" is used to refer to it (or "generic library" if generic), as well as to its declaration and body, as in "library procedure", "library package_body", or "generic library package". The term compilation unit is used to refer to a compilation_unit. When the meaning is clear from context, the term is also used to refer to the library_item of a compilation_unit or to the proper_body of a subunit (that is, the compilation_unit without the context_clause and the separate (parent_unit_name)).
  10. The parent declaration of a library_item (and of the library unit) is the declaration denoted by the parent_unit_name, if any, of the defining_program_unit_name of the library_item. If there is no parent_unit_name, the parent declaration is the declaration of Standard, the library_item is a root library_item, and the library unit (renaming) is a root library unit (renaming). The declaration and body of Standard itself have no parent declaration. The parent unit of a library_item or library unit is the library unit declared by its parent declaration.
  11. The children of a library unit occur immediately within the declarative region of the declaration of the library unit. The ancestors of a library unit are itself, its parent, its parent's parent, and so on. (Standard is an ancestor of every library unit.) The descendant relation is the inverse of the ancestor relation.
  12. A library_unit_declaration or a library_unit_renaming_declaration is private if the declaration is immediately preceded by the reserved word private; it is otherwise public. A library unit is private or public according to its declaration. The public descendants of a library unit are the library unit itself, and the public descendants of its public children. Its other descendants are private descendants.

    Legality Rules

  13. The parent unit of a library_item shall be a library package or generic library package.
  14. If a defining_program_unit_name of a given declaration or body has a parent_unit_name, then the given declaration or body shall be a library_item. The body of a program unit shall be a library_item if and only if the declaration of the program unit is a library_item. In a library_unit_renaming_declaration, the (old) name shall denote a library_item.
  15. A parent_unit_name (which can be used within a defining_program_unit_name of a library_item and in the separate clause of a subunit), and each of its prefixes, shall not denote a renaming_declaration. On the other hand, a name that denotes a library_unit_renaming_declaration is allowed in a with_clause and other places where the name of a library unit is allowed.
  16. If a library package is an instance of a generic package, then every child of the library package shall either be itself an instance or be a renaming of a library unit.
  17. A child of a generic library package shall either be itself a generic unit or be a renaming of some other child of the same generic unit. The renaming of a child of a generic package shall occur only within the declarative region of the generic package.
  18. A child of a parent generic package shall be instantiated or renamed only within the declarative region of the parent generic.
  19. For each declaration or renaming of a generic unit as a child of some parent generic package, there is a corresponding declaration nested immediately within each instance of the parent. This declaration is visible only within the scope of a with_clause that mentions the child generic unit.
  20. A library subprogram shall not override a primitive subprogram.
  21. The defining name of a function that is a compilation unit shall not be an operator_symbol.

    Static Semantics

  22. A subprogram_renaming_declaration that is a library_unit_renaming_declaration is a renaming-as-declaration, not a renaming-as-body.
  23. There are two kinds of dependences among compilation units:
    1. The semantic dependences (see below) are the ones needed to check the compile-time rules across compilation unit boundaries; a compilation unit depends semantically on the other compilation units needed to determine its legality. The visibility rules are based on the semantic dependences.
    2. The elaboration dependences, see section Program Execution, determine the order of elaboration of library_items.
  1. A library_item depends semantically upon its parent declaration. A subunit depends semantically upon its parent body. A library_unit_body depends semantically upon the corresponding library_unit_declaration, if any. A compilation unit depends semantically upon each library_item mentioned in a with_clause of the compilation unit. In addition, if a given compilation unit contains an attribute_reference of a type defined in another compilation unit, then the given compilation unit depends semantically upon the other compilation unit. The semantic dependence relationship is transitive. NOTES
  2. (1) A simple program may consist of a single compilation unit. A compilation need not have any compilation units; for example, its text can consist of pragmas.
  3. (2) The designator of a library function cannot be an operator_symbol, but a nonlibrary renaming_declaration is allowed to rename a library function as an operator. Within a partition, two library subprograms are required to have distinct names and hence cannot overload each other. However, renaming_declarations are allowed to define overloaded names for such subprograms, and a locally declared subprogram is allowed to overload a library subprogram. The expanded name Standard.L can be used to denote a root library unit L (unless the declaration of Standard is hidden) since root library unit declarations occur immediately within the declarative region of package Standard.

    Examples

  4. Examples of library units: 
  5. package Rational_Numbers.IO is
   -- public child of Rational_Numbers, see section Package Specifications and Declarations
   procedure Put(R : in  Rational);
   procedure Get(R : out Rational);
end Rational_Numbers.IO;

  6. private procedure Rational_Numbers.Reduce(R : in out Rational);
-- private child of Rational_Numbers

  7. with Rational_Numbers.Reduce;   -- refer to a private child
package body Rational_Numbers is
   ...
end Rational_Numbers;

  8. with Rational_Numbers.IO; use Rational_Numbers;
with Ada.Text_io;  --  see section Text Input-Output
procedure Main is  -- a root library procedure
   R : Rational;
begin
   R := 5/3;       -- construct a rational number, see section Package Specifications and Declarations
   Ada.Text_IO.Put("The answer is: ");
   IO.Put(R);
   Ada.Text_IO.New_Line;
end Main;

  9. with Rational_Numbers.IO;
package Rational_IO renames Rational_Numbers.IO;
-- a library unit renaming declaration
  10. Each of the above library_items can be submitted to the compiler separately.

Context Clauses - With Clauses

  1. A context_clause is used to specify the library_items whose names are needed within a compilation unit.

    Syntax 

  2. context_clause ::= {context_item}

  3. context_item ::= with_clause | use_clause

  4. with_clause ::= with library_unit_name {, library_unit_name};

    Name Resolution Rules

  5. The scope of a with_clause that appears on a library_unit_declaration or library_unit_renaming_declaration consists of the entire declarative region of the declaration, which includes all children and subunits. The scope of a with_clause that appears on a body consists of the body, which includes all subunits.
  6. A library_item is mentioned in a with_clause if it is denoted by a library_unit_name or a prefix in the with_clause.
  7. Outside its own declarative region, the declaration or renaming of a library unit can be visible only within the scope of a with_clause that mentions it. The visibility of the declaration or renaming of a library unit otherwise follows from its placement in the environment.

    Legality Rules

  8. If a with_clause of a given compilation_unit mentions a private child of some library unit, then the given compilation_unit shall be either the declaration of a private descendant of that library unit or the body or subunit of a (public or private) descendant of that library unit. NOTES
  9. (3) A library_item mentioned in a with_clause of a compilation unit is visible within the compilation unit and hence acts just like an ordinary declaration. Thus, within a compilation unit that mentions its declaration, the name of a library package can be given in use_clauses and can be used to form expanded names, a library subprogram can be called, and instances of a generic library unit can be declared. If a child of a parent generic package is mentioned in a with_clause, then the corresponding declaration nested within each visible instance is visible within the compilation unit.

Subunits of Compilation Units

  1. Subunits are like child units, with these (important) differences: subunits support the separate compilation of bodies only (not declarations); the parent contains a body_stub to indicate the existence and place of each of its subunits; declarations appearing in the parent's body can be visible within the subunits.

    Syntax 

  2. body_stub ::=
     subprogram_body_stub
   | package_body_stub
   | task_body_stub
   | protected_body_stub

  3. subprogram_body_stub ::= subprogram_specification is separate;

  4. package_body_stub ::= package body defining_identifier is separate;

  5. task_body_stub ::= task body defining_identifier is separate;

  6. protected_body_stub ::=
   protected body defining_identifier is separate;

  7. subunit ::= separate (parent_unit_name) proper_body

    Legality Rules

  8. The parent body of a subunit is the body of the program unit denoted by its parent_unit_name. The term subunit is used to refer to a subunit and also to the proper_body of a subunit.
  9. The parent body of a subunit shall be present in the current environment, and shall contain a corresponding body_stub with the same defining_identifier as the subunit.
  10. A package_body_stub shall be the completion of a package_declaration or generic_package_declaration; a task_body_stub shall be the completion of a task_declaration; a protected_body_stub shall be the completion of a protected_declaration.
  11. In contrast, a subprogram_body_stub need not be the completion of a previous declaration, in which case the _stub declares the subprogram. If the _stub is a completion, it shall be the completion of a subprogram_declaration or generic_subprogram_declaration. The profile of a subprogram_body_stub that completes a declaration shall conform fully to that of the declaration.
  12. A subunit that corresponds to a body_stub shall be of the same kind (package_, subprogram_, task_, or protected_) as the body_stub. The profile of a subprogram_body subunit shall be fully conformant to that of the corresponding body_stub.
  13. A body_stub shall appear immediately within the declarative_part of a compilation unit body. This rule does not apply within an instance of a generic unit.
  14. The defining_identifiers of all body_stubs that appear immediately within a particular declarative_part shall be distinct.

    Post-Compilation Rules

  15. For each body_stub, there shall be a subunit containing the corresponding proper_body. NOTES
  16. (4) The rules in section The Compilation Process, say that a body_stub is equivalent to the corresponding proper_body. This implies:
    1. Visibility within a subunit is the visibility that would be obtained at the place of the corresponding body_stub (within the parent body) if the context_clause of the subunit were appended to that of the parent body.
    2. The effect of the elaboration of a body_stub is to elaborate the subunit.

Examples

  1. The package Parent is first written without subunits: 
  2. package Parent is
    procedure Inner;
end Parent;

  3. with Ada.Text_IO;
package body Parent is
    Variable : String := "Hello, there.";
    procedure Inner is
    begin
        Ada.Text_IO.Put_Line(Variable);
    end Inner;
end Parent;
  4. The body of procedure Inner may be turned into a subunit by rewriting the package body as follows (with the declaration of Parent remaining the same): 
  5. package body Parent is
    Variable : String := "Hello, there.";
    procedure Inner is separate;
end Parent;

  6. with Ada.Text_IO;
separate(Parent)
procedure Inner is
begin
    Ada.Text_IO.Put_Line(Variable);
end Inner;

The Compilation Process

  1. Each compilation unit submitted to the compiler is compiled in the context of an environment declarative_part (or simply, an environment), which is a conceptual declarative_part that forms the outermost declarative region of the context of any compilation. At run time, an environment forms the declarative_part of the body of the environment task of a partition, see section Program Execution.
  2. The declarative_items of the environment are library_items appearing in an order such that there are no forward semantic dependences. Each included subunit occurs in place of the corresponding stub. The visibility rules apply as if the environment were the outermost declarative region, except that with_clauses are needed to make declarations of library units visible, see section Context Clauses - With Clauses.
  3. The mechanisms for creating an environment and for adding and replacing compilation units within an environment are implementation defined.

    Name Resolution Rules

  4. If a library_unit_body that is a subprogram_body is submitted to the compiler, it is interpreted only as a completion if a library_unit_declaration for a subprogram or a generic subprogram with the same defining_program_unit_name already exists in the environment (even if the profile of the body is not type conformant with that of the declaration); otherwise the subprogram_body is interpreted as both the declaration and body of a library subprogram.

    Legality Rules

  5. When a compilation unit is compiled, all compilation units upon which it depends semantically shall already exist in the environment; the set of these compilation units shall be consistent in the sense that the new compilation unit shall not semantically depend (directly or indirectly) on two different versions of the same compilation unit, nor on an earlier version of itself.

    Implementation Permissions

  6. The implementation may require that a compilation unit be legal before inserting it into the environment.
  7. When a compilation unit that declares or renames a library unit is added to the environment, the implementation may remove from the environment any preexisting library_item with the same defining_program_unit_name. When a compilation unit that is a subunit or the body of a library unit is added to the environment, the implementation may remove from the environment any preexisting version of the same compilation unit. When a given compilation unit is removed from the environment, the implementation may also remove any compilation unit that depends semantically upon the given one. If the given compilation unit contains the body of a subprogram to which a pragma Inline applies, the implementation may also remove any compilation unit containing a call to that subprogram. NOTES
  8. (5) The rules of the language are enforced across compilation and compilation unit boundaries, just as they are enforced within a single compilation unit.
  9. (6) An implementation may support a concept of a library, which contains library_items. If multiple libraries are supported, the implementation has to define how a single environment is constructed when a compilation unit is submitted to the compiler. Naming conflicts between different libraries might be resolved by treating each library as the root of a hierarchy of child library units.
  10. (7) A compilation unit containing an instantiation of a separately compiled generic unit does not semantically depend on the body of the generic unit. Therefore, replacing the generic body in the environment does not result in the removal of the compilation unit containing the instantiation.

Pragmas and Program Units

  1. This subclause discusses pragmas related to program units, library units, and compilations.

    Name Resolution Rules

  2. Certain pragmas are defined to be program unit pragmas. A name given as the argument of a program unit pragma shall resolve to denote the declarations or renamings of one or more program units that occur immediately within the declarative region or compilation in which the pragma immediately occurs, or it shall resolve to denote the declaration of the immediately enclosing program unit (if any); the pragma applies to the denoted program unit(s). If there are no names given as arguments, the pragma applies to the immediately enclosing program unit.

    Legality Rules

  3. A program unit pragma shall appear in one of these places:
    1. At the place of a compilation_unit, in which case the pragma shall immediately follow in the same compilation (except for other pragmas) a library_unit_declaration that is a subprogram_declaration, generic_subprogram_declaration, or generic_instantiation, and the pragma shall have an argument that is a name denoting that declaration.
    2. Immediately within the declaration of a program unit and before any nested declaration, in which case the argument, if any, shall be a direct_name that denotes the immediately enclosing program unit declaration.
    3. At the place of a declaration other than the first, of a declarative_part or program unit declaration, in which case the pragma shall have an argument, which shall be a direct_name that denotes one or more of the following (and nothing else): a subprogram_declaration, a generic_subprogram_declaration, or a generic_instantiation, of the same declarative_part or program unit declaration.
  1. Certain program unit pragmas are defined to be library unit pragmas. The name, if any, in a library unit pragma shall denote the declaration of a library unit.

    Post-Compilation Rules

  2. Certain pragmas are defined to be configuration pragmas; they shall appear before the first compilation_unit of a compilation. They are generally used to select a partition-wide or system-wide option. The pragma applies to all compilation_units appearing in the compilation, unless there are none, in which case it applies to all future compilation_units compiled into the same environment.

    Implementation Permissions

  3. An implementation may place restrictions on configuration pragmas, so long as it allows them when the environment contains no library_items other than those of the predefined environment.

Environment-Level Visibility Rules

  1. The normal visibility rules do not apply within a parent_unit_name or a context_clause, nor within a pragma that appears at the place of a compilation unit. The special visibility rules for those contexts are given here.

    Static Semantics

  2. Within the parent_unit_name at the beginning of a library_item, and within a with_clause, the only declarations that are visible are those that are library_items of the environment, and the only declarations that are directly visible are those that are root library_items of the environment. Notwithstanding the rules of section Selected Components, an expanded name in a with_clause may consist of a prefix that denotes a generic package and a selector_name that denotes a child of that generic package (The child is necessarily a generic unit, see See section Compilation Units - Library Units).
  3. Within a use_clause or pragma that is within a context_clause, each library_item mentioned in a previous with_clause of the same context_clause is visible, and each root library_item so mentioned is directly visible. In addition, within such a use_clause, if a given declaration is visible or directly visible, each declaration that occurs immediately within the given declaration's visible part is also visible. No other declarations are visible or directly visible.
  4. Within the parent_unit_name of a subunit, library_items are visible as they are in the parent_unit_name of a library_item; in addition, the declaration corresponding to each body_stub in the environment is also visible.
  5. Within a pragma that appears at the place of a compilation unit, the immediately preceding library_item and each of its ancestors is visible. The ancestor root library_item is directly visible.

Program Execution

  1. An Ada program consists of a set of partitions, which can execute in parallel with one another, possibly in a separate address space, and possibly on a separate computer.

    Post-Compilation Rules

  2. A partition is a program or part of a program that can be invoked from outside the Ada implementation. For example, on many systems, a partition might be an executable file generated by the system linker. The user can explicitly assign library units to a partition. The assignment is done in an implementation-defined manner. The compilation units included in a partition are those of the explicitly assigned library units, as well as other compilation units needed by those library units. The compilation units needed by a given compilation unit are determined as follows (unless specified otherwise via an implementation-defined pragma, or by some other implementation-defined means):
    1. A compilation unit needs itself;
    2. If a compilation unit is needed, then so are any compilation units upon which it depends semantically;
    3. If a library_unit_declaration is needed, then so is any corresponding library_unit_body;
    4. If a compilation unit with stubs is needed, then so are any corresponding subunits.
  1. The user can optionally designate (in an implementation-defined manner) one subprogram as the main subprogram for the partition. A main subprogram, if specified, shall be a subprogram.
  2. Each partition has an anonymous environment task, which is an implicit outermost task whose execution elaborates the library_items of the environment declarative_part, and then calls the main subprogram, if there is one. A partition's execution is that of its tasks.
  3. The order of elaboration of library units is determined primarily by the elaboration dependences. There is an elaboration dependence of a given library_item upon another if the given library_item or any of its subunits depends semantically on the other library_item. In addition, if a given library_item or any of its subunits has a pragma Elaborate or Elaborate_All that mentions another library unit, then there is an elaboration dependence of the given library_item upon the body of the other library unit, and, for Elaborate_All only, upon each library_item needed by the declaration of the other library unit.
  4. The environment task for a partition has the following structure: 
  5. task Environment_Task;

  6. task body Environment_Task is
    ... (1) -- The environment declarative_part
            -- (that is, the sequence of library_items) goes here.
begin
    ... (2) -- Call the main subprogram, if there is one.
end Environment_Task;
  7. The environment declarative_part at (1) is a sequence of declarative_items consisting of copies of the library_items included in the partition. The order of elaboration of library_items is the order in which they appear in the environment declarative_part:
    1. The order of all included library_items is such that there are no forward elaboration dependences.
    2. Any included library_unit_declaration to which a pragma Elaborate_Body applies is immediately followed by its library_unit_body, if included.
    3. All library_items declared pure occur before any that are not declared pure.
    4. All preelaborated library_items occur before any that are not preelaborated.
  1. There shall be a total order of the library_items that obeys the above rules. The order is otherwise implementation defined.
  2. The full expanded names of the library units and subunits included in a given partition shall be distinct.
  3. The sequence_of_statements of the environment task (see (2) above) consists of either:
      1. A call to the main subprogram, if the partition has one. If the main subprogram has parameters, they are passed; where the actuals come from is implementation defined. What happens to the result of a main function is also implementation defined.
    1. or:
      1. A null_statement, if there is no main subprogram.
  1. The mechanisms for building and running partitions are implementation defined. These might be combined into one operation, as, for example, in dynamic linking, or "load-and-go" systems.

    Dynamic Semantics

  2. The execution of a program consists of the execution of a set of partitions. Further details are implementation defined. The execution of a partition starts with the execution of its environment task, ends when the environment task terminates, and includes the executions of all tasks of the partition. The execution of the (implicit) task_body of the environment task acts as a master for all other tasks created as part of the execution of the partition. When the environment task completes (normally or abnormally), it waits for the termination of all such tasks, and then finalizes any remaining objects of the partition.

    Bounded (Run-Time) Errors

  3. Once the environment task has awaited the termination of all other tasks of the partition, any further attempt to create a task (during finalization) is a bounded error, and may result in the raising of Program_Error either upon creation or activation of the task. If such a task is activated, it is not specified whether the task is awaited prior to termination of the environment task.

    Implementation Requirements

  4. The implementation shall ensure that all compilation units included in a partition are consistent with one another, and are legal according to the rules of the language.

    Implementation Permissions

  5. The kind of partition described in this clause is known as an active partition. An implementation is allowed to support other kinds of partitions, with implementation-defined semantics.
  6. An implementation may restrict the kinds of subprograms it supports as main subprograms. However, an implementation is required to support all main subprograms that are public parameterless library procedures.
  7. If the environment task completes abnormally, the implementation may abort any dependent tasks. NOTES
  8. (8) An implementation may provide inter-partition communication mechanism(s) via special packages and pragmas. Standard pragmas for distribution and methods for specifying inter-partition communication are defined in section Distributed Systems (normative). If no such mechanisms are provided, then each partition is isolated from all others, and behaves as a program in and of itself.
  9. (9) Partitions are not required to run in separate address spaces. For example, an implementation might support dynamic linking via the partition concept.
  10. (10) An order of elaboration of library_items that is consistent with the partial ordering defined above does not always ensure that each library_unit_body is elaborated before any other compilation unit whose elaboration necessitates that the library_unit_body be already elaborated (In particular, there is no requirement that the body of a library unit be elaborated as soon as possible after the library_unit_declaration is elaborated, unless the pragmas in subclause, see section Elaboration Control, are used).
  11. (11) A partition (active or otherwise) need not have a main subprogram. In such a case, all the work done by the partition would be done by elaboration of various library_items, and by tasks created by that elaboration. Passive partitions, which cannot have main subprograms, are defined in section Distributed Systems (normative).

Elaboration Control

  1. This subclause defines pragmas that help control the elaboration order of library_items.

    Syntax

  2. The form of a pragma Preelaborate is as follows: 
  3. pragma Preelaborate[(library_unit_name)];
    1. A pragma Preelaborate is a library unit pragma.

Legality Rules

  1. An elaborable construct is preelaborable unless its elaboration performs any of the following actions:
    1. The execution of a statement other than a null_statement.
    2. A call to a subprogram other than a static function.
    3. The evaluation of a primary that is a name of an object, unless the name is a static expression, or statically denotes a discriminant of an enclosing type.
    4. The creation of a default-initialized object (including a component) of a descendant of a private type, private extension, controlled type, task type, or protected type with entry_declarations; similarly the evaluation of an extension_aggregate with an ancestor subtype_mark denoting a subtype of such a type.
  1. A generic body is preelaborable only if elaboration of a corresponding instance body would not perform any such actions, presuming that the actual for each formal private type (or extension) is a private type (or extension), and the actual for each formal subprogram is a user-defined subprogram.
  2. If a pragma Preelaborate (or pragma Pure -- see below) applies to a library unit, then it is preelaborated. If a library unit is preelaborated, then its declaration, if any, and body, if any, are elaborated prior to all non-preelaborated library_items of the partition. All compilation units of a preelaborated library unit shall be preelaborable. In addition to the places where Legality Rules normally apply, see section Generic Instantiation, this rule applies also in the private part of an instance of a generic unit. In addition, all compilation units of a preelaborated library unit shall depend semantically only on compilation units of other preelaborated library units.

    Implementation Advice

  3. In an implementation, a type declared in a preelaborated package should have the same representation in every elaboration of a given version of the package, whether the elaborations occur in distinct executions of the same program, or in executions of distinct programs or partitions that include the given version.

    Syntax

  4. The form of a pragma Pure is as follows: 
  5. pragma Pure[(library_unit_name)];
    1. A pragma Pure is a library unit pragma.

      Legality Rules

  1. A pure library_item is a preelaborable library_item that does not contain the declaration of any variable or named access type, except within a subprogram, generic subprogram, task unit, or protected unit.
  2. A pragma Pure is used to declare that a library unit is pure. If a pragma Pure applies to a library unit, then its compilation units shall be pure, and they shall depend semantically only on compilation units of other library units that are declared pure.

    Implementation Permissions

  3. If a library unit is declared pure, then the implementation is permitted to omit a call on a library-level subprogram of the library unit if the results are not needed after the call. Similarly, it may omit such a call and simply reuse the results produced by an earlier call on the same subprogram, provided that none of the parameters are of a limited type, and the addresses and values of all by-reference actual parameters, and the values of all by-copy-in actual parameters, are the same as they were at the earlier call. This permission applies even if the subprogram produces other side effects when called.

    Syntax

  4. The form of a pragma Elaborate, Elaborate_All, or Elaborate_Body is as follows: 
  5. pragma Elaborate(library_unit_name{, library_unit_name});

  6. pragma Elaborate_All(library_unit_name{, library_unit_name});

  7. pragma Elaborate_Body[(library_unit_name)];
    1. A pragma Elaborate or Elaborate_All is only allowed within a context_clause.
    2. A pragma Elaborate_Body is a library unit pragma.

Legality Rules

  1. If a pragma Elaborate_Body applies to a declaration, then the declaration requires a completion (a body).

    Static Semantics

  2. A pragma Elaborate specifies that the body of the named library unit is elaborated before the current library_item. A pragma Elaborate_All specifies that each library_item that is needed by the named library unit declaration is elaborated before the current library_item. A pragma Elaborate_Body specifies that the body of the library unit is elaborated immediately after its declaration. NOTES
  3. (12) A preelaborated library unit is allowed to have non-preelaborable children.
  4. (13) A library unit that is declared pure is allowed to have impure children.

Exceptions

  1. This section defines the facilities for dealing with errors or other exceptional situations that arise during program execution. An exception represents a kind of exceptional situation; an occurrence of such a situation (at run time) is called an exception occurrence. To raise an exception is to abandon normal program execution so as to draw attention to the fact that the corresponding situation has arisen. Performing some actions in response to the arising of an exception is called handling the exception.
  2. An exception_declaration declares a name for an exception. An exception is raised initially either by a raise_statement or by the failure of a language-defined check. When an exception arises, control can be transferred to a user-provided exception_handler at the end of a handled_sequence_of_statements, or it can be propagated to a dynamically enclosing execution.

Exception Declarations

  1. An exception_declaration declares a name for an exception.

    Syntax

  2. exception_declaration ::= defining_identifier_list : exception;

    Static Semantics

  3. Each single exception_declaration declares a name for a different exception. If a generic unit includes an exception_declaration, the exception_declarations implicitly generated by different instantiations of the generic unit refer to distinct exceptions (but all have the same defining_identifier). The particular exception denoted by an exception name is determined at compilation time and is the same regardless of how many times the exception_declaration is elaborated.
  4. The predefined exceptions are the ones declared in the declaration of package Standard: Constraint_Error, Program_Error, Storage_Error, and Tasking_Error; one of them is raised when a language-defined check fails.

    Dynamic Semantics

  5. The elaboration of an exception_declaration has no effect.
  6. The execution of any construct raises Storage_Error if there is insufficient storage for that execution. The amount of storage needed for the execution of constructs is unspecified.

    Examples

  7. Examples of user-defined exception declarations: 
  8. Singular            : exception;
Error               : exception;
Overflow, Underflow : exception;

Exception Handlers

  1. The response to one or more exceptions is specified by an exception_handler.

    Syntax 

  2. handled_sequence_of_statements ::=
      sequence_of_statements
   [exception
      exception_handler
      {exception_handler}]

  3. exception_handler ::=
  when [choice_parameter_specification:]
    exception_choice {| exception_choice} =>
     sequence_of_statements

  4. choice_parameter_specification ::= defining_identifier

  5. exception_choice ::= exception_name | others

    Legality Rules

  6. A choice with an exception_name covers the named exception. A choice with others covers all exceptions not named by previous choices of the same handled_sequence_of_statements. Two choices in different exception_handlers of the same handled_sequence_of_statements shall not cover the same exception.
  7. A choice with others is allowed only for the last handler of a handled_sequence_of_statements and as the only choice of that handler.
  8. An exception_name of a choice shall not denote an exception declared in a generic formal package.

    Static Semantics

  9. A choice_parameter_specification declares a choice parameter, which is a constant object of type Exception_Occurrence, see section The Package Exceptions. During the handling of an exception occurrence, the choice parameter, if any, of the handler represents the exception occurrence that is being handled.

    Dynamic Semantics

  10. The execution of a handled_sequence_of_statements consists of the execution of the sequence_of_statements. The optional handlers are used to handle any exceptions that are propagated by the sequence_of_statements.

    Examples

  11. Example of an exception handler: 
  12. begin
   Open(File, In_File, "input.txt");   --  see section File Management
exception
   when E : Name_Error =>
      Put("Cannot open input file : ");
      Put_Line(Exception_Message(E));  --  see section The Package Exceptions
      raise;
end;

Raise Statements

  1. A raise_statement raises an exception.

    Syntax 

  2. raise_statement ::= raise [exception_name];

    Legality Rules

  3. The name, if any, in a raise_statement shall denote an exception. A raise_statement with no exception_name (that is, a re-raise statement) shall be within a handler, but not within a body enclosed by that handler.

    Dynamic Semantics

  4. To raise an exception is to raise a new occurrence of that exception, as explained in section Exception Handling. For the execution of a raise_statement with an exception_name, the named exception is raised. For the execution of a re-raise statement, the exception occurrence that caused transfer of control to the innermost enclosing handler is raised again.

    Examples

  5. Examples of raise statements: 
  6. raise Ada.IO_Exceptions.Name_Error;  --  see section Exceptions in Input-Output

  7. raise;
--  re-raise the current exception

Exception Handling

  1. When an exception occurrence is raised, normal program execution is abandoned and control is transferred to an applicable exception_handler, if any. To handle an exception occurrence is to respond to the exceptional event. To propagate an exception occurrence is to raise it again in another context; that is, to fail to respond to the exceptional event in the present context.

    Dynamic Semantics

  2. Within a given task, if the execution of construct a is defined by this International Standard to consist (in part) of the execution of construct b, then while b is executing, the execution of a is said to dynamically enclose the execution of b. The innermost dynamically enclosing execution of a given execution is the dynamically enclosing execution that started most recently.
  3. When an exception occurrence is raised by the execution of a given construct, the rest of the execution of that construct is abandoned; that is, any portions of the execution that have not yet taken place are not performed. The construct is first completed, and then left, as explained in section Completion and Finalization. Then:
    1. If the construct is a task_body, the exception does not propagate further;
    2. If the construct is the sequence_of_statements of a handled_sequence_of_statements that has a handler with a choice covering the exception, the occurrence is handled by that handler;
    3. Otherwise, the occurrence is propagated to the innermost dynamically enclosing execution, which means that the occurrence is raised again in that context.
  1. When an occurrence is handled by a given handler, the choice_parameter_specification, if any, is first elaborated, which creates the choice parameter and initializes it to the occurrence. Then, the sequence_of_statements of the handler is executed; this execution replaces the abandoned portion of the execution of the sequence_of_statements. NOTES
  2. (1) Note that exceptions raised in a declarative_part of a body are not handled by the handlers of the handled_sequence_of_statements of that body.

The Package Exceptions

Static Semantics

  1. The following language-defined library package exists: 
  2. package Ada.Exceptions is
    type Exception_Id is private;
    Null_Id : constant Exception_Id;
    function Exception_Name(Id : Exception_Id) return String;

  3.     type Exception_Occurrence is limited private;
    type Exception_Occurrence_Access is
      access all Exception_Occurrence;
    Null_Occurrence : constant Exception_Occurrence;

  4.     procedure Raise_Exception
      (E       : in Exception_Id;
       Message : in String := "");
    function Exception_Message(X : Exception_Occurrence)
      return String;
    procedure Reraise_Occurrence(X : in Exception_Occurrence);

  5.     function Exception_Identity(X : Exception_Occurrence)
      return Exception_Id;
    function Exception_Name(X : Exception_Occurrence)
      return String;
    --  Same as Exception_Name(Exception_Identity(X)).
    function Exception_Information(X : Exception_Occurrence)
      return String;

  6.     procedure Save_Occurrence(Target : out Exception_Occurrence;
                              Source : in Exception_Occurrence);
    function Save_Occurrence(Source : Exception_Occurrence)
                             return Exception_Occurrence_Access;
private
   ... -- not specified by the language
end Ada.Exceptions;
  7. Each distinct exception is represented by a distinct value of type Exception_Id. Null_Id does not represent any exception, and is the default initial value of type Exception_Id. Each occurrence of an exception is represented by a value of type Exception_Occurrence. Null_Occurrence does not represent any exception occurrence, and is the default initial value of type Exception_Occurrence.
  8. For a prefix E that denotes an exception, the following attribute is defined:
  9. E'Identity 
    E'Identity returns the unique identity of the exception. The
type of this attribute is Exception_Id.
  10. Raise_Exception raises a new occurrence of the identified exception. In this case, Exception_Message returns the Message parameter of Raise_Exception. For a raise_statement with an exception_name, Exception_Message returns implementation-defined information about the exception occurrence. Reraise_Occurrence reraises the specified exception occurrence.
  11. Exception_Identity returns the identity of the exception of the occurrence.
  12. The Exception_Name functions return the full expanded name of the exception, in upper case, starting with a root library unit. For an exception declared immediately within package Standard, the defining_identifier is returned. The result is implementation defined if the exception is declared within an unnamed block_statement.
  13. Exception_Information returns implementation-defined information about the exception occurrence.
  14. Raise_Exception and Reraise_Occurrence have no effect in the case of Null_Id or Null_Occurrence. Exception_Message, Exception_Identity, Exception_Name, and Exception_Information raise Constraint_Error for a Null_Id or Null_Occurrence.
  15. The Save_Occurrence procedure copies the Source to the Target. The Save_Occurrence function uses an allocator of type Exception_Occurrence_Access to create a new object, copies the Source to this new object, and returns an access value designating this new object; the result may be deallocated using an instance of Unchecked_Deallocation.

    Implementation Requirements

  16. The implementation of the Write attribute, see section Stream-Oriented Attributes, of Exception_Occurrence shall support writing a representation of an exception occurrence to a stream; the implementation of the Read attribute of Exception_Occurrence shall support reconstructing an exception occurrence from a stream (including one written in a different partition).

    Implementation Permissions

  17. An implementation of Exception_Name in a space-constrained environment may return the defining_identifier instead of the full expanded name.
  18. The string returned by Exception_Message may be truncated (to no less than 200 characters) by the Save_Occurrence procedure (not the function), the Reraise_Occurrence procedure, and the re-raise statement.

    Implementation Advice

  19. Exception_Message (by default) and Exception_Information should produce information useful for debugging. Exception_Message should be short (about one line), whereas Exception_Information can be long. Exception_Message should not include the Exception_Name. Exception_Information should include both the Exception_Name and the Exception_Message.

Example of Exception Handling

Examples

  1. Exception handling may be used to separate the detection of an error from the response to that error: 
  2. with Ada.Exceptions;
use Ada;
package File_System is
    type File_Handle is limited private;

  3.     File_Not_Found : exception;
    procedure Open(F : in out File_Handle; Name : String);
    --  raises File_Not_Found if named file does not exist

  4.     End_Of_File : exception;
    procedure Read(F : in out File_Handle; Data : out Data_Type);
    --  raises End_Of_File if the file is not open

  5.     ...
end File_System;

  6. package body File_System is
    procedure Open(F : in out File_Handle; Name : String) is
    begin
        if File_Exists(Name) then
            ...
        else
            Exceptions.Raise_Exception
              (File_Not_Found'Identity,
               "File not found: " & Name & ".");
        end if;
    end Open;

  7.     procedure Read(F : in out File_Handle; Data : out Data_Type) is
    begin
        if F.Current_Position <= F.Last_Position then
            ...
        else
            raise End_Of_File;
        end if;
    end Read;

  8.     ...

  9. end File_System;

  10. with Ada.Text_IO;
with Ada.Exceptions;
with File_System; use File_System;
use Ada;
procedure Main is
begin
    ... -- call operations in File_System
exception
    when End_Of_File =>
        Close(Some_File);
    when Not_Found_Error : File_Not_Found =>
        Text_IO.Put_Line
          (Exceptions.Exception_Message(Not_Found_Error));
    when The_Error : others =>
        Text_IO.Put_Line("Unknown error:");
        if Verbosity_Desired then
            Text_IO.Put_Line(Exceptions.Exception_Information
              (The_Error));
        else
            Text_IO.Put_Line(Exceptions.Exception_Name
              (The_Error));
            Text_IO.Put_Line(Exceptions.Exception_Message
              (The_Error));
        end if;
        raise;
end Main;
  11. In the above example, the File_System package contains information about detecting certain exceptional situations, but it does not specify how to handle those situations. Procedure Main specifies how to handle them; other clients of File_System might have different handlers, even though the exceptional situations arise from the same basic causes.

Suppressing Checks

  1. A pragma Suppress gives permission to an implementation to omit certain language-defined checks.
  2. A language-defined check (or simply, a "check") is one of the situations defined by this International Standard that requires a check to be made at run time to determine whether some condition is true. A check fails when the condition being checked is false, causing an exception to be raised.

    Syntax

  3. The form of a pragma Suppress is as follows: 
  4. pragma Suppress(identifier [, [On =>] name]);
    1. A pragma Suppress is allowed only immediately within a declarative_part, immediately within a package_specification, or as a configuration pragma.

Legality Rules

  1. The identifier shall be the name of a check. The name (if present) shall statically denote some entity.
  2. For a pragma Suppress that is immediately within a package_specification and includes a name, the name shall denote an entity (or several overloaded subprograms) declared immediately within the package_specification.

    Static Semantics

  3. A pragma Suppress gives permission to an implementation to omit the named check from the place of the pragma to the end of the innermost enclosing declarative region, or, if the pragma is given in a package_specification and includes a name, to the end of the scope of the named entity. If the pragma includes a name, the permission applies only to checks performed on the named entity, or, for a subtype, on objects and values of its type. Otherwise, the permission applies to all entities. If permission has been given to suppress a given check, the check is said to be suppressed.
  4. The following are the language-defined checks:
    1. The following checks correspond to situations in which the exception Constraint_Error is raised upon failure.
      1. Access_Check 
        When evaluating a dereference (explicit or
implicit), check that the value of the name is
not null. When passing an actual parameter to a
formal access parameter, check that the value of
the actual parameter is not null.
      2. Discriminant_Check 
        Check that the discriminants of a composite value
have the values imposed by a discriminant
constraint. Also, when accessing a record
component, check that it exists for the current
discriminant values.
      3. Division_Check 
        Check that the second operand is not zero for the
operations /, rem and mod.
      4. Index_Check 
        Check that the bounds of an array value are equal
to the corresponding bounds of an index
constraint. Also, when accessing a component of
an array object, check for each dimension that
the given index value belongs to the range
defined by the bounds of the array object. Also,
when accessing a slice of an array object, check
that the given discrete range is compatible with
the range defined by the bounds of the array
object.
      5. Length_Check 
        Check that two arrays have matching components,
in the case of array subtype conversions, and
logical operators for arrays of boolean
components.
      6. Overflow_Check 
        Check that a scalar value is within the base
range of its type, in cases where the
implementation chooses to raise an exception
instead of returning the correct mathematical
result.
      7. Range_Check 
        Check that a scalar value satisfies a range
constraint. Also, for the elaboration of a
subtype_indication, check that the constraint (if
present) is compatible with the subtype denoted
by the subtype_mark. Also, for an aggregate,
check that an index or discriminant value belongs
to the corresponding subtype. Also, check that
when the result of an operation yields an array,
the value of each component belongs to the
component subtype.
      8. Tag_Check 
        Check that operand tags in a dispatching call are
all equal. Check for the correct tag on tagged
type conversions, for an assignment_statement,
and when returning a tagged limited object from a
function.
    1. The following checks correspond to situations in which the exception Program_Error is raised upon failure.
      1. Elaboration_Check 
        When a subprogram or protected entry is called, a
task activation is accomplished, or a generic
instantiation is elaborated, check that the body
of the corresponding unit has already been
elaborated.
      2. Accessibility_Check 
        Check the accessibility level of an entity or
view.
    1. The following check corresponds to situations in which the exception Storage_Error is raised upon failure.
      1. Storage_Check 
        Check that evaluation of an allocator does not
require more space than is available for a
storage pool. Check that the space available for
a task or subprogram has not been exceeded.
    1. The following check corresponds to all situations in which any predefined exception is raised.
      1. All_Checks 
        Represents the union of all checks; suppressing
All_Checks suppresses all checks.

Erroneous Execution

  1. If a given check has been suppressed, and the corresponding error situation occurs, the execution of the program is erroneous.

    Implementation Permissions

  2. An implementation is allowed to place restrictions on Suppress pragmas. An implementation is allowed to add additional check names, with implementation-defined semantics. When Overflow_Check has been suppressed, an implementation may also suppress an unspecified subset of the Range_Checks.

    Implementation Advice

  3. The implementation should minimize the code executed for checks that have been suppressed. NOTES
  4. (2) There is no guarantee that a suppressed check is actually removed; hence a pragma Suppress should be used only for efficiency reasons.

    Examples

  5. Examples of suppressing checks: 
  6. pragma Suppress(Range_Check);
pragma Suppress(Index_Check, On => Table);

Exceptions and Optimization

  1. This clause gives permission to the implementation to perform certain "optimizations" that do not necessarily preserve the canonical semantics.

    Dynamic Semantics

  2. The rest of this International Standard (outside this clause) defines the canonical semantics of the language. The canonical semantics of a given (legal) program determines a set of possible external effects that can result from the execution of the program with given inputs.
  3. As explained in section Conformity of an Implementation with the Standard, the external effect of a program is defined in terms of its interactions with its external environment. Hence, the implementation can perform any internal actions whatsoever, in any order or in parallel, so long as the external effect of the execution of the program is one that is allowed by the canonical semantics, or by the rules of this clause.

    Implementation Permissions

  4. The following additional permissions are granted to the implementation:
    1. An implementation need not always raise an exception when a language-defined check fails. Instead, the operation that failed the check can simply yield an undefined result. The exception need be raised by the implementation only if, in the absence of raising it, the value of this undefined result would have some effect on the external interactions of the program. In determining this, the implementation shall not presume that an undefined result has a value that belongs to its subtype, nor even to the base range of its type, if scalar. Having removed the raise of the exception, the canonical semantics will in general allow the implementation to omit the code for the check, and some or all of the operation itself.
    2. If an exception is raised due to the failure of a language-defined check, then upon reaching the corresponding exception_handler (or the termination of the task, if none), the external interactions that have occurred need reflect only that the exception was raised somewhere within the execution of the sequence_of_statements with the handler (or the task_body), possibly earlier (or later if the interactions are independent of the result of the checked operation) than that defined by the canonical semantics, but not within the execution of some abort-deferred operation or independent subprogram that does not dynamically enclose the execution of the construct whose check failed. An independent subprogram is one that is defined outside the library unit containing the construct whose check failed, and has no Inline pragma applied to it. Any assignment that occurred outside of such abort-deferred operations or independent subprograms can be disrupted by the raising of the exception, causing the object or its parts to become abnormal, and certain subsequent uses of the object to be erroneous, as explained in section Data Validity.
    NOTES
  1. (3) The permissions granted by this clause can have an effect on the semantics of a program only if the program fails a language-defined check.

Generic Units

  1. A generic unit is a program unit that is either a generic subprogram or a generic package. A generic unit is a template, which can be parameterized, and from which corresponding (nongeneric) subprograms or packages can be obtained. The resulting program units are said to be instances of the original generic unit.
  2. A generic unit is declared by a generic_declaration. This form of declaration has a generic_formal_part declaring any generic formal parameters. An instance of a generic unit is obtained as the result of a generic_instantiation with appropriate generic actual parameters for the generic formal parameters. An instance of a generic subprogram is a subprogram. An instance of a generic package is a package.
  3. Generic units are templates. As templates they do not have the properties that are specific to their nongeneric counterparts. For example, a generic subprogram can be instantiated but it cannot be called. In contrast, an instance of a generic subprogram is a (nongeneric) subprogram; hence, this instance can be called but it cannot be used to produce further instances.

Generic Declarations

  1. A generic_declaration declares a generic unit, which is either a generic subprogram or a generic package. A generic_declaration includes a generic_formal_part declaring any generic formal parameters. A generic formal parameter can be an object; alternatively (unlike a parameter of a subprogram), it can be a type, a subprogram, or a package.

    Syntax 

  2. generic_declaration ::=
   generic_subprogram_declaration | generic_package_declaration

  3. generic_subprogram_declaration ::=
   generic_formal_part subprogram_specification;

  4. generic_package_declaration ::=
   generic_formal_part package_specification;

  5. generic_formal_part ::=
   generic {generic_formal_parameter_declaration | use_clause}

  6. generic_formal_parameter_declaration ::=
      formal_object_declaration
    | formal_type_declaration
    | formal_subprogram_declaration
    | formal_package_declaration
    1. The only form of subtype_indication allowed within a generic_formal_part is a subtype_mark (that is, the subtype_indication shall not include an explicit constraint). The defining name of a generic subprogram shall be an identifier (not an operator_symbol).

Static Semantics

  1. A generic_declaration declares a generic unit -- a generic package, generic procedure or generic function, as appropriate.
  2. An entity is a generic formal entity if it is declared by a generic_formal_parameter_declaration. "Generic formal," or simply "formal," is used as a prefix in referring to objects, subtypes (and types), functions, procedures and packages, that are generic formal entities, as well as to their respective declarations. Examples: "generic formal procedure" or a "formal integer type declaration."

    Dynamic Semantics

  3. The elaboration of a generic_declaration has no effect. NOTES
  4. (1) Outside a generic unit a name that denotes the generic_declaration denotes the generic unit. In contrast, within the declarative region of the generic unit, a name that denotes the generic_declaration denotes the current instance.
  5. (2) Within a generic subprogram_body, the name of this program unit acts as the name of a subprogram. Hence this name can be overloaded, and it can appear in a recursive call of the current instance. For the same reason, this name cannot appear after the reserved word new in a (recursive) generic_instantiation.
  6. (3) A default_expression or default_name appearing in a generic_formal_part is not evaluated during elaboration of the generic_formal_part; instead, it is evaluated when used. (The usual visibility rules apply to any name used in a default: the denoted declaration therefore has to be visible at the place of the expression.)

    Examples

  7. Examples of generic formal parts: 
  8. generic     --  parameterless

  9. generic
    Size : Natural;  --  formal object

  10. generic
   Length : Integer := 200;
   --  formal object with a default expression

  11.    Area : Integer := Length*Length;
   --  formal object with a default expression

  12. generic
   type Item  is private;                        -- formal type
   type Index is (<>);                           -- formal type
   type Row   is array(Index range <>) of Item;  -- formal type
   with function "<"(X, Y : Item) return Boolean;
   --  formal subprogram
  13. Examples of generic declarations declaring generic subprograms Exchange and Squaring: 
  14. generic
   type Elem is private;
procedure Exchange(U, V : in out Elem);

  15. generic
   type Item is private;
   with function "*"(U, V : Item) return Item is <>;
function Squaring(X : Item) return Item;
  16. Example of a generic declaration declaring a generic package: 
  17. generic
   type Item   is private;
   type Vector is array (Positive range <>) of Item;
   with function Sum(X, Y : Item) return Item;
package On_Vectors is
   function Sum  (A, B : Vector) return Vector;
   function Sigma(A    : Vector) return Item;
   Length_Error : exception;
end On_Vectors;

Generic Bodies

  1. The body of a generic unit (a generic body) is a template for the instance bodies. The syntax of a generic body is identical to that of a nongeneric body.

    Dynamic Semantics

  2. The elaboration of a generic body has no other effect than to establish that the generic unit can from then on be instantiated without failing the Elaboration_Check. If the generic body is a child of a generic package, then its elaboration establishes that each corresponding declaration nested in an instance of the parent, see section Compilation Units - Library Units, can from then on be instantiated without failing the Elaboration_Check. NOTES
  3. (4) The syntax of generic subprograms implies that a generic subprogram body is always the completion of a declaration.

    Examples

  4. Example of a generic procedure body: 
  5. procedure Exchange(U, V : in out Elem) is  --  see section Generic Declarations
   T : Elem;  --  the generic formal type
begin
   T := U;
   U := V;
   V := T;
end Exchange;
  6. Example of a generic function body: 
  7. function Squaring(X : Item) return Item is  --  see section Generic Declarations
begin
   return X*X;  --  the formal operator "*"
end Squaring;
  8. Example of a generic package body: 
  9. package body On_Vectors is  --  see section Generic Declarations

  10.    function Sum(A, B : Vector) return Vector is
      Result : Vector(A'Range); --  the formal type Vector
      Bias   : constant Integer := B'First - A'First;
   begin
      if A'Length /= B'Length then
         raise Length_Error;
      end if;

  11.       for N in A'Range loop
         Result(N) := Sum(A(N), B(N + Bias));
         --  the formal function Sum
      end loop;
      return Result;
   end Sum;

  12.    function Sigma(A : Vector) return Item is
      Total : Item := A(A'First); --  the formal type Item
   begin
      for N in A'First + 1 .. A'Last loop
         Total := Sum(Total, A(N)); --  the formal function Sum
      end loop;
      return Total;
   end Sigma;
end On_Vectors;

Generic Instantiation

  1. An instance of a generic unit is declared by a generic_instantiation.

    Syntax 

  2. generic_instantiation ::=
     package defining_program_unit_name is
       new generic_package_name [generic_actual_part];
   | procedure defining_program_unit_name is
       new generic_procedure_name [generic_actual_part];
   | function defining_designator is
       new generic_function_name [generic_actual_part];

  3. generic_actual_part ::=
   (generic_association {, generic_association})

  4. generic_association ::=
   [generic_formal_parameter_selector_name =>]
      explicit_generic_actual_parameter

  5. explicit_generic_actual_parameter ::= expression | variable_name
   | subprogram_name | entry_name | subtype_mark
   | package_instance_name
    1. A generic_association is named or positional according to whether or not the generic_formal_parameter_selector_name is specified. Any positional associations shall precede any named associations.
  1. The generic actual parameter is either the explicit_generic_actual_parameter given in a generic_parameter_association for each formal, or the corresponding default_expression or default_name if no generic_parameter_association is given for the formal. When the meaning is clear from context, the term "generic actual," or simply "actual," is used as a synonym for "generic actual parameter" and also for the view denoted by one, or the value of one.

    Legality Rules

  2. In a generic_instantiation for a particular kind of program unit (package, procedure, or function), the name shall denote a generic unit of the corresponding kind (generic package, generic procedure, or generic function, respectively).
  3. The generic_formal_parameter_selector_name of a generic_association shall denote a generic_formal_parameter_declaration of the generic unit being instantiated. If two or more formal subprograms have the same defining name, then named associations are not allowed for the corresponding actuals.
  4. A generic_instantiation shall contain at most one generic_association for each formal. Each formal without an association shall have a default_expression or subprogram_default.
  5. In a generic unit Legality Rules are enforced at compile time of the generic_declaration and generic body, given the properties of the formals. In the visible part and formal part of an instance, Legality Rules are enforced at compile time of the generic_instantiation, given the properties of the actuals. In other parts of an instance, Legality Rules are not enforced; this rule does not apply when a given rule explicitly specifies otherwise.

    Static Semantics

  6. A generic_instantiation declares an instance; it is equivalent to the instance declaration (a package_declaration or subprogram_declaration) immediately followed by the instance body, both at the place of the instantiation.
  7. The instance is a copy of the text of the template. Each use of a formal parameter becomes (in the copy) a use of the actual, as explained below. An instance of a generic package is a package, that of a generic procedure is a procedure, and that of a generic function is a function.
  8. The interpretation of each construct within a generic declaration or body is determined using the overloading rules when that generic declaration or body is compiled. In an instance, the interpretation of each (copied) construct is the same, except in the case of a name that denotes the generic_declaration or some declaration within the generic unit; the corresponding name in the instance then denotes the corresponding copy of the denoted declaration. The overloading rules do not apply in the instance.
  9. In an instance, a generic_formal_parameter_declaration declares a view whose properties are identical to those of the actual, except as specified in section Formal Objects, and section Formal Subprograms. Similarly, for a declaration within a generic_formal_parameter_declaration, the corresponding declaration in an instance declares a view whose properties are identical to the corresponding declaration within the declaration of the actual.
  10. Implicit declarations are also copied, and a name that denotes an implicit declaration in the generic denotes the corresponding copy in the instance. However, for a type declared within the visible part of the generic, a whole new set of primitive subprograms is implicitly declared for use outside the instance, and may differ from the copied set if the properties of the type in some way depend on the properties of some actual type specified in the instantiation. For example, if the type in the generic is derived from a formal private type, then in the instance the type will inherit subprograms from the corresponding actual type.
  11. These new implicit declarations occur immediately after the type declaration in the instance, and override the copied ones. The copied ones can be called only from within the instance; the new ones can be called only from outside the instance, although for tagged types, the body of a new one can be executed by a call to an old one.
  12. In the visible part of an instance, an explicit declaration overrides an implicit declaration if they are homographs, as described in section Visibility. On the other hand, an explicit declaration in the private part of an instance overrides an implicit declaration in the instance, only if the corresponding explicit declaration in the generic overrides a corresponding implicit declaration in the generic. Corresponding rules apply to the other kinds of overriding described in section Visibility.

    Post-Compilation Rules

  13. Recursive generic instantiation is not allowed in the following sense: if a given generic unit includes an instantiation of a second generic unit, then the instance generated by this instantiation shall not include an instance of the first generic unit (whether this instance is generated directly, or indirectly by intermediate instantiations).

    Dynamic Semantics

  14. For the elaboration of a generic_instantiation, each generic_association is first evaluated. If a default is used, an implicit generic_association is assumed for this rule. These evaluations are done in an arbitrary order, except that the evaluation for a default actual takes place after the evaluation for another actual if the default includes a name that denotes the other one. Finally, the instance declaration and body are elaborated.
  15. For the evaluation of a generic_association the generic actual parameter is evaluated. Additional actions are performed in the case of a formal object of mode in, see section Formal Objects. NOTES
  16. (5) If a formal type is not tagged, then the type is treated as an untagged type within the generic body. Deriving from such a type in a generic body is permitted; the new type does not get a new tag value, even if the actual is tagged. Overriding operations for such a derived type cannot be dispatched to from outside the instance.

    Examples

  17. Examples of generic instantiations, see section Generic Declarations 
  18. procedure Swap is new Exchange(Elem => Integer);
procedure Swap is new Exchange(Character);
--  Swap is overloaded
function Square is new Squaring(Integer);
--  "*" of Integer used by default
function Square is new Squaring
  (Item => Matrix, "*" => Matrix_Product);
function Square is new Squaring
  (Matrix, Matrix_Product); -- same as previous

  19. package Int_Vectors is new On_Vectors(Integer, Table, "+");
  20. Examples of uses of instantiated units: 
  21. Swap(A, B);
A := Square(A);

  22. T : Table(1 .. 5) := (10, 20, 30, 40, 50);
N : Integer := Int_Vectors.Sigma(T);
--  150 (see section Generic Bodies, for the body of Sigma)

  23. use Int_Vectors;
M : Integer := Sigma(T);  --  150

Formal Objects

  1. A generic formal object can be used to pass a value or variable to a generic unit.

    Syntax 

  2. formal_object_declaration ::=
   defining_identifier_list : mode subtype_mark
     [:= default_expression];

    Name Resolution Rules

  3. The expected type for the default_expression, if any, of a formal object is the type of the formal object.
  4. For a generic formal object of mode in, the expected type for the actual is the type of the formal.
  5. For a generic formal object of mode in out, the type of the actual shall resolve to the type of the formal.

    Legality Rules

  6. If a generic formal object has a default_expression, then the mode shall be in (either explicitly or by default); otherwise, its mode shall be either in or in out.
  7. For a generic formal object of mode in, the actual shall be an expression. For a generic formal object of mode in out, the actual shall be a name that denotes a variable for which renaming is allowed (see section Object Renaming Declarations).
  8. The type of a generic formal object of mode in shall be nonlimited.

    Static Semantics

  9. A formal_object_declaration declares a generic formal object. The default mode is in. For a formal object of mode in, the nominal subtype is the one denoted by the subtype_mark in the declaration of the formal. For a formal object of mode in out, its type is determined by the subtype_mark in the declaration; its nominal subtype is nonstatic, even if the subtype_mark denotes a static subtype.
  10. In an instance, a formal_object_declaration of mode in declares a new stand-alone constant object whose initialization expression is the actual, whereas a formal_object_declaration of mode in out declares a view whose properties are identical to those of the actual.

    Dynamic Semantics

  11. For the evaluation of a generic_association for a formal object of mode in, a constant object is created, the value of the actual parameter is converted to the nominal subtype of the formal object, and assigned to the object, including any value adjustment -- see section User-Defined Assignment and Finalization. NOTES
  12. (6) The constraints that apply to a generic formal object of mode in out are those of the corresponding generic actual parameter (not those implied by the subtype_mark that appears in the formal_object_declaration). Therefore, to avoid confusion, it is recommended that the name of a first subtype be used for the declaration of such a formal object.

Formal Types

  1. A generic formal subtype can be used to pass to a generic unit a subtype whose type is in a certain class of types.

    Syntax 

  2. formal_type_declaration ::=
   type defining_identifier[discriminant_part] is
     formal_type_definition;

  3. formal_type_definition ::=
     formal_private_type_definition
   | formal_derived_type_definition
   | formal_discrete_type_definition
   | formal_signed_integer_type_definition
   | formal_modular_type_definition
   | formal_floating_point_definition
   | formal_ordinary_fixed_point_definition
   | formal_decimal_fixed_point_definition
   | formal_array_type_definition
   | formal_access_type_definition

    Legality Rules

  4. For a generic formal subtype, the actual shall be a subtype_mark; it denotes the (generic) actual subtype.

    Static Semantics

  5. A formal_type_declaration declares a (generic) formal type, and its first subtype, the (generic) formal subtype.
  6. The form of a formal_type_definition determines a class to which the formal type belongs. For a formal_private_type_definition the reserved words tagged and limited indicate the class, see section Formal Private and Derived Types. For a formal_derived_type_definition the class is the derivation class rooted at the ancestor type. For other formal types, the name of the syntactic category indicates the class; a formal_discrete_type_definition defines a discrete type, and so on.

    Legality Rules

  7. The actual type shall be in the class determined for the formal.

    Static Semantics

  8. The formal type also belongs to each class that contains the determined class. The primitive subprograms of the type are as for any type in the determined class. For a formal type other than a formal derived type, these are the predefined operators of the type; they are implicitly declared immediately after the declaration of the formal type. In an instance, the copy of such an implicit declaration declares a view of the predefined operator of the actual type, even if this operator has been overridden for the actual type. The rules specific to formal derived types are given in section Formal Private and Derived Types. NOTES
  9. (7) Generic formal types, like all types, are not named. Instead, a name can denote a generic formal subtype. Within a generic unit, a generic formal type is considered as being distinct from all other (formal or nonformal) types.
  10. (8) A discriminant_part is allowed only for certain kinds of types, and therefore only for certain kinds of generic formal types (see section Discriminants).

    Examples

  11. Examples of generic formal types: 
  12. type Item is private;
type Buffer(Length : Natural) is limited private;

  13. type Enum  is (<>);
type Int   is range <>;
type Angle is delta <>;
type Mass  is digits <>;

  14. type Table is array (Enum) of Item;
  15. Example of a generic formal part declaring a formal integer type: 
  16. generic
   type Rank is range <>;
   First  : Rank := Rank'First;
   Second : Rank := First + 1;
   --  the operator "+" of the type Rank

Formal Private and Derived Types

  1. The class determined for a formal private type can be either limited or nonlimited, and either tagged or untagged; no more specific class is known for such a type. The class determined for a formal derived type is the derivation class rooted at the ancestor type.

    Syntax 

  2. formal_private_type_definition ::=
   [[abstract] tagged] [limited] private

  3. formal_derived_type_definition ::=
   [abstract] new subtype_mark [with private]

    Legality Rules

  4. If a generic formal type declaration has a known_discriminant_part, then it shall not include a default_expression for a discriminant.
  5. The ancestor subtype of a formal derived type is the subtype denoted by the subtype_mark of the formal_derived_type_definition. For a formal derived type declaration, the reserved words with private shall appear if and only if the ancestor type is a tagged type; in this case the formal derived type is a private extension of the ancestor type and the ancestor shall not be a class-wide type. Similarly, the optional reserved word abstract shall appear only if the ancestor type is a tagged type.
  6. If the formal subtype is definite, then the actual subtype shall also be definite.
  7. For a generic formal derived type with no discriminant_part:
    1. If the ancestor subtype is constrained, the actual subtype shall be constrained, and shall be statically compatible with the ancestor;
    2. If the ancestor subtype is an unconstrained access or composite subtype, the actual subtype shall be unconstrained.
    3. If the ancestor subtype is an unconstrained discriminated subtype, then the actual shall have the same number of discriminants, and each discriminant of the actual shall correspond to a discriminant of the ancestor, in the sense of section Discriminants.
  1. The declaration of a formal derived type shall not have a known_discriminant_part. For a generic formal private type with a known_discriminant_part:
    1. The actual type shall be a type with the same number of discriminants.
    2. The actual subtype shall be unconstrained.
    3. The subtype of each discriminant of the actual type shall statically match the subtype of the corresponding discriminant of the formal type.
  1. For a generic formal type with an unknown_discriminant_part, the actual may, but need not, have discriminants, and may be definite or indefinite.

    Static Semantics

  2. The class determined for a formal private type is as follows: 
  3. Type Definition         Determined Class

limited private         the class of all types
private                 the class of all nonlimited types
tagged limited private  the class of all tagged types
tagged private          the class of all nonlimited tagged types
  4. The presence of the reserved word abstract determines whether the actual type may be abstract.
  5. A formal private or derived type is a private or derived type, respectively. A formal derived tagged type is a private extension. A formal private or derived type is abstract if the reserved word abstract appears in its declaration.
  6. If the ancestor type is a composite type that is not an array type, the formal type inherits components from the ancestor type (including discriminants if a new discriminant_part is not specified), as for a derived type defined by a derived_type_definition, see section Derived Types and Classes.
  7. For a formal derived type, the predefined operators and inherited user-defined subprograms are determined by the ancestor type, and are implicitly declared at the earliest place, if any, within the immediate scope of the formal type, where the corresponding primitive subprogram of the ancestor is visible, see section Private Operations. In an instance, the copy of such an implicit declaration declares a view of the corresponding primitive subprogram of the ancestor, even if this primitive has been overridden for the actual type. In the case of a formal private extension, however, the tag of the formal type is that of the actual type, so if the tag in a call is statically determined to be that of the formal type, the body executed will be that corresponding to the actual type.
  8. For a prefix S that denotes a formal indefinite subtype, the following attribute is defined:
  9. S'Definite 
    S'Definite yields True if the actual subtype corresponding to
S is definite; otherwise it yields False. The value of this
attribute is of the predefined type Boolean.
    NOTES
  10. (9) In accordance with the general rule that the actual type shall belong to the class determined for the formal, see section Formal Types.:
    1. If the formal type is nonlimited, then so shall be the actual;
    2. For a formal derived type, the actual shall be in the class rooted at the ancestor subtype.
  1. (10) The actual type can be abstract only if the formal type is abstract (see section Abstract Types and Subprograms).
  2. (11) If the formal has a discriminant_part, the actual can be either definite or indefinite. Otherwise, the actual has to be definite.

Formal Scalar Types

  1. A formal scalar type is one defined by any of the formal_type_definitions in this subclause. The class determined for a formal scalar type is discrete, signed integer, modular, floating point, ordinary fixed point, or decimal.

    Syntax 

  2. formal_discrete_type_definition ::= (<>)

  3. formal_signed_integer_type_definition ::= range <>

  4. formal_modular_type_definition ::= mod <>

  5. formal_floating_point_definition ::= digits <>

  6. formal_ordinary_fixed_point_definition ::= delta <>

  7. formal_decimal_fixed_point_definition ::= delta <> digits <>

    Legality Rules

  8. The actual type for a formal scalar type shall not be a nonstandard numeric type. NOTES
  9. (12) The actual type shall be in the class of types implied by the syntactic category of the formal type definition, see section Formal Types. For example, the actual for a formal_modular_type_definition shall be a modular type.

Formal Array Types

  1. The class determined for a formal array type is the class of all array types.

    Syntax 

  2. formal_array_type_definition ::= array_type_definition

    Legality Rules

  3. The only form of discrete_subtype_definition that is allowed within the declaration of a generic formal (constrained) array subtype is a subtype_mark.
  4. For a formal array subtype, the actual subtype shall satisfy the following conditions:
    1. The formal array type and the actual array type shall have the same dimensionality; the formal subtype and the actual subtype shall be either both constrained or both unconstrained.
    2. For each index position, the index types shall be the same, and the index subtypes (if unconstrained), or the index ranges (if constrained), shall statically match, see section Statically Matching Constraints and Subtypes.
    3. The component subtypes of the formal and actual array types shall statically match.
    4. If the formal type has aliased components, then so shall the actual.

Examples

  1. Example of formal array types: 
  2. --  given the generic package

  3. generic
   type Item   is private;
   type Index  is (<>);
   type Vector is array (Index range <>) of Item;
   type Table  is array (Index) of Item;
package P is
   ...
end P;

  4. --  and the types

  5. type Mix    is array (Color range <>) of Boolean;
type Option is array (Color) of Boolean;

  6. --  then Mix can match Vector and Option can match Table

  7. package R is new P(Item   => Boolean, Index => Color,
                   Vector => Mix,     Table => Option);

  8. --  Note that Mix cannot match Table and Option cannot match Vector

Formal Access Types

  1. The class determined for a formal access type is the class of all access types.

    Syntax 

  2. formal_access_type_definition ::= access_type_definition

    Legality Rules

  3. For a formal access-to-object type, the designated subtypes of the formal and actual types shall statically match.
  4. If and only if the general_access_modifier constant applies to the formal, the actual shall be an access-to-constant type. If the general_access_modifier all applies to the formal, then the actual shall be a general access-to-variable type, see section Access Types.
  5. For a formal access-to-subprogram subtype, the designated profiles of the formal and the actual shall be mode-conformant, and the calling convention of the actual shall be protected if and only if that of the formal is protected.

    Examples

  6. Example of formal access types: 
  7. --  the formal types of the generic package

  8. generic
   type Node is private;
   type Link is access Node;
package P is
   ...
end P;

  9. --  can be matched by the actual types

  10. type Car;
type Car_Name is access Car;

  11. type Car is
   record
      Pred, Succ : Car_Name;
      Number     : License_Number;
      Owner      : Person;
   end record;

  12. --  in the following generic instantiation

  13. package R is new P(Node => Car, Link => Car_Name);

Formal Subprograms

  1. Formal subprograms can be used to pass callable entities to a generic unit.

    Syntax 

  2. formal_subprogram_declaration ::=
   with subprogram_specification [is subprogram_default];

  3. subprogram_default ::= default_name | <>

  4. default_name ::= name

    Name Resolution Rules

  5. The expected profile for the default_name, if any, is that of the formal subprogram.
  6. For a generic formal subprogram, the expected profile for the actual is that of the formal subprogram.

    Legality Rules

  7. The profiles of the formal and any named default shall be mode-conformant.
  8. The profiles of the formal and actual shall be mode-conformant.

    Static Semantics

  9. A formal_subprogram_declaration declares a generic formal subprogram. The types of the formal parameters and result, if any, of the formal subprogram are those determined by the subtype_marks given in the formal_subprogram_declaration; however, independent of the particular subtypes that are denoted by the subtype_marks, the nominal subtypes of the formal parameters and result, if any, are defined to be nonstatic, and unconstrained if of an array type (no applicable index constraint is provided in a call on a formal subprogram). In an instance, a formal_subprogram_declaration declares a view of the actual. The profile of this view takes its subtypes and calling convention from the original profile of the actual entity, while taking the formal parameter names and default_expressions from the profile given in the formal_subprogram_declaration. The view is a function or procedure, never an entry.
  10. If a generic unit has a subprogram_default specified by a box, and the corresponding actual parameter is omitted, then it is equivalent to an explicit actual parameter that is a usage name identical to the defining name of the formal. NOTES
  11. (13) The matching rules for formal subprograms state requirements that are similar to those applying to subprogram_renaming_declarations (see section Subprogram Renaming Declarations). In particular, the name of a parameter of the formal subprogram need not be the same as that of the corresponding parameter of the actual subprogram; similarly, for these parameters, default_expressions need not correspond.
  12. (14) The constraints that apply to a parameter of a formal subprogram are those of the corresponding formal parameter of the matching actual subprogram (not those implied by the corresponding subtype_mark in the _specification of the formal subprogram). A similar remark applies to the result of a function. Therefore, to avoid confusion, it is recommended that the name of a first subtype be used in any declaration of a formal subprogram.
  13. (15) The subtype specified for a formal parameter of a generic formal subprogram can be any visible subtype, including a generic formal subtype of the same generic_formal_part.
  14. (16) A formal subprogram is matched by an attribute of a type if the attribute is a function with a matching specification. An enumeration literal of a given type matches a parameterless formal function whose result type is the given type.
  15. (17) A default_name denotes an entity that is visible or directly visible at the place of the generic_declaration; a box used as a default is equivalent to a name that denotes an entity that is directly visible at the place of the _instantiation.
  16. (18) The actual subprogram cannot be abstract, see section Abstract Types and Subprograms.

    Examples

  17. Examples of generic formal subprograms: 
  18. with function "+"(X, Y : Item) return Item is <>;
with function Image(X : Enum) return String is Enum'Image;
with procedure Update is Default_Update;

  19. --  given the generic procedure declaration

  20. generic
   with procedure Action (X : in Item);
procedure Iterate(Seq : in Item_Sequence);

  21. --  and the procedure

  22. procedure Put_Item(X : in Item);

  23. --  the following instantiation is possible

  24. procedure Put_List is new Iterate(Action => Put_Item);

Formal Packages

  1. Formal packages can be used to pass packages to a generic unit. The formal_package_declaration declares that the formal package is an instance of a given generic package. Upon instantiation, the actual package has to be an instance of that generic package.

    Syntax 

  2. formal_package_declaration ::=
   with package defining_identifier is new
     generic_package_name formal_package_actual_part;

  3. formal_package_actual_part ::= (<>) | [generic_actual_part]

    Legality Rules

  4. The generic_package_name shall denote a generic package (the template for the formal package); the formal package is an instance of the template.
  5. The actual shall be an instance of the template. If the formal_package_actual_part is (<>), then the actual may be any instance of the template; otherwise, each actual parameter of the actual instance shall match the corresponding actual parameter of the formal package (whether the actual parameter is given explicitly or by default), as follows:
    1. For a formal object of mode in the actuals match if they are static expressions with the same value, or if they statically denote the same constant, or if they are both the literal null.
    2. For a formal subtype, the actuals match if they denote statically matching subtypes.
    3. For other kinds of formals, the actuals match if they statically denote the same entity.

Static Semantics

  1. A formal_package_declaration declares a generic formal package.
  2. The visible part of a formal package includes the first list of basic_declarative_items of the package_specification. In addition, if the formal_package_actual_part is (<>), it also includes the generic_formal_part of the template for the formal package.

Example of a Generic Package

  1. The following example provides a possible formulation of stacks by means of a generic package. The size of each stack and the type of the stack elements are provided as generic formal parameters.

    Examples 

  1. generic
   Size : Positive;
   type Item is private;
package Stack is
   procedure Push(E : in  Item);
   procedure Pop (E : out Item);
   Overflow, Underflow : exception;
end Stack;

  2. package body Stack is

  3.    type Table is array (Positive range <>) of Item;
   Space : Table(1 .. Size);
   Index : Natural := 0;

  4.    procedure Push(E : in Item) is
   begin
      if Index >= Size then
         raise Overflow;
      end if;
      Index := Index + 1;
      Space(Index) := E;
   end Push;

  5.    procedure Pop(E : out Item) is
   begin
      if Index = 0 then
         raise Underflow;
      end if;
      E := Space(Index);
      Index := Index - 1;
   end Pop;

  6. end Stack;
  7. Instances of this generic package can be obtained as follows: 
  8. package Stack_Int  is new Stack(Size => 200, Item => Integer);
package Stack_Bool is new Stack(100, Boolean);
  9. Thereafter, the procedures of the instantiated packages can be called as follows: 
  10. Stack_Int.Push(N);
Stack_Bool.Push(True);
  11. Alternatively, a generic formulation of the type Stack can be given as follows (package body omitted): 
  12. generic
   type Item is private;
package On_Stacks is
   type Stack(Size : Positive) is limited private;
   procedure Push(S : in out Stack; E : in  Item);
   procedure Pop (S : in out Stack; E : out Item);
   Overflow, Underflow : exception;
private
   type Table is array (Positive range <>) of Item;
   type Stack(Size : Positive) is
      record
         Space : Table(1 .. Size);
         Index : Natural := 0;
      end record;
end On_Stacks;
  13. In order to use such a package, an instance has to be created and thereafter stacks of the corresponding type can be declared: 
  14. declare
   package Stack_Real is new On_Stacks(Real); use Stack_Real;
   S : Stack(100);
begin
   ...
   Push(S, 2.54);
   ...
end;

Representation Issues

  1. This section describes features for querying and controlling aspects of representation and for interfacing to hardware.

Representation Items

  1. There are three kinds of representation items: representation_clauses, component_clauses, and representation pragmas. Representation items specify how the types and other entities of the language are to be mapped onto the underlying machine. They can be provided to give more efficient representation or to interface with features that are outside the domain of the language (for example, peripheral hardware). Representation items also specify other specifiable properties of entities. A representation item applies to an entity identified by a local_name, which denotes an entity declared local to the current declarative region, or a library unit declared immediately preceding a representation pragma in a compilation.

    Syntax 

  2. representation_clause ::=
     attribute_definition_clause
   | enumeration_representation_clause
   | record_representation_clause
   | at_clause

  3. local_name ::=
     direct_name
   | direct_name'attribute_designator
   | library_unit_name
    1. A representation pragma is allowed only at places where a representation_clause or compilation_unit is allowed.

Name Resolution Rules

  1. In a representation item, if the local_name is a direct_name, then it shall resolve to denote a declaration (or, in the case of a pragma, one or more declarations) that occurs immediately within the same declarative_region as the representation item. If the local_name has an attribute_designator, then it shall resolve to denote an implementation-defined component, see section Record Representation Clauses, or a class-wide type implicitly declared immediately within the same declarative_region as the representation item. A local_name that is a library_unit_name (only permitted in a representation pragma) shall resolve to denote the library_item that immediately precedes (except for other pragmas) the representation pragma.

    Legality Rules

  2. The local_name of a representation_clause or representation pragma shall statically denote an entity (or, in the case of a pragma, one or more entities) declared immediately preceding it in a compilation, or within the same declarative_part, package_specification, task_definition, protected_definition, or record_definition as the representation item. If a local_name denotes a local callable entity, it may do so through a local subprogram_renaming_declaration (as a way to resolve ambiguity in the presence of overloading); otherwise, the local_name shall not denote a renaming_declaration.
  3. The representation of an object consists of a certain number of bits (the size of the object). These are the bits that are normally read or updated by the machine code when loading, storing, or operating-on the value of the object. This includes some padding bits, when the size of the object is greater than the size of its subtype. Such padding bits are considered to be part of the representation of the object, rather than being gaps between objects, if these bits are normally read and updated.
  4. A representation item directly specifies an aspect of representation of the entity denoted by the local_name, except in the case of a type-related representation item, whose local_name shall denote a first subtype, and which directly specifies an aspect of the subtype's type. A representation item that names a subtype is either subtype-specific (Size and Alignment clauses) or type-related (all others). Subtype-specific aspects may differ for different subtypes of the same type.
  5. A representation item that directly specifies an aspect of a subtype or type shall appear after the type is completely defined, see section Completions of Declarations, and before the subtype or type is frozen, see section Freezing Rules. If a representation item is given that directly specifies an aspect of an entity, then it is illegal to give another representation item that directly specifies the same aspect of the entity.
  6. For an untagged derived type, no type-related representation items are allowed if the parent type is a by-reference type, or has any user-defined primitive subprograms.
  7. Representation aspects of a generic formal parameter are the same as those of the actual. A type-related representation item is not allowed for a descendant of a generic formal untagged type.
  8. A representation item that specifies the Size for a given subtype, or the size or storage place for an object (including a component) of a given subtype, shall allow for enough storage space to accommodate any value of the subtype.
  9. A representation item that is not supported by the implementation is illegal, or raises an exception at run time.

    Static Semantics

  10. If two subtypes statically match, then their subtype-specific aspects (Size and Alignment) are the same.
  11. A derived type inherits each type-related aspect of its parent type that was directly specified before the declaration of the derived type, or (in the case where the parent is derived) that was inherited by the parent type from the grandparent type. A derived subtype inherits each subtype-specific aspect of its parent subtype that was directly specified before the declaration of the derived type, or (in the case where the parent is derived) that was inherited by the parent subtype from the grandparent subtype, but only if the parent subtype statically matches the first subtype of the parent type. An inherited aspect of representation is overridden by a subsequent representation item that specifies the same aspect of the type or subtype.
  12. Each aspect of representation of an entity is as follows:
    1. If the aspect is specified for the entity, meaning that it is either directly specified or inherited, then that aspect of the entity is as specified, except in the case of Storage_Size, which specifies a minimum.
    2. If an aspect of representation of an entity is not specified, it is chosen by default in an unspecified manner.

Dynamic Semantics

  1. For the elaboration of a representation_clause, any evaluable constructs within it are evaluated.

    Implementation Permissions

  2. An implementation may interpret aspects of representation in an implementation-defined manner. An implementation may place implementation-defined restrictions on representation items. A recommended level of support is specified for representation items and related features in each subclause. These recommendations are changed to requirements for implementations that support the Systems Programming Annex, see section Required Representation Support.

    Implementation Advice

  3. The recommended level of support for all representation items is qualified as follows:
    1. An implementation need not support representation items containing nonstatic expressions, except that an implementation should support a representation item for a given entity if each nonstatic expression in the representation item is a name that statically denotes a constant declared before the entity.
    2. An implementation need not support a specification for the Size for a given composite subtype, nor the size or storage place for an object (including a component) of a given composite subtype, unless the constraints on the subtype and its composite subcomponents (if any) are all static constraints.
    3. An aliased component, or a component whose type is by-reference, should always be allocated at an addressable location.

Pragma Pack

  1. A pragma Pack specifies that storage minimization should be the main criterion when selecting the representation of a composite type.

    Syntax

  2. The form of a pragma Pack is as follows: 
  3. pragma Pack(first_subtype_local_name);

    Legality Rules

  4. The first_subtype_local_name of a pragma Pack shall denote a composite subtype.

    Static Semantics

  5. A pragma Pack specifies the packing aspect of representation; the type (or the extension part) is said to be packed. For a type extension, the parent part is packed as for the parent type, and a pragma Pack causes packing only of the extension part.

    Implementation Advice

  6. If a type is packed, then the implementation should try to minimize storage allocated to objects of the type, possibly at the expense of speed of accessing components, subject to reasonable complexity in addressing calculations.
  7. The recommended level of support for pragma Pack is:
    1. For a packed record type, the components should be packed as tightly as possible subject to the Sizes of the component subtypes, and subject to any record_representation_clause that applies to the type; the implementation may, but need not, reorder components or cross aligned word boundaries to improve the packing. A component whose Size is greater than the word size may be allocated an integral number of words.
    2. For a packed array type, if the component subtype's Size is less than or equal to the word size, and Component_Size is not specified for the type, Component_Size should be less than or equal to the Size of the component subtype, rounded up to the nearest factor of the word size.

Representation Attributes

  1. The values of certain implementation-dependent characteristics can be obtained by interrogating appropriate representation attributes. Some of these attributes are specifiable via an attribute_definition_clause.

    Syntax 

  2. attribute_definition_clause ::=
     for local_name'attribute_designator use expression;
   | for local_name'attribute_designator use name;

    Name Resolution Rules

  3. For an attribute_definition_clause that specifies an attribute that denotes a value, the form with an expression shall be used. Otherwise, the form with a name shall be used.
  4. For an attribute_definition_clause that specifies an attribute that denotes a value or an object, the expected type for the expression or name is that of the attribute. For an attribute_definition_clause that specifies an attribute that denotes a subprogram, the expected profile for the name is the profile required for the attribute. For an attribute_definition_clause that specifies an attribute that denotes some other kind of entity, the name shall resolve to denote an entity of the appropriate kind.

    Legality Rules

  5. An attribute_designator is allowed in an attribute_definition_clause only if this International Standard explicitly allows it, or for an implementation-defined attribute if the implementation allows it. Each specifiable attribute constitutes an aspect of representation.
  6. For an attribute_definition_clause that specifies an attribute that denotes a subprogram, the profile shall be mode conformant with the one required for the attribute, and the convention shall be Ada. Additional requirements are defined for particular attributes.

    Static Semantics

  7. A Size clause is an attribute_definition_clause whose attribute_designator is Size. Similar definitions apply to the other specifiable attributes.
  8. A storage element is an addressable element of storage in the machine. A word is the largest amount of storage that can be conveniently and efficiently manipulated by the hardware, given the implementation's run-time model. A word consists of an integral number of storage elements.
  9. The following attributes are defined:
  10. For a prefix X that denotes an object, program unit, or label:
  11. X'Address 
    Denotes the address of the first of the storage elements
allocated to X. For a program unit or label, this value
refers to the machine code associated with the corresponding
body or statement. The value of this attribute is of type
System.Address.

  12. Address may be specified for stand-alone objects and for
program units via an attribute_definition_clause.

    Erroneous Execution

  13. If an Address is specified, it is the programmer's responsibility to ensure that the address is valid; otherwise, program execution is erroneous.

    Implementation Advice

  14. For an array X, X'Address should point at the first component of the array, and not at the array bounds.
  15. The recommended level of support for the Address attribute is:
    1. X'Address should produce a useful result if X is an object that is aliased or of a by-reference type, or is an entity whose Address has been specified.
    2. An implementation should support Address clauses for imported subprograms.
    3. Objects (including subcomponents) that are aliased or of a by-reference type should be allocated on storage element boundaries.
    4. If the Address of an object is specified, or it is imported or exported, then the implementation should not perform optimizations based on assumptions of no aliases.
    NOTES
  1. (1) The specification of a link name in a pragma Export, see section Interfacing Pragmas for a subprogram or object is an alternative to explicit specification of its link-time address, allowing a link-time directive to place the subprogram or object within memory.
  2. (2) The rules for the Size attribute imply, for an aliased object X, that if X'Size = Storage_Unit, then X'Address points at a storage element containing all of the bits of X, and only the bits of X.

    Static Semantics

  3. For a prefix X that denotes a subtype or object:
  4. X'Alignment 
    The Address of an object that is allocated under control of
the implementation is an integral multiple of the Alignment
of the object (that is, the Address modulo the Alignment is
zero). The offset of a record component is a multiple of the
Alignment of the component. For an object that is not
allocated under control of the implementation (that is, one
that is imported, that is allocated by a user-defined
allocator, whose Address has been specified, or is designated
by an access value returned by an instance of
Unchecked_Conversion), the implementation may assume that the
Address is an integral multiple of its Alignment. The
implementation shall not assume a stricter alignment.

  5. The value of this attribute is of type
universal_integer, and nonnegative; zero means that the
object is not necessarily aligned on a storage element
boundary.

  6. Alignment may be specified for first subtypes and
stand-alone objects via an attribute_definition_clause; the
expression of such a clause shall be static, and its value
nonnegative. If the Alignment of a subtype is specified,
then the Alignment of an object of the subtype is at least as
strict, unless the object's Alignment is also specified. The
Alignment of an object created by an allocator is that of the
designated subtype.

  7. If an Alignment is specified for a composite subtype or
object, this Alignment shall be equal to the least common
multiple of any specified Alignments of the subcomponent
subtypes, or an integer multiple thereof.

    Erroneous Execution

  8. Program execution is erroneous if an Address clause is given that conflicts with the Alignment.
  9. If the Alignment is specified for an object that is not allocated under control of the implementation, execution is erroneous if the object is not aligned according to the Alignment.

    Implementation Advice

  10. The recommended level of support for the Alignment attribute for subtypes is:
    1. An implementation should support specified Alignments that are factors and multiples of the number of storage elements per word, subject to the following:
    2. An implementation need not support specified Alignments for combinations of Sizes and Alignments that cannot be easily loaded and stored by available machine instructions.
    3. An implementation need not support specified Alignments that are greater than the maximum Alignment the implementation ever returns by default.
  1. The recommended level of support for the Alignment attribute for objects is:
    1. Same as above, for subtypes, but in addition:
    2. For stand-alone library-level objects of statically constrained subtypes, the implementation should support all Alignments supported by the target linker. For example, page alignment is likely to be supported for such objects, but not for subtypes.
    NOTES
  1. (3) Alignment is a subtype-specific attribute.
  2. (4) The Alignment of a composite object is always equal to the least common multiple of the Alignments of its components, or a multiple thereof.
  3. (5) A component_clause, Component_Size clause, or a pragma Pack can override a specified Alignment.

    Static Semantics

  4. For a prefix X that denotes an object:
  5. X'Size 
    Denotes the size in bits of the representation of the object.
The value of this attribute is of the type universal_integer.
    1. Size may be specified for stand-alone objects via an attribute_definition_clause; the expression of such a clause shall be static and its value nonnegative.

Implementation Advice

  1. The recommended level of support for the Size attribute of objects is:
    1. A Size clause should be supported for an object if the specified Size is at least as large as its subtype's Size, and corresponds to a size in storage elements that is a multiple of the object's Alignment (if the Alignment is nonzero).

Static Semantics

  1. For every subtype S:
  2. S'Size 
    If S is definite, denotes the size (in bits) that the
implementation would choose for the following objects of
subtype S:
    1. A record component of subtype S when the record type is packed.
    2. The formal parameter of an instance of Unchecked_Conversion that converts from subtype S to some other subtype.
    3. If S is indefinite, the meaning is implementation defined. The value of this attribute is of the type universal_integer. The Size of an object is at least as large as that of its subtype, unless the object's Size is determined by a Size clause, a component_clause, or a Component_Size clause. Size may be specified for first subtypes via an attribute_definition_clause; the expression of such a clause shall be static and its value nonnegative.

Implementation Requirements

  1. In an implementation, Boolean'Size shall be 1.

    Implementation Advice

  2. If the Size of a subtype is specified, and allows for efficient independent addressability, see section Shared Variables, on the target architecture, then the Size of the following objects of the subtype should equal the Size of the subtype:
    1. Aliased objects (including components).
    2. Unaliased components, unless the Size of the component is determined by a component_clause or Component_Size clause.
  1. A Size clause on a composite subtype should not affect the internal layout of components.
  2. The recommended level of support for the Size attribute of subtypes is:
    1. The Size (if not specified) of a static discrete or fixed point subtype should be the number of bits needed to represent each value belonging to the subtype using an unbiased representation, leaving space for a sign bit only if the subtype contains negative values. If such a subtype is a first subtype, then an implementation should support a specified Size for it that reflects this representation.
    2. For a subtype implemented with levels of indirection, the Size should include the size of the pointers, but not the size of what they point at.
    NOTES
  1. (6) Size is a subtype-specific attribute.
  2. (7) A component_clause or Component_Size clause can override a specified Size. A pragma Pack cannot.

    Static Semantics

  3. For a prefix T that denotes a task object (after any implicit dereference):
  4. T'Storage_Size 
    Denotes the number of storage elements reserved for the task.
The value of this attribute is of the type universal_integer.
The Storage_Size includes the size of the task's stack, if
any. The language does not specify whether or not it
includes other storage associated with the task (such as the
"task control block" used by some implementations.)  If a
pragma Storage_Size is given, the value of the Storage_Size
attribute is at least the value specified in the pragma.
  5. A pragma Storage_Size specifies the amount of storage to be reserved for the execution of a task.

    Syntax

  6. The form of a pragma Storage_Size is as follows: 
  7. pragma Storage_Size(expression);
    1. A pragma Storage_Size is allowed only immediately within a task_definition.

Name Resolution Rules

  1. The expression of a pragma Storage_Size is expected to be of any integer type.

    Dynamic Semantics

  2. A pragma Storage_Size is elaborated when an object of the type defined by the immediately enclosing task_definition is created. For the elaboration of a pragma Storage_Size, the expression is evaluated; the Storage_Size attribute of the newly created task object is at least the value of the expression.
  3. At the point of task object creation, or upon task activation, Storage_Error is raised if there is insufficient free storage to accommodate the requested Storage_Size. Static Semantics
  4. For a prefix X that denotes an array subtype or array object (after any implicit dereference):
  5. X'Component_Size 
    Denotes the size in bits of components of the type of X. The
value of this attribute is of type universal_integer.
    1. Component_Size may be specified for array types via an attribute_definition_clause; the expression of such a clause shall be static, and its value nonnegative.

Implementation Advice

  1. The recommended level of support for the Component_Size attribute is:
    1. An implementation need not support specified Component_Sizes that are less than the Size of the component subtype.
    2. An implementation should support specified Component_Sizes that are factors and multiples of the word size. For such Component_Sizes, the array should contain no gaps between components. For other Component_Sizes (if supported), the array should contain no gaps between components when packing is also specified; the implementation should forbid this combination in cases where it cannot support a no-gaps representation.

Static Semantics

  1. For every subtype S of a tagged type T (specific or class-wide), the following attribute is defined:
  2. S'External_Tag 
    S'External_Tag denotes an external string representation for
S'Tag; it is of the predefined type String. External_Tag may
be specified for a specific tagged type via an
attribute_definition_clause; the expression of such a
clause shall be static. The default external tag
representation is implementation defined. See section Dispatching Operations of Tagged Types, and
section Stream-Oriented Attributes.

    Implementation Requirements

  3. In an implementation, the default external tag for each specific tagged type declared in a partition shall be distinct, so long as the type is declared outside an instance of a generic body. If the compilation unit in which a given tagged type is declared, and all compilation units on which it semantically depends, are the same in two different partitions, then the external tag for the type shall be the same in the two partitions. What it means for a compilation unit to be the same in two different partitions is implementation defined. At a minimum, if the compilation unit is not recompiled between building the two different partitions that include it, the compilation unit is considered the same in the two partitions. NOTES
  4. (8) The following language-defined attributes are specifiable, at least for some of the kinds of entities to which they apply: Address, Size, Component_Size, Alignment, External_Tag, Small, Bit_Order, Storage_Pool, Storage_Size, Write, Output, Read, Input, and Machine_Radix.
  5. (9) It follows from the general rules in section Representation Items, that if one writes "for X'Size use Y;" then the X'Size attribute_reference will return Y (assuming the implementation allows the Size clause). The same is true for all of the specifiable attributes except Storage_Size.

    Examples

  6. Examples of attribute definition clauses: 
  7. Byte : constant := 8;
Page : constant := 2**12;

  8. type Medium is range 0 .. 65_000;
for Medium'Size use 2*Byte;
for Medium'Alignment use 2;
Device_Register : Medium;
for Device_Register'Size use Medium'Size;
for Device_Register'Address use
  System.Storage_Elements.To_Address(16#FFFF_0020#);

  9. type Short is delta 0.01 range -100.0 .. 100.0;
for Short'Size use 15;

  10. for Car_Name'Storage_Size use
-- specify access type's storage pool size
  2000*((Car'Size/System.Storage_Unit) +1);
  -- approximately 2000 cars

  11. function My_Read(Stream : access Ada.Streams.Root_Stream_Type'Class)
  return T;
for T'Read use My_Read;  --  see section Stream-Oriented Attributes
    NOTES
  12. (10) Notes on the examples: In the Size clause for Short, fifteen bits is the minimum necessary, since the type definition requires Short'Small <= 2**(-7).

Enumeration Representation Clauses

  1. An enumeration_representation_clause specifies the internal codes for enumeration literals.

    Syntax 

  2. enumeration_representation_clause ::=
   for first_subtype_local_name use enumeration_aggregate;

  3. enumeration_aggregate ::= array_aggregate

    Name Resolution Rules

  4. The enumeration_aggregate shall be written as a one-dimensional array_aggregate, for which the index subtype is the unconstrained subtype of the enumeration type, and each component expression is expected to be of any integer type.

    Legality Rules

  5. The first_subtype_local_name of an enumeration_representation_clause shall denote an enumeration subtype.
  6. The expressions given in the array_aggregate shall be static, and shall specify distinct integer codes for each value of the enumeration type; the associated integer codes shall satisfy the predefined ordering relation of the type.

    Static Semantics

  7. An enumeration_representation_clause specifies the coding aspect of representation. The coding consists of the internal code for each enumeration literal, that is, the integral value used internally to represent each literal.

    Implementation Requirements

  8. For nonboolean enumeration types, if the coding is not specified for the type, then for each value of the type, the internal code shall be equal to its position number.

    Implementation Advice

  9. The recommended level of support for enumeration_representation_clauses is:
    1. An implementation should support at least the internal codes in the range System.Min_Int..System.Max_Int. An implementation need not support enumeration_representation_clauses for boolean types.
    NOTES
  1. (11) Unchecked_Conversion may be used to query the internal codes used for an enumeration type. The attributes of the type, such as Succ, Pred, and Pos, are unaffected by the representation_clause. For example, Pos always returns the position number, not the internal integer code that might have been specified in a representation_clause.

    Examples

  2. Example of an enumeration representation clause: 
  3. type Mix_Code is (ADD, SUB, MUL, LDA, STA, STZ);

  4. for Mix_Code use
   (ADD => 1, SUB => 2, MUL => 3, LDA => 8, STA => 24, STZ =>33);

Record Layout

  1. The (record) layout aspect of representation consists of the storage places for some or all components, that is, storage place attributes of the components. The layout can be specified with a record_representation_clause.

Record Representation Clauses

  1. A record_representation_clause specifies the storage representation of records and record extensions, that is, the order, position, and size of components (including discriminants, if any).

    Syntax 

  2. record_representation_clause ::=
   for first_subtype_local_name use
      record [mod_clause]
         {component_clause}
      end record;

  3. component_clause ::=
   component_local_name at position range first_bit .. last_bit;

  4. position ::= static_expression

  5. first_bit ::= static_simple_expression

  6. last_bit ::= static_simple_expression

    Name Resolution Rules

  7. Each position, first_bit, and last_bit is expected to be of any integer type.

    Legality Rules

  8. The first_subtype_local_name of a record_representation_clause shall denote a specific nonlimited record or record extension subtype.
  9. If the component_local_name is a direct_name, the local_name shall denote a component of the type. For a record extension, the component shall not be inherited, and shall not be a discriminant that corresponds to a discriminant of the parent type. If the component_local_name has an attribute_designator, the direct_name of the local_name shall denote either the declaration of the type or a component of the type, and the attribute_designator shall denote an implementation-defined implicit component of the type.
  10. The position, first_bit, and last_bit shall be static expressions. The value of position and first_bit shall be nonnegative. The value of last_bit shall be no less than first_bit - 1.
  11. At most one component_clause is allowed for each component of the type, including for each discriminant (component_clauses may be given for some, all, or none of the components). Storage places within a component_list shall not overlap, unless they are for components in distinct variants of the same variant_part.
  12. A name that denotes a component of a type is not allowed within a record_representation_clause for the type, except as the component_local_name of a component_clause.

    Static Semantics

  13. A record_representation_clause (without the mod_clause) specifies the layout. The storage place attributes, see section Storage Place Attributes, are taken from the values of the position, first_bit, and last_bit expressions after normalizing those values so that first_bit is less than Storage_Unit.
  14. A record_representation_clause for a record extension does not override the layout of the parent part; if the layout was specified for the parent type, it is inherited by the record extension.

    Implementation Permissions

  15. An implementation may generate implementation-defined components (for example, one containing the offset of another component). An implementation may generate names that denote such implementation-defined components; such names shall be implementation-defined attribute_references. An implementation may allow such implementation-defined names to be used in record_ representation_clauses. An implementation can restrict such component_clauses in any manner it sees fit.
  16. If a record_representation_clause is given for an untagged derived type, the storage place attributes for all of the components of the derived type may differ from those of the corresponding components of the parent type, even for components whose storage place is not specified explicitly in the record_representation_clause.

    Implementation Advice

  17. The recommended level of support for record_representation_clauses is:
    1. An implementation should support storage places that can be extracted with a load, mask, shift sequence of machine code, and set with a load, shift, mask, store sequence, given the available machine instructions and run-time model.
    2. A storage place should be supported if its size is equal to the Size of the component subtype, and it starts and ends on a boundary that obeys the Alignment of the component subtype.
    3. If the default bit ordering applies to the declaration of a given type, then for a component whose subtype's Size is less than the word size, any storage place that does not cross an aligned word boundary should be supported.
    4. An implementation may reserve a storage place for the tag field of a tagged type, and disallow other components from overlapping that place.
    5. An implementation need not support a component_clause for a component of an extension part if the storage place is not after the storage places of all components of the parent type, whether or not those storage places had been specified.
    NOTES
  1. (12) If no component_clause is given for a component, then the choice of the storage place for the component is left to the implementation. If component_clauses are given for all components, the record_representation_clause completely specifies the representation of the type and will be obeyed exactly by the implementation.

    Examples

  2. Example of specifying the layout of a record type: 
  3. Word : constant := 4;  --  storage element is byte, 4 bytes per word

  4. type State      is (A,M,W,P);
type Mode       is (Fix, Dec, Exp, Signif);

  5. type Byte_Mask  is array (0..7)  of Boolean;
type State_Mask is array (State) of Boolean;
type Mode_Mask  is array (Mode)  of Boolean;

  6. type Program_Status_Word is
  record
      System_Mask     : Byte_Mask;
      Protection_Key  : Integer range 0 .. 3;
      Machine_State   : State_Mask;
      Interrupt_Cause : Interruption_Code;
      Ilc             : Integer range 0 .. 3;
      Cc              : Integer range 0 .. 3;
      Program_Mask    : Mode_Mask;
      Inst_Address    : Address;
end record;

  7. for Program_Status_Word use
  record
      System_Mask     at 0*Word range 0  .. 7;
      Protection_Key  at 0*Word range 10 .. 11; -- bits 8,9 unused
      Machine_State   at 0*Word range 12 .. 15;
      Interrupt_Cause at 0*Word range 16 .. 31;
      Ilc             at 1*Word range 0  .. 1;  -- second word
      Cc              at 1*Word range 2  .. 3;
      Program_Mask    at 1*Word range 4  .. 7;
      Inst_Address    at 1*Word range 8  .. 31;
  end record;

  8. for Program_Status_Word'Size use 8*System.Storage_Unit;
for Program_Status_Word'Alignment use 8;
    NOTES
  9. (13) Note on the example: The record_representation_clause defines the record layout. The Size clause guarantees that (at least) eight storage elements are used for objects of the type. The Alignment clause guarantees that aliased, imported, or exported objects of the type will have addresses divisible by eight.

Storage Place Attributes

Static Semantics

  1. For a component C of a composite, non-array object R, the storage place attributes are defined:
  2. R.C'Position 
    Denotes the same value as R.C'Address - R'Address. The value
of this attribute is of the type universal_integer.
  3. R.C'First_Bit 
    Denotes the offset, from the start of the first of the
storage elements occupied by C, of the first bit occupied by
C. This offset is measured in bits. The first bit of a
storage element is numbered zero. The value of this
attribute is of the type universal_integer.
  4. R.C'Last_Bit 
    Denotes the offset, from the start of the first of the
storage elements occupied by C, of the last bit occupied by
C. This offset is measured in bits. The value of this
attribute is of the type universal_integer.

    Implementation Advice

  5. If a component is represented using some form of pointer (such as an offset) to the actual data of the component, and this data is contiguous with the rest of the object, then the storage place attributes should reflect the place of the actual data, not the pointer. If a component is allocated discontiguously from the rest of the object, then a warning should be generated upon reference to one of its storage place attributes.

Bit Ordering

  1. The Bit_Order attribute specifies the interpretation of the storage place attributes.

    Static Semantics

  2. A bit ordering is a method of interpreting the meaning of the storage place attributes. High_Order_First (known in the vernacular as "big endian") means that the first bit of a storage element (bit 0) is the most significant bit (interpreting the sequence of bits that represent a component as an unsigned integer value). Low_Order_First (known in the vernacular as "little endian") means the opposite: the first bit is the least significant.
  3. For every specific record subtype S, the following attribute is defined:
  4. S'Bit_Order 
    Denotes the bit ordering for the type of S. The value of this
attribute is of type System.Bit_Order. Bit_Order may be
specified for specific record types via an
attribute_definition_clause; the expression of such a
clause shall be static.
  5. If Word_Size = Storage_Unit, the default bit ordering is implementation defined. If Word_Size > Storage_Unit, the default bit ordering is the same as the ordering of storage elements in a word, when interpreted as an integer.
  6. The storage place attributes of a component of a type are interpreted according to the bit ordering of the type.

    Implementation Advice

  7. The recommended level of support for the nondefault bit ordering is:
    1. If Word_Size = Storage_Unit, then the implementation should support the nondefault bit ordering in addition to the default bit ordering.

Change of Representation

  1. A type_conversion, see section Type Conversions can be used to convert between two different representations of the same array or record. To convert an array from one representation to another, two array types need to be declared with matching component subtypes, and convertible index types. If one type has packing specified and the other does not, then explicit conversion can be used to pack or unpack an array.
  2. To convert a record from one representation to another, two record types with a common ancestor type need to be declared, with no inherited subprograms. Distinct representations can then be specified for the record types, and explicit conversion between the types can be used to effect a change in representation.

    Examples

  3. Example of change of representation: 
  4. -- Packed_Descriptor and Descriptor are two different types
-- with identical characteristics, apart from their
-- representation

  5. type Descriptor is
    record
      -- components of a descriptor
    end record;

  6. type Packed_Descriptor is new Descriptor;

  7. for Packed_Descriptor use
    record
      -- component clauses for some or for all components
    end record;

  8. --  Change of representation can now be accomplished
--  by explicit type conversions:

  9. D : Descriptor;
P : Packed_Descriptor;

  10. P := Packed_Descriptor(D);  -- pack D
D := Descriptor(P);         -- unpack P

The Package System

  1. For each implementation there is a library package called System which includes the definitions of certain configuration-dependent characteristics.

    Static Semantics

  2. The following language-defined library package exists: 
  3. package System is
   pragma Preelaborate(System);

  4.    type Name is implementation-defined-enumeration-type;
   System_Name : constant Name := implementation-defined;

  5.    -- System-Dependent Named Numbers:

  6.    Min_Int               : constant := root_integer'First;
   Max_Int               : constant := root_integer'Last;

  7.    Max_Binary_Modulus    : constant := implementation-defined;
   Max_Nonbinary_Modulus : constant := implementation-defined;

  8.    Max_Base_Digits       : constant := root_real'Digits;
   Max_Digits            : constant := implementation-defined;

  9.    Max_Mantissa          : constant := implementation-defined;
   Fine_Delta            : constant := implementation-defined;

  10.    Tick                  : constant := implementation-defined;

  11.    -- Storage-related Declarations:

  12.    type Address is implementation-defined;
   Null_Address : constant Address;

  13.    Storage_Unit : constant := implementation-defined;
   Word_Size    : constant := implementation-defined * Storage_Unit;
   Memory_Size  : constant := implementation-defined;

  14.    -- Address Comparison:
   function "<" (Left, Right : Address) return Boolean;
   function "<="(Left, Right : Address) return Boolean;
   function ">" (Left, Right : Address) return Boolean;
   function ">="(Left, Right : Address) return Boolean;
   function "=" (Left, Right : Address) return Boolean;
-- function "/=" (Left, Right : Address) return Boolean;
   -- "/=" is implicitly defined
   pragma Convention(Intrinsic, "<");
   ...
   -- and so on for all language-defined subprograms in this package

  15.    -- Other System-Dependent Declarations:
   type Bit_Order is (High_Order_First, Low_Order_First);
   Default_Bit_Order : constant Bit_Order;

  16.    -- Priority-related declarations, see section Task Priorities.:
   subtype Any_Priority is Integer
     range implementation-defined;
   subtype Priority is Any_Priority
     range Any_Priority'First .. implementation-defined;
   subtype Interrupt_Priority is Any_Priority
     range Priority'Last+1 .. Any_Priority'Last;

  17.    Default_Priority : constant Priority
     := (Priority'First + Priority'Last)/2;

  18. private
   ... -- not specified by the language
end System;
  19. Name is an enumeration subtype. Values of type Name are the names of alternative machine configurations handled by the implementation. System_Name represents the current machine configuration.
  20. The named numbers Fine_Delta and Tick are of the type universal_real; the others are of the type universal_integer.
  21. The meanings of the named numbers are:
  22. Min_Int 
    The smallest (most negative) value allowed for the
expressions of a signed_integer_type_definition.
  23. Max_Int 
    The largest (most positive) value allowed for the expressions
of a signed_integer_type_definition.
  24. Max_Binary_Modulus 
    A power of two such that it, and all lesser positive powers
of two, are allowed as the modulus of a
modular_type_definition.
  25. Max_Nonbinary_Modulus 
    A value such that it, and all lesser positive integers, are
allowed as the modulus of a modular_type_definition.
  26. Max_Base_Digits 
    The largest value allowed for the requested decimal precision
in a floating_point_definition.
  27. Max_Digits 
    The largest value allowed for the requested decimal precision
in a floating_point_definition that has no
real_range_specification. Max_Digits is less than or equal
to Max_Base_Digits.
  28. Max_Mantissa 
    The largest possible number of binary digits in the mantissa
of machine numbers of a user-defined ordinary fixed point
type. (The mantissa is defined in section Numerics (normative).)
  29. Fine_Delta 
    The smallest delta allowed in an
ordinary_fixed_point_definition that has the
real_range_specification range -1.0 .. 1.0.
  30. Tick 
    A period in seconds approximating the real time interval
during which the value of Calendar.Clock remains constant.
  31. Storage_Unit 
    The number of bits per storage element.
  32. Word_Size 
    The number of bits per word.
  33. Memory_Size 
    An implementation-defined value that is intended to reflect
the memory size of the configuration in storage elements.
  34. Address is of a definite, nonlimited type. Address represents machine addresses capable of addressing individual storage elements. Null_Address is an address that is distinct from the address of any object or program unit.
  35. See section Bit Ordering, for an explanation of Bit_Order and Default_Bit_Order.

    Implementation Permissions

  36. An implementation may add additional implementation-defined declarations to package System and its children. However, it is usually better for the implementation to provide additional functionality via implementation-defined children of System. Package System may be declared pure.

    Implementation Advice

  37. Address should be of a private type. NOTES
  38. (14) There are also some language-defined child packages of System defined elsewhere.

The Package System.Storage_Elements

Static Semantics

  1. The following language-defined library package exists: 
  2. package System.Storage_Elements is
   pragma Preelaborate(System.Storage_Elements);

  3.    type Storage_Offset is range implementation-defined;

  4.    subtype Storage_Count is Storage_Offset
     range 0..Storage_Offset'Last;

  5.    type Storage_Element is mod implementation-defined;
   for Storage_Element'Size use Storage_Unit;
   type Storage_Array is array
     (Storage_Offset range <>) of aliased Storage_Element;
   for Storage_Array'Component_Size use Storage_Unit;

  6.    -- Address Arithmetic:

  7.    function "+"(Left : Address; Right : Storage_Offset)
     return Address;
   function "+"(Left : Storage_Offset; Right : Address)
     return Address;
   function "-"(Left : Address; Right : Storage_Offset)
     return Address;
   function "-"(Left, Right : Address)
     return Storage_Offset;

  8.    function "mod"(Left : Address; Right : Storage_Offset)
     return Storage_Offset;

  9.    -- Conversion to/from integers:

  10.    type Integer_Address is implementation-defined;
   function To_Address(Value : Integer_Address) return Address;
   function To_Integer(Value : Address) return Integer_Address;

  11.    pragma Convention(Intrinsic, "+");
      -- ...and so on for all language-defined subprograms
      -- declared in this package.
end System.Storage_Elements;
  12. Storage_Element represents a storage element. Storage_Offset represents an offset in storage elements. Storage_Count represents a number of storage elements. Storage_Array represents a contiguous sequence of storage elements.
  13. Integer_Address is a (signed or modular) integer subtype. To_Address and To_Integer convert back and forth between this type and Address.

    Implementation Requirements

  14. Storage_Offset'Last shall be greater than or equal to Integer'Last or the largest possible storage offset, whichever is smaller. Storage_Offset'First shall be <= (-Storage_Offset'Last).

    Implementation Permissions

  15. Package System.Storage_Elements may be declared pure.

    Implementation Advice

  16. Operations in System and its children should reflect the target environment semantics as closely as is reasonable. For example, on most machines, it makes sense for address arithmetic to "wrap around." Operations that do not make sense should raise Program_Error.

The Package System.Address_To_Access_Conversions

Static Semantics

  1. The following language-defined generic library package exists: 
  2. generic
    type Object(<>) is limited private;
package System.Address_To_Access_Conversions is
   pragma Preelaborate(Address_To_Access_Conversions);

  3.    type Object_Pointer is access all Object;
   function To_Pointer(Value : Address) return Object_Pointer;
   function To_Address(Value : Object_Pointer) return Address;

  4.    pragma Convention(Intrinsic, To_Pointer);
   pragma Convention(Intrinsic, To_Address);
end System.Address_To_Access_Conversions;
  5. The To_Pointer and To_Address subprograms convert back and forth between values of types Object_Pointer and Address. To_Pointer(X'Address) is equal to X'Unchecked_Access for any X that allows Unchecked_Access. To_Pointer(Null_Address) returns null. For other addresses, the behavior is unspecified. To_Address(null) returns Null_Address (for null of the appropriate type). To_Address(Y), where Y /= null, returns Y.all'Address.

    Implementation Permissions

  6. An implementation may place restrictions on instantiations of Address_To_Access_Conversions.

Machine Code Insertions

  1. A machine code insertion can be achieved by a call to a subprogram whose sequence_of_statements contains code_statements.

    Syntax 

  2. code_statement ::= qualified_expression;
    1. A code_statement is only allowed in the handled_sequence_of_statements of a subprogram_body. If a subprogram_body contains any code_statements, then within this subprogram_body the only allowed form of statement is a code_statement (labeled or not), the only allowed declarative_items are use_clauses, and no exception_handler is allowed (comments and pragmas are allowed as usual).

Name Resolution Rules

  1. The qualified_expression is expected to be of any type.

    Legality Rules

  2. The qualified_expression shall be of a type declared in package System.Machine_Code.
  3. A code_statement shall appear only within the scope of a with_clause that mentions package System.Machine_Code.

    Static Semantics

  4. The contents of the library package System.Machine_Code (if provided) are implementation defined. The meaning of code_statements is implementation defined. Typically, each qualified_expression represents a machine instruction or assembly directive.

    Implementation Permissions

  5. An implementation may place restrictions on code_statements. An implementation is not required to provide package System.Machine_Code. NOTES
  6. (15) An implementation may provide implementation-defined pragmas specifying register conventions and calling conventions.
  7. (16) Machine code functions are exempt from the rule that a return_statement is required. In fact, return_statements are forbidden, since only code_statements are allowed.
  8. (17) Intrinsic subprograms, see section Conformance Rules, can also be used to achieve machine code insertions. Interface to assembly language can be achieved using the features in Annex B, see section Interface to Other Languages (normative).

    Examples

  9. Example of a code statement: 
  10. M : Mask;
procedure Set_Mask; pragma Inline(Set_Mask);

  11. procedure Set_Mask is
  use System.Machine_Code;
  -- assume "with System.Machine_Code;" appears somewhere above
begin
  SI_Format'(Code => SSM, B => M'Base_Reg, D => M'Disp);
  --  Base_Reg and Disp are implementation-defined attributes
end Set_Mask;

Unchecked Type Conversions

  1. An unchecked type conversion can be achieved by a call to an instance of the generic function Unchecked_Conversion.

    Static Semantics

  2. The following language-defined generic library function exists: 
  3. generic
   type Source(<>) is limited private;
   type Target(<>) is limited private;
function Ada.Unchecked_Conversion(S : Source) return Target;
pragma Convention(Intrinsic, Ada.Unchecked_Conversion);
pragma Pure(Ada.Unchecked_Conversion);

    Dynamic Semantics

  4. The size of the formal parameter S in an instance of Unchecked_Conversion is that of its subtype. This is the actual subtype passed to Source, except when the actual is an unconstrained composite subtype, in which case the subtype is constrained by the bounds or discriminants of the value of the actual expression passed to S.
  5. If all of the following are true, the effect of an unchecked conversion is to return the value of an object of the target subtype whose representation is the same as that of the source object S:
    1. S'Size = Target'Size.
    2. S'Alignment = Target'Alignment.
    3. The target subtype is not an unconstrained composite subtype.
    4. S and the target subtype both have a contiguous representation.
    5. The representation of S is a representation of an object of the target subtype.
  1. Otherwise, the effect is implementation defined; in particular, the result can be abnormal, see section Data Validity.

    Implementation Permissions

  2. An implementation may return the result of an unchecked conversion by reference, if the Source type is not a by-copy type. In this case, the result of the unchecked conversion represents simply a different (read-only) view of the operand of the conversion.
  3. An implementation may place restrictions on Unchecked_Conversion.

    Implementation Advice

  4. The Size of an array object should not include its bounds; hence, the bounds should not be part of the converted data.
  5. The implementation should not generate unnecessary run-time checks to ensure that the representation of S is a representation of the target type. It should take advantage of the permission to return by reference when possible. Restrictions on unchecked conversions should be avoided unless required by the target environment.
  6. The recommended level of support for unchecked conversions is:
      Unchecked conversions should be supported and should be reversible in the cases where this clause defines the result. To enable meaningful use of unchecked conversion, a contiguous representation should be used for elementary subtypes, for statically constrained array subtypes whose component subtype is one of the subtypes described in this paragraph, and for record subtypes without discriminants whose component subtypes are described in this paragraph.

Data Validity

  1. Certain actions that can potentially lead to erroneous execution are not directly erroneous, but instead can cause objects to become abnormal. Subsequent uses of abnormal objects can be erroneous.
  2. A scalar object can have an invalid representation, which means that the object's representation does not represent any value of the object's subtype. The primary cause of invalid representations is uninitialized variables.
  3. Abnormal objects and invalid representations are explained in this subclause.

    Dynamic Semantics

  4. When an object is first created, and any explicit or default initializations have been performed, the object and all of its parts are in the normal state. Subsequent operations generally leave them normal. However, an object or part of an object can become abnormal in the following ways:
    1. An assignment to the object is disrupted due to an abort, see section Abort of a Task - Abort of a Sequence of Statements, or due to the failure of a language-defined check, see section Exceptions and Optimization.
    2. The object is not scalar, and is passed to an in out or out parameter of an imported procedure or language-defined input procedure, if after return from the procedure the representation of the parameter does not represent a value of the parameter's subtype.
  1. Whether or not an object actually becomes abnormal in these cases is not specified. An abnormal object becomes normal again upon successful completion of an assignment to the object as a whole.

    Erroneous Execution

  2. It is erroneous to evaluate a primary that is a name denoting an abnormal object, or to evaluate a prefix that denotes an abnormal object.

    Bounded (Run-Time) Errors

  3. If the representation of a scalar object does not represent a value of the object's subtype (perhaps because the object was not initialized), the object is said to have an invalid representation. It is a bounded error to evaluate the value of such an object. If the error is detected, either Constraint_Error or Program_Error is raised. Otherwise, execution continues using the invalid representation. The rules of the language outside this subclause assume that all objects have valid representations. The semantics of operations on invalid representations are as follows:
    1. If the representation of the object represents a value of the object's type, the value of the type is used.
    2. If the representation of the object does not represent a value of the object's type, the semantics of operations on such representations is implementation-defined, but does not by itself lead to erroneous or unpredictable execution, or to other objects becoming abnormal.

Erroneous Execution

  1. A call to an imported function or an instance of Unchecked_Conversion is erroneous if the result is scalar, and the result object has an invalid representation.
  2. The dereference of an access value is erroneous if it does not designate an object of an appropriate type or a subprogram with an appropriate profile, if it designates a nonexistent object, or if it is an access-to-variable value that designates a constant object. Such an access value can exist, for example, because of Unchecked_Deallocation, Unchecked_Access, or Unchecked_Conversion. NOTES
  3. (18) Objects can become abnormal due to other kinds of actions that directly update the object's representation; such actions are generally considered directly erroneous, however.

The Valid Attribute

  1. The Valid attribute can be used to check the validity of data produced by unchecked conversion, input, interface to foreign languages, and the like.

    Static Semantics

  2. For a prefix X that denotes a scalar object (after any implicit dereference), the following attribute is defined:
  3. X'Valid 
    Yields True if and only if the object denoted by X is normal
and has a valid representation. The value of this attribute
is of the predefined type Boolean.
    NOTES
  4. (19) Invalid data can be created in the following cases (not counting erroneous or unpredictable execution):
    1. an uninitialized scalar object,
    2. the result of an unchecked conversion,
    3. input,
    4. interface to another language (including machine code),
    5. aborting an assignment,
    6. disrupting an assignment due to the failure of a language-defined check (see section Exceptions and Optimization) and
    7. use of an object whose Address has been specified.
  1. (20) X'Valid is not considered to be a read of X; hence, it is not an error to check the validity of invalid data.

Unchecked Access Value Creation

  1. The attribute Unchecked_Access is used to create access values in an unsafe manner -- the programmer is responsible for preventing "dangling references."

    Static Semantics

  2. The following attribute is defined for a prefix X that denotes an aliased view of an object:
  3. X'Unchecked_Access 
    All rules and semantics that apply to X'Access, see section Operations of Access Types,
apply also to X'Unchecked_Access, except that, for the
purposes of accessibility rules and checks, it is as if X
were declared immediately within a library package.
    NOTES
  4. (21) This attribute is provided to support the situation where a local object is to be inserted into a global linked data structure, when the programmer knows that it will always be removed from the data structure prior to exiting the object's scope. The Access attribute would be illegal in this case, see section Operations of Access Types.
  5. (22) There is no Unchecked_Access attribute for subprograms.

Storage Management

  1. Each access-to-object type has an associated storage pool. The storage allocated by an allocator comes from the pool; instances of Unchecked_Deallocation return storage to the pool. Several access types can share the same pool.
  2. A storage pool is a variable of a type in the class rooted at Root_Storage_Pool, which is an abstract limited controlled type. By default, the implementation chooses a standard storage pool for each access type. The user may define new pool types, and may override the choice of pool for an access type by specifying Storage_Pool for the type.

    Legality Rules

  3. If Storage_Pool is specified for a given access type, Storage_Size shall not be specified for it.

    Static Semantics

  4. The following language-defined library package exists: 
  5. with Ada.Finalization;
with System.Storage_Elements;
package System.Storage_Pools is
    pragma Preelaborate(System.Storage_Pools);

  6.     type Root_Storage_Pool is
        abstract new
          Ada.Finalization.Limited_Controlled with private;

  7.     procedure Allocate(
      Pool : in out Root_Storage_Pool;
      Storage_Address : out Address;
      Size_In_Storage_Elements : in Storage_Elements.Storage_Count;
      Alignment : in Storage_Elements.Storage_Count) is abstract;

  8.     procedure Deallocate(
      Pool : in out Root_Storage_Pool;
      Storage_Address : in Address;
      Size_In_Storage_Elements : in Storage_Elements.Storage_Count;
      Alignment : in Storage_Elements.Storage_Count) is abstract;

  9.     function Storage_Size(Pool : Root_Storage_Pool)
        return Storage_Elements.Storage_Count is abstract;

  10. private
   ... -- not specified by the language
end System.Storage_Pools;
  11. A storage pool type (or pool type) is a descendant of Root_Storage_Pool. The elements of a storage pool are the objects allocated in the pool by allocators.
  12. For every access subtype S, the following attributes are defined:
  13. S'Storage_Pool 
    Denotes the storage pool of the type of S. The type of this
attribute is Root_Storage_Pool'Class.
  14. S'Storage_Size 
    Yields the result of calling Storage_Size(S'Storage_Pool),
which is intended to be a measure of the number of storage
elements reserved for the pool. The type of this attribute
is universal_integer.
  15. Storage_Size or Storage_Pool may be specified for a non-derived access-to-object type via an attribute_definition_clause; the name in a Storage_Pool clause shall denote a variable.
  16. An allocator of type T allocates storage from T's storage pool. If the storage pool is a user-defined object, then the storage is allocated by calling Allocate, passing T'Storage_Pool as the Pool parameter. The Size_In_Storage_Elements parameter indicates the number of storage elements to be allocated, and is no more than D'Max_Size_In_Storage_Elements, where D is the designated subtype. The Alignment parameter is D'Alignment. The result returned in the Storage_Address parameter is used by the allocator as the address of the allocated storage, which is a contiguous block of memory of Size_In_Storage_Elements storage elements. Any exception propagated by Allocate is propagated by the allocator.
  17. If Storage_Pool is not specified for a type defined by an access_to_object_definition, then the implementation chooses a standard storage pool for it in an implementation-defined manner. In this case, the exception Storage_Error is raised by an allocator if there is not enough storage. It is implementation defined whether or not the implementation provides user-accessible names for the standard pool type(s).
  18. If Storage_Size is specified for an access type, then the Storage_Size of this pool is at least that requested, and the storage for the pool is reclaimed when the master containing the declaration of the access type is left. If the implementation cannot satisfy the request, Storage_Error is raised at the point of the attribute_definition_clause. If neither Storage_Pool nor Storage_Size are specified, then the meaning of Storage_Size is implementation defined.
  19. If Storage_Pool is specified for an access type, then the specified pool is used.
  20. The effect of calling Allocate and Deallocate for a standard storage pool directly (rather than implicitly via an allocator or an instance of Unchecked_Deallocation) is unspecified.

    Erroneous Execution

  21. If Storage_Pool is specified for an access type, then if Allocate can satisfy the request, it should allocate a contiguous block of memory, and return the address of the first storage element in Storage_Address. The block should contain Size_In_Storage_Elements storage elements, and should be aligned according to Alignment. The allocated storage should not be used for any other purpose while the pool element remains in existence. If the request cannot be satisfied, then Allocate should propagate an exception (such as Storage_Error). If Allocate behaves in any other manner, then the program execution is erroneous.

    Documentation Requirements

  22. An implementation shall document the set of values that a user-defined Allocate procedure needs to accept for the Alignment parameter. An implementation shall document how the standard storage pool is chosen, and how storage is allocated by standard storage pools.

    Implementation Advice

  23. An implementation should document any cases in which it dynamically allocates heap storage for a purpose other than the evaluation of an allocator.
  24. A default (implementation-provided) storage pool for an access-to-constant type should not have overhead to support deallocation of individual objects.
  25. A storage pool for an anonymous access type should be created at the point of an allocator for the type, and be reclaimed when the designated object becomes inaccessible. NOTES
  26. (23) A user-defined storage pool type can be obtained by extending the Root_Storage_Pool type, and overriding the primitive subprograms Allocate, Deallocate, and Storage_Size. A user-defined storage pool can then be obtained by declaring an object of the type extension. The user can override Initialize and Finalize if there is any need for non-trivial initialization and finalization for a user-defined pool type. For example, Finalize might reclaim blocks of storage that are allocated separately from the pool object itself.
  27. (24) The writer of the user-defined allocation and deallocation procedures, and users of allocators for the associated access type, are responsible for dealing with any interactions with tasking. In particular:
    1. If the allocators are used in different tasks, they require mutual exclusion.
    2. If they are used inside protected objects, they cannot block.
    3. If they are used by interrupt handlers, see section Interrupt Support, the mutual exclusion mechanism has to work properly in that context.
  1. (25) The primitives Allocate, Deallocate, and Storage_Size are declared as abstract, see section Abstract Types and Subprograms, and therefore they have to be overridden when a new (non-abstract) storage pool type is declared.

    Examples

  2. To associate an access type with a storage pool object, the user first declares a pool object of some type derived from Root_Storage_Pool. Then, the user defines its Storage_Pool attribute, as follows: 
  3. Pool_Object : Some_Storage_Pool_Type;

  4. type T is access Designated;
for T'Storage_Pool use Pool_Object;
  5. Another access type may be added to an existing storage pool, via: 
  6. for T2'Storage_Pool use T'Storage_Pool;
  7. The semantics of this is implementation defined for a standard storage pool.
  8. As usual, a derivative of Root_Storage_Pool may define additional operations. For example, presuming that Mark_Release_Pool_Type has two additional operations, Mark and Release, the following is a possible use: 
  9. type Mark_Release_Pool_Type
   (Pool_Size : Storage_Elements.Storage_Count;
    Block_Size : Storage_Elements.Storage_Count)
        is new Root_Storage_Pool with limited private;

  10. ...

  11. MR_Pool : Mark_Release_Pool_Type (Pool_Size => 2000,
                                  Block_Size => 100);

  12. type Acc is access ...;
for Acc'Storage_Pool use MR_Pool;
...

  13. Mark(MR_Pool);
... -- Allocate objects using "new Designated(...)".
Release(MR_Pool); -- Reclaim the storage.

The Max_Size_In_Storage_Elements Attribute

  1. The Max_Size_In_Storage_Elements attribute is useful in writing user-defined pool types.

    Static Semantics

  2. For every subtype S, the following attribute is defined:
  3. S'Max_Size_In_Storage_Elements 
  4. Denotes the maximum value for Size_In_Storage_Elements that
will be requested via Allocate for an access type whose
designated subtype is S. The value of this attribute is of
type universal_integer.

Unchecked Storage Deallocation

  1. Unchecked storage deallocation of an object designated by a value of an access type is achieved by a call to an instance of the generic procedure Unchecked_Deallocation.

    Static Semantics

  2. The following language-defined generic library procedure exists: 
  3. generic
   type Object(<>) is limited private;
   type Name   is access  Object;
procedure Ada.Unchecked_Deallocation(X : in out Name);
pragma Convention(Intrinsic, Ada.Unchecked_Deallocation);
pragma Preelaborate(Ada.Unchecked_Deallocation);

    Dynamic Semantics

  4. Given an instance of Unchecked_Deallocation declared as follows: 
  5. procedure Free is
    new Ada.Unchecked_Deallocation
      (object_subtype_name, access_to_variable_subtype_name);
  6. Procedure Free has the following effect:
    1. After executing Free(X), the value of X is null.
    2. Free(X), when X is already equal to null, has no effect.
    3. Free(X), when X is not equal to null first performs finalization, as described in section User-Defined Assignment and Finalization. It then deallocates the storage occupied by the object designated by X. If the storage pool is a user-defined object, then the storage is deallocated by calling Deallocate, passing access_to_variable_subtype_name'Storage_Pool as the Pool parameter. Storage_Address is the value returned in the Storage_Address parameter of the corresponding Allocate call. Size_In_Storage_Elements and Alignment are the same values passed to the corresponding Allocate call. There is one exception: if the object being freed contains tasks, the object might not be deallocated.
  1. After Free(X), the object designated by X, and any subcomponents thereof, no longer exist; their storage can be reused for other purposes.

    Bounded (Run-Time) Errors

  2. It is a bounded error to free a discriminated, unterminated task object. The possible consequences are:
    1. No exception is raised.
    2. Program_Error or Tasking_Error is raised at the point of the deallocation.
    3. Program_Error or Tasking_Error is raised in the task the next time it references any of the discriminants.
  1. In the first two cases, the storage for the discriminants (and for any enclosing object if it is designated by an access discriminant of the task) is not reclaimed prior to task termination.

    Erroneous Execution

  2. Evaluating a name that denotes a nonexistent object is erroneous. The execution of a call to an instance of Unchecked_Deallocation is erroneous if the object was created other than by an allocator for an access type whose pool is Name'Storage_Pool.

    Implementation Advice

  3. For a standard storage pool, Free should actually reclaim the storage. NOTES
  4. (26) The rules here that refer to Free apply to any instance of Unchecked_Deallocation.
  5. (27) Unchecked_Deallocation cannot be instantiated for an access-to-constant type. This is implied by the rules of 12.5.4.

Pragma Controlled

  1. Pragma Controlled is used to prevent any automatic reclamation of storage (garbage collection) for the objects created by allocators of a given access type.

    Syntax

  2. The form of a pragma Controlled is as follows: 
  3. pragma Controlled(first_subtype_local_name);

    Legality Rules

  4. The first_subtype_local_name of a pragma Controlled shall denote a non-derived access subtype.

    Static Semantics

  5. A pragma Controlled is a representation pragma that specifies the controlled aspect of representation.
  6. Garbage collection is a process that automatically reclaims storage, or moves objects to a different address, while the objects still exist.
  7. If a pragma Controlled is specified for an access type with a standard storage pool, then garbage collection is not performed for objects in that pool.

    Implementation Permissions

  8. An implementation need not support garbage collection, in which case, a pragma Controlled has no effect.

Pragma Restrictions

  1. A pragma Restrictions expresses the user's intent to abide by certain restrictions. This may facilitate the construction of simpler run-time environments.

    Syntax

  2. The form of a pragma Restrictions is as follows: 
  3. pragma Restrictions(restriction{, restriction});

  4. restriction ::= restriction_identifier
   | restriction_parameter_identifier => expression

    Name Resolution Rules

  5. Unless otherwise specified for a particular restriction, the expression is expected to be of any integer type.

    Legality Rules

  6. Unless otherwise specified for a particular restriction, the expression shall be static, and its value shall be nonnegative.

    Static Semantics

  7. The set of restrictions is implementation defined.

    Post-Compilation Rules

  8. A pragma Restrictions is a configuration pragma; unless otherwise specified for a particular restriction, a partition shall obey the restriction if a pragma Restrictions applies to any compilation unit included in the partition.

    Implementation Permissions

  9. An implementation may place limitations on the values of the expression that are supported, and limitations on the supported combinations of restrictions. The consequences of violating such limitations are implementation defined. NOTES
  10. (28) Restrictions intended to facilitate the construction of efficient tasking run-time systems are defined in section Tasking Restrictions. Safety- and security-related restrictions are defined in section Safety and Security Restrictions.
  11. (29) An implementation has to enforce the restrictions in cases where enforcement is required, even if it chooses not to take advantage of the restrictions in terms of efficiency.

Streams

  1. A stream is a sequence of elements comprising values from possibly different types and allowing sequential access to these values. A stream type is a type in the class whose root type is Streams.Root_Stream_Type. A stream type may be implemented in various ways, such as an external sequential file, an internal buffer, or a network channel.

The Package Streams

Static Semantics

  1. The abstract type Root_Stream_Type is the root type of the class of stream types. The types in this class represent different kinds of streams. A new stream type is defined by extending the root type (or some other stream type), overriding the Read and Write operations, and optionally defining additional primitive subprograms, according to the requirements of the particular kind of stream. The predefined stream-oriented attributes like T'Read and T'Write make dispatching calls on the Read and Write procedures of the Root_Stream_Type. (User-defined T'Read and T'Write attributes can also make such calls, or can call the Read and Write attributes of other types.) 
  2. package Ada.Streams is
    pragma Pure(Streams);

  3.     type Root_Stream_Type is abstract tagged limited private;

  4.     type Stream_Element is mod implementation-defined;
    type Stream_Element_Offset is range implementation-defined;
    subtype Stream_Element_Count is
        Stream_Element_Offset range 0..Stream_Element_Offset'Last;
    type Stream_Element_Array is
        array(Stream_Element_Offset range <>) of Stream_Element;

  5.     procedure Read(
      Stream : in out Root_Stream_Type;
      Item   : out Stream_Element_Array;
      Last   : out Stream_Element_Offset) is abstract;

  6.     procedure Write(
      Stream : in out Root_Stream_Type;
      Item   : in Stream_Element_Array) is abstract;

  7. private
   ... -- not specified by the language
end Ada.Streams;
  8. The Read operation transfers Item'Length stream elements from the specified stream to fill the array Item. The index of the last stream element transferred is returned in Last. Last is less than Item'Last only if the end of the stream is reached.
  9. The Write operation appends Item to the specified stream. NOTES
  10. (30) See section The Package Streams.Stream_IO, for an example of extending type Root_Stream_Type.

Stream-Oriented Attributes

  1. The Write, Read, Output, and Input attributes convert values to a stream of elements and reconstruct values from a stream.

    Static Semantics

  2. For every subtype S of a specific type T, the following attributes are defined.
  3. S'Write 
    S'Write denotes a procedure with the following specification:

    1. procedure S'Write(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item : in T)
    2. S'Write writes the value of Item to Stream.
  1. S'Read 
    S'Read denotes a procedure with the following specification:

    1. procedure S'Read(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item : out T)
    2. S'Read reads the value of Item from Stream.
  1. For elementary types, the representation in terms of stream elements is implementation defined. For composite types, the Write or Read attribute for each component is called in a canonical order. The canonical order of components is last dimension varying fastest for an array, and positional aggregate order for a record. Bounds are not included in the stream if T is an array type. If T is a discriminated type, discriminants are included only if they have defaults. If T is a tagged type, the tag is not included.
  2. For every subtype S'Class of a class-wide type T'Class:
  3. S'Class'Write 
    S'Class'Write denotes a procedure with the following
specification:

    1. procedure S'Class'Write(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : in T'Class)
    2. Dispatches to the subprogram denoted by the Write attribute of the specific type identified by the tag of Item.
  1. S'Class'Read 
    S'Class'Read denotes a procedure with the following
specification:

    1. procedure S'Class'Read(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item : out T'Class)
    2. Dispatches to the subprogram denoted by the Read attribute of the specific type identified by the tag of Item.

Implementation Advice

  1. If a stream element is the same size as a storage element, then the normal in-memory representation should be used by Read and Write for scalar objects. Otherwise, Read and Write should use the smallest number of stream elements needed to represent all values in the base range of the scalar type.

    Static Semantics

  2. For every subtype S of a specific type T, the following attributes are defined.
  3. S'Output 
    S'Output denotes a procedure with the following specification:

    1. procedure S'Output(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item : in T)
    2. S'Output writes the value of Item to Stream, including any bounds or discriminants.
  1. S'Input 
    S'Input denotes a function with the following specification:

    1. function S'Input(
   Stream : access Ada.Streams.Root_Stream_Type'Class)
   return T
    2. S'Input reads and returns one value from Stream, using any bounds or discriminants written by a corresponding S'Output to determine how much to read.
  1. Unless overridden by an attribute_definition_clause, these subprograms execute as follows:
    1. If T is an array type, S'Output first writes the bounds, and S'Input first reads the bounds. If T has discriminants without defaults, S'Output first writes the discriminants (using S'Write for each), and S'Input first reads the discriminants (using S'Read for each).
    2. S'Output then calls S'Write to write the value of Item to the stream. S'Input then creates an object (with the bounds or discriminants, if any, taken from the stream), initializes it with S'Read, and returns the value of the object.
  1. For every subtype S'Class of a class-wide type T'Class:
  2. S'Class'Output 
    S'Class'Output denotes a procedure with the following
specification:

    1. procedure S'Class'Output(
   Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : in T'Class)
    2. First writes the external tag of Item to Stream (by calling String'Output(Tags.External_Tag(Item'Tag) -- see section Tagged Types and Type Extensions.) and then dispatches to the subprogram denoted by the Output attribute of the specific type identified by the tag.
  1. S'Class'Input 
    S'Class'Input denotes a function with the following
specification:

    1. function S'Class'Input(
   Stream : access Ada.Streams.Root_Stream_Type'Class)
   return T'Class
    2. First reads the external tag from Stream and determines the corresponding internal tag (by calling Tags.Internal_Tag(String'Input(Stream)) -- see section Tagged Types and Type Extensions.) and then dispatches to the subprogram denoted by the Input attribute of the specific type identified by the internal tag; returns that result.
  1. In the default implementation of Read and Input for a composite type, for each scalar component that is a discriminant or whose component_declaration includes a default_expression, a check is made that the value returned by Read for the component belongs to its subtype. Constraint_Error is raised if this check fails. For other scalar components, no check is made. For each component that is of an access type, if the implementation can detect that the value returned by Read for the component is not a value of its subtype, Constraint_Error is raised. If the value is not a value of its subtype and this error is not detected, the component has an abnormal value, and erroneous execution can result, see section Data Validity.
  2. The stream-oriented attributes may be specified for any type via an attribute_definition_clause. All nonlimited types have default implementations for these operations. An attribute_reference for one of these attributes is illegal if the type is limited, unless the attribute has been specified by an attribute_definition_clause. For an attribute_definition_clause specifying one of these attributes, the subtype of the Item parameter shall be the base subtype if scalar, and the first subtype otherwise. The same rule applies to the result of the Input function. NOTES
  3. (31) For a definite subtype S of a type T, only T'Write and T'Read are needed to pass an arbitrary value of the subtype through a stream. For an indefinite subtype S of a type T, T'Output and T'Input will normally be needed, since T'Write and T'Read do not pass bounds, discriminants, or tags.
  4. (32) User-specified attributes of S'Class are not inherited by other class-wide types descended from S.

    Examples

  5. Example of user-defined Write attribute: 
  6. procedure My_Write
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : My_Integer'Base);
for My_Integer'Write use My_Write;

Freezing Rules

  1. This clause defines a place in the program text where each declared entity becomes "frozen." A use of an entity, such as a reference to it by name, or (for a type) an expression of the type, causes freezing of the entity in some contexts, as described below. The Legality Rules forbid certain kinds of uses of an entity in the region of text where it is frozen.
  2. The freezing of an entity occurs at one or more places (freezing points) in the program text where the representation for the entity has to be fully determined. Each entity is frozen from its first freezing point to the end of the program text (given the ordering of compilation units defined in section The Compilation Process.
  3. The end of a declarative_part, protected_body, or a declaration of a library package or generic library package, causes freezing of each entity declared within it, except for incomplete types. A noninstance body causes freezing of each entity declared before it within the same declarative_part.
  4. A construct that (explicitly or implicitly) references an entity can cause the freezing of the entity, as defined by subsequent paragraphs. At the place where a construct causes freezing, each name, expression, or range within the construct causes freezing:
    1. The occurrence of a generic_instantiation causes freezing; also, if a parameter of the instantiation is defaulted, the default_expression or default_name for that parameter causes freezing.
    2. The occurrence of an object_declaration that has no corresponding completion causes freezing.
    3. The declaration of a record extension causes freezing of the parent subtype.
  1. A static expression causes freezing where it occurs. A nonstatic expression causes freezing where it occurs, unless the expression is part of a default_expression, a default_name, or a per-object expression of a component's constraint, in which case, the freezing occurs later as part of another construct.
  2. The following rules define which entities are frozen at the place where a construct causes freezing:
    1. At the place where an expression causes freezing, the type of the expression is frozen, unless the expression is an enumeration literal used as a discrete_choice of the array_aggregate of an enumeration_representation_clause.
    2. At the place where a name causes freezing, the entity denoted by the name is frozen, unless the name is a prefix of an expanded name; at the place where an object name causes freezing, the nominal subtype associated with the name is frozen.
    3. At the place where a range causes freezing, the type of the range is frozen.
    4. At the place where an allocator causes freezing, the designated subtype of its type is frozen. If the type of the allocator is a derived type, then all ancestor types are also frozen.
    5. At the place where a callable entity is frozen, each subtype of its profile is frozen. If the callable entity is a member of an entry family, the index subtype of the family is frozen. At the place where a function call causes freezing, if a parameter of the call is defaulted, the default_expression for that parameter causes freezing.
    6. At the place where a subtype is frozen, its type is frozen. At the place where a type is frozen, any expressions or names within the full type definition cause freezing; the first subtype, and any component subtypes, index subtypes, and parent subtype of the type are frozen as well. For a specific tagged type, the corresponding class-wide type is frozen as well. For a class-wide type, the corresponding specific type is frozen as well.

Legality Rules

  1. The explicit declaration of a primitive subprogram of a tagged type shall occur before the type is frozen, see section Dispatching Operations of Tagged Types.
  2. A type shall be completely defined before it is frozen (see section Completions of Declarations, and section Private Types and Private Extensions.).
  3. The completion of a deferred constant declaration shall occur before the constant is frozen, see section Deferred Constants.
  4. A representation item that directly specifies an aspect of an entity shall appear before the entity is frozen, see section Representation Items.

Predefined Language Environment (normative)

  1. This Annex contains the specifications of library units that shall be provided by every implementation. There are three root library units: Ada, Interfaces, and System; other library units are children of these: 
  2. Standard --  see section The Package Standard.
  Ada --  see section The Package Ada.
     Asynchronous_Task_Control --  see section Asynchronous Task Control.
     Calendar --  see section Delay Statements, Duration, and Time.
     Characters --  see section The Package Characters.
        Handling --  see section The Package Characters.Handling.
        Latin_1 --  see section The Package Characters.Latin_1.
     Command_Line --  see section The Package Command_Line.
     Decimal --  see section The Package Decimal.
     Direct_IO --  see section The Generic Package Direct_IO.
     Dynamic_Priorities --  see section Dynamic Priorities.
     Exceptions --  see section The Package Exceptions.
     Finalization --  see section User-Defined Assignment and Finalization.
     Interrupts --  see section The Package Interrupts.
        Names --  see section The Package Interrupts.
     IO_Exceptions --  see section Exceptions in Input-Output.
     Numerics --  see section The Numerics Packages.
        Complex_Elementary_Functions --  see section Complex Elementary Functions.
        Complex_Types --  see section Complex Types.
        Discrete_Random --  see section Random Number Generation.
        Elementary_Functions --  see section Elementary Functions.
        Float_Random --  see section Random Number Generation.
        Generic_Complex_Elementary_Functions --  see section Complex Elementary Functions.
        Generic_Complex_Types --  see section Complex Types.
        Generic_Elementary_Functions --  see section Elementary Functions.
     Real_Time --  see section Monotonic Time.
     Sequential_IO --  see section The Generic Package Sequential_IO.
     Storage_IO --  see section The Generic Package Storage_IO.
     Streams --  see section The Package Streams.
        Stream_IO --  see section The Package Streams.Stream_IO.
     Strings --  see section The Package Strings.
        Bounded --  see section Bounded-Length String Handling.
        Fixed --  see section Fixed-Length String Handling.
        Maps --  see section The Package Strings.Maps.
           Constants --  see section String-Handling Sets and Mappings.
        Unbounded --  see section Unbounded-Length String Handling.
        Wide_Bounded --  see section Wide_String Handling.
        Wide_Fixed --  see section Wide_String Handling.
        Wide_Maps --  see section Wide_String Handling.
           Wide_Constants --  see section Wide_String Handling.
        Wide_Unbounded --  see section Wide_String Handling.
Standard (...continued)
  Ada (...continued)
     Synchronous_Task_Control --  see section Synchronous Task Control.
     Tags --  see section Tagged Types and Type Extensions.
     Task_Attributes --  see section The Package Task_Attributes.
     Task_Identification --  see section The Package Task_Identification.
     Text_IO --  see section The Package Text_IO.
        Complex_IO --  see section Complex Input-Output.
        Editing --  see section The Package Text_IO.Editing.
        Text_Streams --  see section The Package Text_IO.Text_Streams.
     Unchecked_Conversion --  see section Unchecked Type Conversions.
     Unchecked_Deallocation --  see section Unchecked Storage Deallocation.
     Wide_Text_IO --  see section Wide Text Input-Output.
        Complex_IO --  see section Complex Input-Output.
        Editing --  see section The Package Wide_Text_IO.Editing.
        Text_Streams --  see section The Package Wide_Text_IO.Text_Streams.

  Interfaces --  see section The Package Interfaces.
     C --  see section Interfacing with C.
        Pointers --  see section The Generic Package Interfaces.C.Pointers.
        Strings --  see section The Package Interfaces.C.Strings.
     COBOL --  see section Interfacing with COBOL.
     Fortran --  see section Interfacing with Fortran.

  System --  see section The Package System.
     Address_To_Access_Conversions --  see section The Package System.Address_To_Access_Conversions.
     Machine_Code --  see section Machine Code Insertions.
     RPC --  see section Partition Communication Subsystem.
     Storage_Elements --  see section The Package System.Storage_Elements.
     Storage_Pools --  see section Storage Management.

    Implementation Requirements

  3. The implementation shall ensure that each language defined subprogram is reentrant in the sense that concurrent calls on the same subprogram perform as specified, so long as all parameters that could be passed by reference denote nonoverlapping objects.

    Implementation Permissions

  4. The implementation may restrict the replacement of language-defined compilation units. The implementation may restrict children of language-defined library units (other than Standard).

The Package Standard

  1. This clause outlines the specification of the package Standard containing all predefined identifiers in the language. The corresponding package body is not specified by the language.
  2. The operators that are predefined for the types declared in the package Standard are given in comments since they are implicitly declared. Italics are used for pseudo-names of anonymous types (such as root_real) and for undefined information (such as implementation-defined).

    Static Semantics

  3. The library package Standard has the following declaration: 
  4. package Standard is
   pragma Pure(Standard);

  5.    type Boolean is (False, True);

  6.    --  The predefined relational operators
   --  for this type are as follows:

  7.    -- function "="   (Left, Right : Boolean) return Boolean;
   -- function "/="  (Left, Right : Boolean) return Boolean;
   -- function "<"   (Left, Right : Boolean) return Boolean;
   -- function "<="  (Left, Right : Boolean) return Boolean;
   -- function ">"   (Left, Right : Boolean) return Boolean;
   -- function ">="  (Left, Right : Boolean) return Boolean;

  8.    --  The predefined logical operators and the predefined
   --  logical negation operator are as follows:

  9.    --  function "and" (Left, Right : Boolean) return Boolean;
   --  function "or"  (Left, Right : Boolean) return Boolean;
   --  function "xor" (Left, Right : Boolean) return Boolean;

  10.    --  function "not" (Right : Boolean) return Boolean;

  11.    --  The integer type root_integer is predefined.
   --  The corresponding universal type is universal_integer.

  12.    type Integer is range implementation-defined;

  13.    subtype Natural  is Integer range 0 .. Integer'Last;
   subtype Positive is Integer range 1 .. Integer'Last;

  14.    --  The predefined operators for type Integer are as follows:

  15.    --  function "="  (Left, Right : Integer'Base) return Boolean;
   --  function "/=" (Left, Right : Integer'Base) return Boolean;
   --  function "<"  (Left, Right : Integer'Base) return Boolean;
   --  function "<=" (Left, Right : Integer'Base) return Boolean;
   --  function ">"  (Left, Right : Integer'Base) return Boolean;
   --  function ">=" (Left, Right : Integer'Base) return Boolean;

  16.    --  function "+"   (Right : Integer'Base) return Integer'Base;
   --  function "-"   (Right : Integer'Base) return Integer'Base;
   --  function "abs" (Right : Integer'Base) return Integer'Base;

  17.    --  function "+"   (Left, Right : Integer'Base)
   --    return Integer'Base;
   --  function "-"   (Left, Right : Integer'Base)
   --    return Integer'Base;
   --  function "*"   (Left, Right : Integer'Base)
   --    return Integer'Base;
   --  function "/"   (Left, Right : Integer'Base)
   --    return Integer'Base;
   --  function "rem" (Left, Right : Integer'Base)
   --    return Integer'Base;
   --  function "mod" (Left, Right : Integer'Base)
   --    return Integer'Base;

  18.    --  function "**"
     (Left  : Integer'Base;
      Right : Natural) return Integer'Base;

  19.    --  The specification of each operator for the type
   --  root_integer, or for any additional predefined integer
   --  type, is obtained by replacing Integer by the name of the type
   --  in the specification of the corresponding operator of the type
   --  Integer. The right operand of the exponentiation operator
   --  remains as subtype Natural.

  20.    --  The floating point type root_real is predefined.
   --  The corresponding universal type is universal_real.

  21.    type Float is digits implementation-defined;

  22.    --  The predefined operators for this type are as follows:

  23.    --  function "="   (Left, Right : Float) return Boolean;
   --  function "/="  (Left, Right : Float) return Boolean;
   --  function "<"   (Left, Right : Float) return Boolean;
   --  function "<="  (Left, Right : Float) return Boolean;
   --  function ">"   (Left, Right : Float) return Boolean;
   --  function ">="  (Left, Right : Float) return Boolean;

  24.    --  function "+"   (Right : Float) return Float;
   --  function "-"   (Right : Float) return Float;
   --  function "abs" (Right : Float) return Float;

  25.    --  function "+"   (Left, Right : Float) return Float;
   --  function "-"   (Left, Right : Float) return Float;
   --  function "*"   (Left, Right : Float) return Float;
   --  function "/"   (Left, Right : Float) return Float;

  26.    --  function "**"
     (Left  : Float;
      Right : Integer'Base) return Float;

  27.    --  The specification of each operator for the type root_real,
   --  or  for any additional predefined floating point type, is
   --  obtained by replacing Float by the name of the type in the
   --  specification of the corresponding operator of the type Float.

  28.    --  In addition, the following operators are predefined for
   --  the root numeric types:

  29.    function "*" (Left : root_integer; Right : root_real)
     return root_real;

  30.    function "*" (Left : root_real; Right : root_integer)
     return root_real;

  31.    function "/" (Left : root_real; Right : root_integer)
     return root_real;

  32.    --  The type universal_fixed is predefined.
   --  The only multiplying operators defined between
   --  fixed point types are

  33.    function "*" (Left : universal_fixed; Right : universal_fixed)
     return universal_fixed;

  34.    function "/" (Left : universal_fixed; Right : universal_fixed)
     return universal_fixed;

   --  The declaration of type Character is based on the standard
   --  ISO 8859-1 character set.

  35.    --  There are no character literals corresponding to the
   --  positions for control characters. They are indicated in
   --  italics in this definition (see section Character Types).

   type Character is

     (nul,  soh,  stx,  etx, eot,  enq,  ack,  bel,
      bs,   ht,   lf,   vt,  ff,   cr,   so,   si,

      dle,  dc1,  dc2,  dc3, dc4,  nak,  syn,  etb,
      can,  em,   sub,  esc, fs,   gs,   rs,   us,

      ' ',  '!',  '"',  '#', '$',  '%',  '&',  "',
      '(',  ')',  '*',  '+', ',',  '-',  '.',  '/',

      '0',  '1',  '2',  '3', '4',  '5',  '6',  '7',
      '8',  '9',  ':',  ';', '<',  '=',  '>',  '?',

      '',  'A',  'B',  'C', 'D',  'E',  'F',  'G',
      'H',  'I',  'J',  'K', 'L',  'M',  'N',  'O',

      'P',  'Q',  'R',  'S', 'T',  'U',  'V',  'W',
      'X',  'Y',  'Z',  '[', '\',  ']',  '^',  '_',

      '`',  'a',  'b',  'c', 'd',  'e',  'f',  'g',
      'h',  'i',  'j',  'k', 'l',  'm',  'n',  'o',

      'p',  'q',  'r',  's', 't',  'u',  'v',  'w',
      'x',  'y',  'z',  '{', '|',  '}',  '~',  del,

      reserved_128, reserved_129,  bph,  nbh,
      reserved_132, nel,     ssa,  esa,

      hts, htj, vts, pld, plu, ri, ss2, ss3,

      dcs, pu1, pu2, sts, cch, mw, spa, epa,

      sos, reserved_153, sci, csi,
      st,  osc,          pm,  apc,

   ... );

  36.    --  The predefined operators for the type Character are the
   --  same as for any enumeration type.

   --  The declaration of type Wide_Character is based on the
   --  standard ISO 10646 BMP character set. The first 256 positions
   --  have the same contents as type Character (see section Character Types).

   type Wide_Character is (nul, soh ... FFFE, FFFF);

   package ASCII is ... end ASCII;  --Obsolescent;  (see section ASCII).

   -- Predefined string types:

  37.    type String is array(Positive range <>) of Character;
   pragma Pack(String);

  38.    -- The predefined operators for this type are as follows:

  39.    --  function "="  (Left, Right: String) return Boolean;
   --  function "/=" (Left, Right: String) return Boolean;
   --  function "<"  (Left, Right: String) return Boolean;
   --  function "<=" (Left, Right: String) return Boolean;
   --  function ">"  (Left, Right: String) return Boolean;
   --  function ">=" (Left, Right: String) return Boolean;

  40.    --  function "&" (Left: String;    Right: String)
   --    return String;
   --  function "&" (Left: Character; Right: String)
   --    return String;
   --  function "&" (Left: String;    Right: Character)
   --    return String;
   --  function "&" (Left: Character; Right: Character)
   --    return String;

  41.    type Wide_String is array(Positive range <>) of Wide_Character;
   pragma Pack(Wide_String);

  42.    --  The predefined operators for this type correspond to those
   --  for String

  43.    type Duration is delta
     implementation-defined range implementation-defined;

  44.    --  The predefined operators for the type Duration are the
   --  same as for any fixed point type.

  45.    -- The predefined exceptions:

  46.    Constraint_Error: exception;
   Program_Error   : exception;
   Storage_Error   : exception;
   Tasking_Error   : exception;

  47. end Standard;
  48. Standard has no private part.
  49. In each of the types Character and Wide_Character, the character literals for the space character (position 32) and the non-breaking space character (position 160) correspond to different values. Unless indicated otherwise, each occurrence of the character literal ' ' in this International Standard refers to the space character. Similarly, the character literals for hyphen (position 45) and soft hyphen (position 173) correspond to different values. Unless indicated otherwise, each occurrence of the character literal '-' in this International Standard refers to the hyphen character.

    Dynamic Semantics

  50. Elaboration of the body of Standard has no effect.

    Implementation Permissions

  51. An implementation may provide additional predefined integer types and additional predefined floating point types. Not all of these types need have names.

    Implementation Advice

  52. If an implementation provides additional named predefined integer types, then the names should end with "Integer" as in "Long_Integer". If an implementation provides additional named predefined floating point types, then the names should end with "Float" as in "Long_Float". NOTES
  53. (1) Certain aspects of the predefined entities cannot be completely described in the language itself. For example, although the enumeration type Boolean can be written showing the two enumeration literals False and True, the short-circuit control forms cannot be expressed in the language.
  54. (2) As explained in section Declarative Region, and section The Compilation Process, the declarative region of the package Standard encloses every library unit and consequently the main subprogram; the declaration of every library unit is assumed to occur within this declarative region. Library_items are assumed to be ordered in such a way that there are no forward semantic dependences. However, as explained in section Visibility, the only library units that are visible within a given compilation unit are the library units named by all with_clauses that apply to the given unit, and moreover, within the declarative region of a given library unit, that library unit itself.
  55. (3) If all block_statements of a program are named, then the name of each program unit can always be written as an expanded name starting with Standard (unless Standard is itself hidden). The name of a library unit cannot be a homograph of a name (such as Integer) that is already declared in Standard.
  56. (4) The exception Standard.Numeric_Error is defined in section Numeric_Error.

The Package Ada

Static Semantics

  1. The following language-defined library package exists: 
  2. package Ada is
    pragma Pure(Ada);
end Ada;
  3. Ada serves as the parent of most of the other language-defined library units; its declaration is empty (except for the pragma Pure).

    Legality Rules

  4. In the standard mode, it is illegal to compile a child of package Ada.

Character Handling

  1. This clause presents the packages related to character processing: an empty pure package Characters and child packages Characters.Handling and Characters.Latin_1. The package Characters.Handling provides classification and conversion functions for Character data, and some simple functions for dealing with Wide_Character data. The child package Characters.Latin_1 declares a set of constants initialized to values of type Character.

The Package Characters

Static Semantics

  1. The library package Characters has the following declaration: 
  2. package Ada.Characters is
  pragma Pure(Characters);
end Ada.Characters;

The Package Characters.Handling

Static Semantics

  1. The library package Characters.Handling has the following declaration: 
  2. package Ada.Characters.Handling is
  pragma Preelaborate(Handling);

  3.   --  Character classification functions

  4.   function Is_Control           (Item : in Character) return Boolean;
  function Is_Graphic           (Item : in Character) return Boolean;
  function Is_Letter            (Item : in Character) return Boolean;
  function Is_Lower             (Item : in Character) return Boolean;
  function Is_Upper             (Item : in Character) return Boolean;
  function Is_Basic             (Item : in Character) return Boolean;
  function Is_Digit             (Item : in Character) return Boolean;
  function Is_Decimal_Digit     (Item : in Character) return Boolean
    renames Is_Digit;
  function Is_Hexadecimal_Digit (Item : in Character) return Boolean;
  function Is_Alphanumeric      (Item : in Character) return Boolean;
  function Is_Special           (Item : in Character) return Boolean;

  5.   --  Conversion functions for Character and String

  6.   function To_Lower (Item : in Character) return Character;
  function To_Upper (Item : in Character) return Character;
  function To_Basic (Item : in Character) return Character;

  7.   function To_Lower (Item : in String) return String;
  function To_Upper (Item : in String) return String;
  function To_Basic (Item : in String) return String;

  8.   --  Classifications of and conversions
  --  between Character and ISO 646

  9.   subtype ISO_646 is
    Character range Character'Val(0) .. Character'Val(127);

  10.   function Is_ISO_646 (Item : in Character) return Boolean;
  function Is_ISO_646 (Item : in String)    return Boolean;

  11.   function To_ISO_646 (Item       : in Character;
                       Substitute : in ISO_646 := ' ')
    return ISO_646;

  12.   function To_ISO_646 (Item       : in String;
                       Substitute : in ISO_646 := ' ')
    return String;

  13.   --  Classifications of and conversions
  --  between Wide_Character and Character.

  14.  function Is_Character (Item : in Wide_Character) return Boolean;
 function Is_String    (Item : in Wide_String)    return Boolean;

  15.   function To_Character (Item       : in Wide_Character;
                         Substitute : in Character := ' ')
    return Character;

  16.   function To_String (Item       : in Wide_String;
                      Substitute : in Character := ' ')
    return String;

  17.   function To_Wide_Character (Item : in Character)
    return Wide_Character;

  18.   function To_Wide_String (Item : in String) return Wide_String;

  19. end Ada.Characters.Handling;
  20. In the description below for each function that returns a Boolean result, the effect is described in terms of the conditions under which the value True is returned. If these conditions are not met, then the function returns False.
  21. Each of the following classification functions has a formal Character parameter, Item, and returns a Boolean result.
  22. Is_Control 
    True if Item is a control character. A control character is
a character whose position is in one of the ranges 0..31 or
127..159.
  23. Is_Graphic 
    True if Item is a graphic character. A graphic character is
a character whose position is in one of the ranges 32..126 or
160..255.
  24. Is_Letter 
    True if Item is a letter. A letter is a character that is in
one of the ranges 'A'..'Z' or 'a'..'z', or whose position is
in one of the ranges 192..214, 216..246, or 248..255.
  25. Is_Lower 
    True if Item is a lower-case letter. A lower-case letter is
a character that is in the range 'a'..'z', or whose position
is in one of the ranges 223..246 or 248..255.
  26. Is_Upper 
    True if Item is an upper-case letter. An upper-case letter
is a character that is in the range 'A'..'Z' or whose
position is in one of the ranges 192..214 or 216.. 222.
  27. Is_Basic 
    True if Item is a basic letter. A basic letter is a
character that is in one of the ranges 'A'..'Z' and 'a'..'z',
or that is one of the following: an upper- or lower-case AE
diphthong, an upper- or lower-case Icelandic eth, an upper-
or lower-case Icelandic thorn, or a sharp-s.
  28. Is_Digit 
    True if Item is a decimal digit. A decimal digit is a
character in the range '0'..'9'.
  29. Is_Decimal_Digit 
    A renaming of Is_Digit.
  30. Is_Hexadecimal_Digit 
    True if Item is a hexadecimal digit. A hexadecimal digit is
a character that is either a decimal digit or that is in one
of the ranges 'A' .. 'F' or 'a' .. 'f'.
  31. Is_Alphanumeric 
    True if Item is an alphanumeric character. An alphanumeric
character is a character that is either a letter or a decimal
digit.
  32. Is_Special 
    True if Item is a special graphic character. A special
graphic character is a graphic character that is not
alphanumeric.
  33. Each of the names To_Lower, To_Upper, and To_Basic refers to two functions: one that converts from Character to Character, and the other that converts from String to String. The result of each Character-to-Character function is described below, in terms of the conversion applied to Item, its formal Character parameter. The result of each String-to-String conversion is obtained by applying to each element of the function's String parameter the corresponding Character-to-Character conversion; the result is the null String if the value of the formal parameter is the null String. The lower bound of the result String is 1.
  34. To_Lower 
    Returns the corresponding lower-case value for Item if
Is_Upper(Item), and returns Item otherwise.
  35. To_Upper 
    Returns the corresponding upper-case value for Item if
Is_Lower(Item) and Item has an upper-case form, and returns Item
otherwise. The lower case letters sharp-s and y-diaeresis do
not have upper case forms.
  36. To_Basic 
    Returns the letter corresponding to Item but with no
diacritical mark, if Item is a letter but not a basic letter;
returns Item otherwise.
  37. The following set of functions test for membership in the ISO 646 character range, or convert between ISO 646 and Character.
  38. Is_ISO_646 
    The function whose formal parameter, Item, is of type
Character returns True if Item is in the subtype ISO_646.
  39. Is_ISO_646 
    The function whose formal parameter, Item, is of type String
returns True if Is_ISO_646(Item(I)) is True for each I in
Item'Range.
  40. To_ISO_646 
    The function whose first formal parameter, Item, is of type
Character returns Item if Is_ISO_646(Item), and returns the
Substitute ISO_646 character otherwise.
  41. To_ISO_646 
    The function whose first formal parameter, Item, is of type
String returns the String whose Range is 1..Item'Length and
each of whose elements is given by To_ISO_646 of the
corresponding element in Item.
  42. The following set of functions test Wide_Character values for membership in Character, or convert between corresponding characters of Wide_Character and Character.
  43. Is_Character 
    Returns True if Wide_Character'Pos(Item) <=
Character'Pos(Character'Last).
  44. Is_String 
    Returns True if Is_Character(Item(I)) is True for each I in
Item'Range.
  45. To_Character 
    Returns the Character corresponding to Item if
Is_Character(Item), and returns the Substitute Character
otherwise.
  46. To_String 
    Returns the String whose range is 1..Item'Length and each of
whose elements is given by To_Character of the corresponding
element in Item.
  47. To_Wide_Character 
    Returns the Wide_Character X such that Character'Pos(Item) =
Wide_Character'Pos(X).
  48. To_Wide_String 
    Returns the Wide_String whose range is 1..Item'Length and
each of whose elements is given by To_Wide_Character of the
corresponding element in Item.

    Implementation Advice

  49. If an implementation provides a localized definition of Character or Wide_Character, then the effects of the subprograms in Characters.Handling should reflect the localizations. See also section Character Types. NOTES
  50. (5) A basic letter is a letter without a diacritical mark.
  51. (6) Except for the hexadecimal digits, basic letters, and ISO_646 characters, the categories identified in the classification functions form a strict hierarchy:
    1. Control characters
    2. Graphic characters
      1. Alphanumeric characters
        1. Letters
          1. Upper-case letters
          2. Lower-case letters
        1. Decimal digits
      1. Special graphic characters

The Package Characters.Latin_1

  1. The package Characters.Latin_1 declares constants for characters in ISO 8859-1.

    Static Semantics

  2. The library package Characters.Latin_1 has the following declaration: 
  3. package Ada.Characters.Latin_1 is
    pragma Pure(Latin_1);

  4.   -- Control characters:

  5.   NUL                  : constant Character := Character'Val(0);
  SOH                  : constant Character := Character'Val(1);
  STX                  : constant Character := Character'Val(2);
  ETX                  : constant Character := Character'Val(3);
  EOT                  : constant Character := Character'Val(4);
  ENQ                  : constant Character := Character'Val(5);
  ACK                  : constant Character := Character'Val(6);
  BEL                  : constant Character := Character'Val(7);
  BS                   : constant Character := Character'Val(8);
  HT                   : constant Character := Character'Val(9);
  LF                   : constant Character := Character'Val(10);
  VT                   : constant Character := Character'Val(11);
  FF                   : constant Character := Character'Val(12);
  CR                   : constant Character := Character'Val(13);
  SO                   : constant Character := Character'Val(14);
  SI                   : constant Character := Character'Val(15);

  6.   DLE                  : constant Character := Character'Val(16);
  DC1                  : constant Character := Character'Val(17);
  DC2                  : constant Character := Character'Val(18);
  DC3                  : constant Character := Character'Val(19);
  DC4                  : constant Character := Character'Val(20);
  NAK                  : constant Character := Character'Val(21);
  SYN                  : constant Character := Character'Val(22);
  ETB                  : constant Character := Character'Val(23);
  CAN                  : constant Character := Character'Val(24);
  EM                   : constant Character := Character'Val(25);
  SUB                  : constant Character := Character'Val(26);
  ESC                  : constant Character := Character'Val(27);
  FS                   : constant Character := Character'Val(28);
  GS                   : constant Character := Character'Val(29);
  RS                   : constant Character := Character'Val(30);
  US                   : constant Character := Character'Val(31);

  7.   -- ISO 646 graphic characters:

  8.   Space                : constant Character := ' ';
                         -- Character'Val(32)
  Exclamation          : constant Character := '!';
                         -- Character'Val(33)
  Quotation            : constant Character := '"';
                         -- Character'Val(34)
  Number_Sign          : constant Character := '#';
                         -- Character'Val(35)
  Dollar_Sign          : constant Character := '$';
                         -- Character'Val(36)
  Percent_Sign         : constant Character := '%';
                         -- Character'Val(37)
  Ampersand            : constant Character := '&';
                         -- Character'Val(38)
  Apostrophe           : constant Character := "';
                         -- Character'Val(39)
  Left_Parenthesis     : constant Character := '(';
                         -- Character'Val(40)
  Right_Parenthesis    : constant Character := ')';
                         -- Character'Val(41)
  Asterisk             : constant Character := '*';
                         -- Character'Val(42)
  Plus_Sign            : constant Character := '+';
                         -- Character'Val(43)
  Comma                : constant Character := ',';
                         -- Character'Val(44)
  Hyphen               : constant Character := '-';
                         -- Character'Val(45)
  Minus_Sign           : Character renames Hyphen;
  Full_Stop            : constant Character := '.';
                         -- Character'Val(46)
  Solidus              : constant Character := '/';
                         -- Character'Val(47)

  9.   -- Decimal digits '0' though '9' are at positions 48 through 57

  10.   Colon                : constant Character := ':';
                         -- Character'Val(58)
  Semicolon            : constant Character := ';';
                         -- Character'Val(59)
  Less_Than_Sign       : constant Character := '<';
                         -- Character'Val(60)
  Equals_Sign          : constant Character := '=';
                         -- Character'Val(61)
  Greater_Than_Sign    : constant Character := '>';
                         -- Character'Val(62)
  Question             : constant Character := '?';
                         -- Character'Val(63)
  Commercial_At        : constant Character := '';
                         -- Character'Val(64)

  11.   -- Letters 'A' through 'Z' are at positions 65 through 90

  12.   Left_Square_Bracket  : constant Character := '[';
                         -- Character'Val(91)
  Reverse_Solidus      : constant Character := '\';
                         -- Character'Val(92)
  Right_Square_Bracket : constant Character := ']';
                         -- Character'Val(93)
  Circumflex           : constant Character := '^';
                         -- Character'Val(94)
  Low_Line             : constant Character := '_';
                         -- Character'Val(95)

  13.   Grave                : constant Character := '`';
                         -- Character'Val(96)
  LC_A                 : constant Character := 'a';
                         -- Character'Val(97)
  LC_B                 : constant Character := 'b';
                         -- Character'Val(98)
  LC_C                 : constant Character := 'c';
                         -- Character'Val(99)
  LC_D                 : constant Character := 'd';
                         -- Character'Val(100)
  LC_E                 : constant Character := 'e';
                         -- Character'Val(101)
  LC_F                 : constant Character := 'f';
                         -- Character'Val(102)
  LC_G                 : constant Character := 'g';
                         -- Character'Val(103)
  LC_H                 : constant Character := 'h';
                         -- Character'Val(104)
  LC_I                 : constant Character := 'i';
                         -- Character'Val(105)
  LC_J                 : constant Character := 'j';
                         -- Character'Val(106)
  LC_K                 : constant Character := 'k';
                         -- Character'Val(107)
  LC_L                 : constant Character := 'l';
                         -- Character'Val(108)
  LC_M                 : constant Character := 'm';
                         -- Character'Val(109)
  LC_N                 : constant Character := 'n';
                         -- Character'Val(110)
  LC_O                 : constant Character := 'o';
                         -- Character'Val(111)

  14.   LC_P                 : constant Character := 'p';
                         -- Character'Val(112)
  LC_Q                 : constant Character := 'q';
                         -- Character'Val(113)
  LC_R                 : constant Character := 'r';
                         -- Character'Val(114)
  LC_S                 : constant Character := 's';
                         -- Character'Val(115)
  LC_T                 : constant Character := 't';
                         -- Character'Val(116)
  LC_U                 : constant Character := 'u';
                         -- Character'Val(117)
  LC_V                 : constant Character := 'v';
                         -- Character'Val(118)
  LC_W                 : constant Character := 'w';
                         -- Character'Val(119)
  LC_X                 : constant Character := 'x';
                         -- Character'Val(120)
  LC_Y                 : constant Character := 'y';
                         -- Character'Val(121)
  LC_Z                 : constant Character := 'z';
                         -- Character'Val(122)
  Left_Curly_Bracket   : constant Character := '{';
                         -- Character'Val(123)
  Vertical_Line        : constant Character := '|';
                         -- Character'Val(124)
  Right_Curly_Bracket  : constant Character := '}';
                         -- Character'Val(125)
  Tilde                : constant Character := '~';
                         -- Character'Val(126)
  DEL                  : constant Character := Character'Val(127);

  15.   -- ISO 6429 control characters:

  16.   IS4                  : Character renames FS;
  IS3                  : Character renames GS;
  IS2                  : Character renames RS;
  IS1                  : Character renames US;

  17.   Reserved_128         : constant Character := Character'Val(128);
  Reserved_129         : constant Character := Character'Val(129);
  BPH                  : constant Character := Character'Val(130);
  NBH                  : constant Character := Character'Val(131);
  Reserved_132         : constant Character := Character'Val(132);
  NEL                  : constant Character := Character'Val(133);
  SSA                  : constant Character := Character'Val(134);
  ESA                  : constant Character := Character'Val(135);
  HTS                  : constant Character := Character'Val(136);
  HTJ                  : constant Character := Character'Val(137);
  VTS                  : constant Character := Character'Val(138);
  PLD                  : constant Character := Character'Val(139);
  PLU                  : constant Character := Character'Val(140);
  RI                   : constant Character := Character'Val(141);
  SS2                  : constant Character := Character'Val(142);
  SS3                  : constant Character := Character'Val(143);

  18.   DCS                  : constant Character := Character'Val(144);
  PU1                  : constant Character := Character'Val(145);
  PU2                  : constant Character := Character'Val(146);
  STS                  : constant Character := Character'Val(147);
  CCH                  : constant Character := Character'Val(148);
  MW                   : constant Character := Character'Val(149);
  SPA                  : constant Character := Character'Val(150);
  EPA                  : constant Character := Character'Val(151);

  19.   SOS                  : constant Character := Character'Val(152);
  Reserved_153         : constant Character := Character'Val(153);
  SCI                  : constant Character := Character'Val(154);
  CSI                  : constant Character := Character'Val(155);
  ST                   : constant Character := Character'Val(156);
  OSC                  : constant Character := Character'Val(157);
  PM                   : constant Character := Character'Val(158);
  APC                  : constant Character := Character'Val(159);

  20.   -- Other graphic characters:

  21.   -- Character positions 160 (16#A0#) .. 175 (16#AF#):
  No_Break_Space              : constant Character := ' ';
                                -- Character'Val(160)
  NBSP                        : Character renames No_Break_Space;
  Inverted_Exclamation        : constant Character :=
    Character'Val(161);
  Cent_Sign                   : constant Character :=
    Character'Val(162);
  Pound_Sign                  : constant Character :=
    Character'Val(163);
  Currency_Sign               : constant Character :=
    Character'Val(164);
  Yen_Sign                    : constant Character :=
    Character'Val(165);
  Broken_Bar                  : constant Character :=
    Character'Val(166);
  Section_Sign                : constant Character :=
    Character'Val(167);
  Diaeresis                   : constant Character :=
    Character'Val(168);
  Copyright_Sign              : constant Character :=
    Character'Val(169);
  Feminine_Ordinal_Indicator  : constant Character :=
    Character'Val(170);
  Left_Angle_Quotation        : constant Character :=
    Character'Val(171);
  Not_Sign                    : constant Character :=
    Character'Val(172);
  Soft_Hyphen                 : constant Character :=
    Character'Val(173);
  Registered_Trade_Mark_Sign  : constant Character :=
    Character'Val(174);
  Macron                      : constant Character :=
    Character'Val(175);

  22.   -- Character positions 176 (16#B0#) .. 191 (16#BF#):
  Degree_Sign                 : constant Character :=
    Character'Val(176);
  Ring_Above                  : Character renames Degree_Sign;
  Plus_Minus_Sign             : constant Character :=
    Character'Val(177);
  Superscript_Two             : constant Character :=
    Character'Val(178);
  Superscript_Three           : constant Character :=
    Character'Val(179);
  Acute                       : constant Character :=
    Character'Val(180);
  Micro_Sign                  : constant Character :=
    Character'Val(181);
  Pilcrow_Sign                : constant Character :=
    Character'Val(182);
  Paragraph_Sign              : Character renames Pilcrow_Sign;
  Middle_Dot                  : constant Character :=
    Character'Val(183);
  Cedilla                     : constant Character :=
    Character'Val(184);
  Superscript_One             : constant Character :=
    Character'Val(185);
  Masculine_Ordinal_Indicator : constant Character :=
    Character'Val(186);
  Right_Angle_Quotation       : constant Character :=
    Character'Val(187);
  Fraction_One_Quarter        : constant Character :=
    Character'Val(188);
  Fraction_One_Half           : constant Character :=
    Character'Val(189);
  Fraction_Three_Quarters     : constant Character :=
    Character'Val(190);
  Inverted_Question           : constant Character :=
    Character'Val(191);

  23.   -- Character positions 192 (16#C0#) .. 207 (16#CF#):
  UC_A_Grave                  : constant Character :=
    Character'Val(192);
  UC_A_Acute                  : constant Character :=
    Character'Val(193);
  UC_A_Circumflex             : constant Character :=
    Character'Val(194);
  UC_A_Tilde                  : constant Character :=
    Character'Val(195);
  UC_A_Diaeresis              : constant Character :=
    Character'Val(196);
  UC_A_Ring                   : constant Character :=
    Character'Val(197);
  UC_AE_Diphthong             : constant Character :=
    Character'Val(198);
  UC_C_Cedilla                : constant Character :=
    Character'Val(199);
  UC_E_Grave                  : constant Character :=
    Character'Val(200);
  UC_E_Acute                  : constant Character :=
    Character'Val(201);
  UC_E_Circumflex             : constant Character :=
    Character'Val(202);
  UC_E_Diaeresis              : constant Character :=
    Character'Val(203);
  UC_I_Grave                  : constant Character :=
    Character'Val(204);
  UC_I_Acute                  : constant Character :=
    Character'Val(205);
  UC_I_Circumflex             : constant Character :=
    Character'Val(206);
  UC_I_Diaeresis              : constant Character :=
    Character'Val(207);

  24.   -- Character positions 208 (16#D0#) .. 223 (16#DF#):
  UC_Icelandic_Eth            : constant Character :=
    Character'Val(208);
  UC_N_Tilde                  : constant Character :=
    Character'Val(209);
  UC_O_Grave                  : constant Character :=
    Character'Val(210);
  UC_O_Acute                  : constant Character :=
    Character'Val(211);
  UC_O_Circumflex             : constant Character :=
    Character'Val(212);
  UC_O_Tilde                  : constant Character :=
    Character'Val(213);
  UC_O_Diaeresis              : constant Character :=
    Character'Val(214);
  Multiplication_Sign         : constant Character :=
    Character'Val(215);
  UC_O_Oblique_Stroke         : constant Character :=
    Character'Val(216);
  UC_U_Grave                  : constant Character :=
    Character'Val(217);
  UC_U_Acute                  : constant Character :=
    Character'Val(218);
  UC_U_Circumflex             : constant Character :=
    Character'Val(219);
  UC_U_Diaeresis              : constant Character :=
    Character'Val(220);
  UC_Y_Acute                  : constant Character :=
    Character'Val(221);
  UC_Icelandic_Thorn          : constant Character :=
    Character'Val(222);
  LC_German_Sharp_S           : constant Character :=
    Character'Val(223);

  25.   -- Character positions 224 (16#E0#) .. 239 (16#EF#):
  LC_A_Grave                  : constant Character :=
    Character'Val(224);
  LC_A_Acute                  : constant Character :=
    Character'Val(225);
  LC_A_Circumflex             : constant Character :=
    Character'Val(226);
  LC_A_Tilde                  : constant Character :=
    Character'Val(227);
  LC_A_Diaeresis              : constant Character :=
    Character'Val(228);
  LC_A_Ring                   : constant Character :=
    Character'Val(229);
  LC_AE_Diphthong             : constant Character :=
    Character'Val(230);
  LC_C_Cedilla                : constant Character :=
    Character'Val(231);
  LC_E_Grave                  : constant Character :=
    Character'Val(232);
  LC_E_Acute                  : constant Character :=
    Character'Val(233);
  LC_E_Circumflex             : constant Character :=
    Character'Val(234);
  LC_E_Diaeresis              : constant Character :=
    Character'Val(235);
  LC_I_Grave                  : constant Character :=
    Character'Val(236);
  LC_I_Acute                  : constant Character :=
    Character'Val(237);
  LC_I_Circumflex             : constant Character :=
    Character'Val(238);
  LC_I_Diaeresis              : constant Character :=
    Character'Val(239);

  26.   -- Character positions 240 (16#F0#) .. 255 (16#FF#):
  LC_Icelandic_Eth            : constant Character :=
    Character'Val(240);
  LC_N_Tilde                  : constant Character :=
    Character'Val(241);
  LC_O_Grave                  : constant Character :=
    Character'Val(242);
  LC_O_Acute                  : constant Character :=
    Character'Val(243);
  LC_O_Circumflex             : constant Character :=
    Character'Val(244);
  LC_O_Tilde                  : constant Character :=
    Character'Val(245);
  LC_O_Diaeresis              : constant Character :=
    Character'Val(246);
  Division_Sign               : constant Character :=
    Character'Val(247);
  LC_O_Oblique_Stroke         : constant Character :=
    Character'Val(248);
  LC_U_Grave                  : constant Character :=
    Character'Val(249);
  LC_U_Acute                  : constant Character :=
    Character'Val(250);
  LC_U_Circumflex             : constant Character :=
    Character'Val(251);
  LC_U_Diaeresis              : constant Character :=
    Character'Val(252);
  LC_Y_Acute                  : constant Character :=
    Character'Val(253);
  LC_Icelandic_Thorn          : constant Character :=
    Character'Val(254);
  LC_Y_Diaeresis              : constant Character :=
    Character'Val(255);
end Ada.Characters.Latin_1;

    Implementation Permissions

  27. An implementation may provide additional packages as children of Ada.Characters, to declare names for the symbols of the local character set or other character sets.

String Handling

  1. This clause presents the specifications of the package Strings and several child packages, which provide facilities for dealing with string data. Fixed-length, bounded-length, and unbounded-length strings are supported, for both String and Wide_String. The string-handling subprograms include searches for pattern strings and for characters in program-specified sets, translation (via a character-to-character mapping), and transformation (replacing, inserting, overwriting, and deleting of substrings).

The Package Strings

  1. The package Strings provides declarations common to the string handling packages.

    Static Semantics

  2. The library package Strings has the following declaration: 
  3. package Ada.Strings is
   pragma Pure(Strings);

  4.    Space      : constant Character      := ' ';
   Wide_Space : constant Wide_Character := ' ';

  5.    Length_Error, Pattern_Error, Index_Error, Translation_Error
     : exception;

  6.    type Alignment  is (Left, Right, Center);
   type Truncation is (Left, Right, Error);
   type Membership is (Inside, Outside);
   type Direction  is (Forward, Backward);
   type Trim_End   is (Left, Right, Both);
end Ada.Strings;

The Package Strings.Maps

  1. The package Strings.Maps defines the types, operations, and other entities needed for character sets and character-to-character mappings.

    Static Semantics

  2. The library package Strings.Maps has the following declaration: 
  3. package Ada.Strings.Maps is
   pragma Preelaborate(Maps);

  4.    -- Representation for a set of character values:
   type Character_Set is private;

  5.    Null_Set : constant Character_Set;

  6.    type Character_Range is
     record
        Low  : Character;
        High : Character;
     end record;
   -- Represents Character range Low..High

  7.    type Character_Ranges is
     array (Positive range <>) of Character_Range;

  8.    function To_Set (Ranges : in Character_Ranges)
     return Character_Set;

  9.    function To_Set (Span : in Character_Range)
     return Character_Set;

  10.    function To_Ranges (Set : in Character_Set)
     return Character_Ranges;

  11.    function "=" (Left, Right : in Character_Set) return Boolean;

  12.    function "not" (Right : in Character_Set)
     return Character_Set;
   function "and" (Left, Right : in Character_Set)
     return Character_Set;
   function "or"  (Left, Right : in Character_Set)
     return Character_Set;
   function "xor" (Left, Right : in Character_Set)
     return Character_Set;
   function "-"   (Left, Right : in Character_Set)
     return Character_Set;

  13.    function Is_In (Element : in Character;
                   Set     : in Character_Set)
      return Boolean;

  14.    function Is_Subset (Elements : in Character_Set;
                       Set      : in Character_Set)
      return Boolean;

  15.    function "<=" (Left  : in Character_Set;
                  Right : in Character_Set)
      return Boolean renames Is_Subset;

  16.    -- Alternative representation for a set of character values:
   subtype Character_Sequence is String;

  17.    function To_Set (Sequence : in Character_Sequence)
     return Character_Set;

  18.    function To_Set (Singleton : in Character) return Character_Set;

  19.    function To_Sequence (Set : in Character_Set)
     return Character_Sequence;

  20.    -- Representation for a character to character mapping:
   type Character_Mapping is private;

  21.    function Value (Map     : in Character_Mapping;
                   Element : in Character)
      return Character;

  22.    Identity : constant Character_Mapping;

  23.    function To_Mapping (From, To : in Character_Sequence)
     return Character_Mapping;

  24.    function To_Domain (Map : in Character_Mapping)
     return Character_Sequence;
   function To_Range  (Map : in Character_Mapping)
     return Character_Sequence;

  25.    type Character_Mapping_Function is
      access function (From : in Character) return Character;

  26. private
   ... -- not specified by the language
end Ada.Strings.Maps;
  27. An object of type Character_Set represents a set of characters.
  28. Null_Set represents the set containing no characters.
  29. An object Obj of type Character_Range represents the set of characters in the range Obj.Low .. Obj.High.
  30. An object Obj of type Character_Ranges represents the union of the sets corresponding to Obj(I) for I in Obj'Range. 
  31. function To_Set (Ranges : in Character_Ranges) return Character_Set;
    1. If Ranges'Length=0 then Null_Set is returned; otherwise the returned value represents the set corresponding to Ranges. 
  1. function To_Set (Span : in Character_Range) return Character_Set;
    1. The returned value represents the set containing each character in Span. 
  1. function To_Ranges (Set : in Character_Set) return Character_Ranges;
    1. If Set = Null_Set then an empty Character_Ranges array is returned; otherwise the shortest array of contiguous ranges of Character values in Set, in increasing order of Low, is returned. 
  1. function "=" (Left, Right : in Character_Set) return Boolean;
    1. The function "=" returns True if Left and Right represent identical sets, and False otherwise.
  1. Each of the logical operators "not", "and", "or", and "xor" returns a Character_Set value that represents the set obtained by applying the corresponding operation to the set(s) represented by the parameter(s) of the operator. "-"(Left, Right) is equivalent to "and"(Left, "not"(Right)). 
  2. function Is_In (Element : in Character;
                Set     : in Character_Set);
   return Boolean;
    1. Is_In returns True if Element is in Set, and False otherwise. 
  1. function Is_Subset (Elements : in Character_Set;
                    Set      : in Character_Set)
   return Boolean;
    1. Is_Subset returns True if Elements is a subset of Set, and False otherwise. 
  1. subtype Character_Sequence is String;
    1. The Character_Sequence subtype is used to portray a set of character values and also to identify the domain and range of a character mapping. 
  1. function To_Set (Sequence  : in Character_Sequence)
  return Character_Set;

function To_Set (Singleton : in Character)
  return Character_Set;
    1. Sequence portrays the set of character values that it explicitly contains (ignoring duplicates). Singleton portrays the set comprising a single Character. Each of the To_Set functions returns a Character_Set value that represents the set portrayed by Sequence or Singleton. 
  1. function To_Sequence (Set : in Character_Set)
  return Character_Sequence;
    1. The function To_Sequence returns a Character_Sequence value containing each of the characters in the set represented by Set, in ascending order with no duplicates. 
  1. type Character_Mapping is private;
    1. An object of type Character_Mapping represents a Character-to-Character mapping. 
  1. function Value (Map     : in Character_Mapping;
                Element : in Character)
   return Character;
    1. The function Value returns the Character value to which Element maps with respect to the mapping represented by Map.
  1. A character C matches a pattern character P with respect to a given Character_Mapping value Map if Value(Map, C) = P. A string S matches a pattern string P with respect to a given Character_Mapping if their lengths are the same and if each character in S matches its corresponding character in the pattern string P.
  2. String handling subprograms that deal with character mappings have parameters whose type is Character_Mapping. 
  3. Identity : constant Character_Mapping;
    1. Identity maps each Character to itself. 
  1. function To_Mapping (From, To : in Character_Sequence)
  return Character_Mapping;
    1. To_Mapping produces a Character_Mapping such that each element of From maps to the corresponding element of To, and each other character maps to itself. If From'Length /= To'Length, or if some character is repeated in From, then Translation_Error is propagated. 
  1. function To_Domain (Map : in Character_Mapping)
  return Character_Sequence;
    1. To_Domain returns the shortest Character_Sequence value D such that each character not in D maps to itself, and such that the characters in D are in ascending order. The lower bound of D is 1. 
  1. function To_Range (Map : in Character_Mapping)
  return Character_Sequence;
    1. To_Range returns the Character_Sequence value R, with lower bound 1 and upper bound Map'Length, such that if D = To_Domain(Map) then D(I) maps to R(I) for each I in D'Range.
  1. An object F of type Character_Mapping_Function maps a Character value C to the Character value F.all(C), which is said to match C with respect to mapping function F. NOTES
  2. (7) Character_Mapping and Character_Mapping_Function are used both for character equivalence mappings in the search subprograms (such as for case insensitivity) and as transformational mappings in the Translate subprograms.
  3. (8) To_Domain(Identity) and To_Range(Identity) each returns the null string.

    Examples

  4. To_Mapping("ABCD", "ZZAB") returns a Character_Mapping that maps 'A' and 'B' to 'Z', 'C' to 'A', 'D' to 'B', and each other Character to itself.

Fixed-Length String Handling

  1. The language-defined package Strings.Fixed provides string-handling subprograms for fixed-length strings; that is, for values of type Standard.String. Several of these subprograms are procedures that modify the contents of a String that is passed as an out or an in out parameter; each has additional parameters to control the effect when the logical length of the result differs from the parameter's length.
  2. For each function that returns a String, the lower bound of the returned value is 1.
  3. The basic model embodied in the package is that a fixed-length string comprises significant characters and possibly padding (with space characters) on either or both ends. When a shorter string is copied to a longer string, padding is inserted, and when a longer string is copied to a shorter one, padding is stripped. The Move procedure in Strings.Fixed, which takes a String as an out parameter, allows the programmer to control these effects. Similar control is provided by the string transformation procedures.

    Static Semantics

  4. The library package Strings.Fixed has the following declaration: 
  5. with Ada.Strings.Maps;
package Ada.Strings.Fixed is
   pragma Preelaborate(Fixed);

  6.    -- "Copy" procedure for strings of possibly different lengths

  7.    procedure Move (Source  : in  String;
                   Target  : out String;
                   Drop    : in  Truncation := Error;
                   Justify : in  Alignment  := Left;
                   Pad     : in  Character  := Space);

  8.    -- Search subprograms

  9.    function Index (Source   : in String;
                   Pattern  : in String;
                   Going    : in Direction := Forward;
                   Mapping  : in Maps.Character_Mapping
                                := Maps.Identity)
      return Natural;

  10.    function Index (Source   : in String;
                   Pattern  : in String;
                   Going    : in Direction := Forward;
                   Mapping  : in Maps.Character_Mapping_Function)
      return Natural;

  11.    function Index (Source : in String;
                   Set    : in Maps.Character_Set;
                   Test   : in Membership := Inside;
                   Going  : in Direction  := Forward)
      return Natural;

  12.    function Index_Non_Blank (Source : in String;
                             Going  : in Direction := Forward)
      return Natural;

  13.    function Count (Source   : in String;
                   Pattern  : in String;
                   Mapping  : in Maps.Character_Mapping
                                 := Maps.Identity)
      return Natural;

  14.    function Count (Source   : in String;
                   Pattern  : in String;
                   Mapping  : in Maps.Character_Mapping_Function)
      return Natural;

  15.    function Count (Source   : in String;
                   Set      : in Maps.Character_Set)
      return Natural;

  16.    procedure Find_Token (Source : in String;
                         Set    : in Maps.Character_Set;
                         Test   : in Membership;
                         First  : out Positive;
                         Last   : out Natural);

  17.    -- String translation subprograms

  18.    function Translate (Source  : in String;
                       Mapping : in Maps.Character_Mapping)
      return String;

  19.    procedure Translate (Source  : in out String;
                            Mapping : in Maps.Character_Mapping);

  20.    function Translate (Source  : in String;
                       Mapping : in Maps.Character_Mapping_Function)
      return String;

  21.    procedure Translate
     (Source  : in out String;
      Mapping : in Maps.Character_Mapping_Function);

  22.    -- String transformation subprograms

  23.    function Replace_Slice (Source   : in String;
                           Low      : in Positive;
                           High     : in Natural;
                           By       : in String)
      return String;

  24.    procedure Replace_Slice (Source   : in out String;
                            Low      : in Positive;
                            High     : in Natural;
                            By       : in String;
                            Drop     : in Truncation := Error;
                            Justify  : in Alignment  := Left;
                            Pad      : in Character  := Space);

  25.    function Insert (Source   : in String;
                    Before   : in Positive;
                    New_Item : in String)
      return String;

  26.    procedure Insert (Source   : in out String;
                     Before   : in Positive;
                     New_Item : in String;
                     Drop     : in Truncation := Error);

  27.    function Overwrite (Source   : in String;
                       Position : in Positive;
                       New_Item : in String)
      return String;

  28.    procedure Overwrite (Source   : in out String;
                        Position : in Positive;
                        New_Item : in String;
                        Drop     : in Truncation := Right);

  29.    function Delete (Source  : in String;
                    From    : in Positive;
                    Through : in Natural)
      return String;

  30.    procedure Delete (Source  : in out String;
                     From    : in Positive;
                     Through : in Natural;
                     Justify : in Alignment := Left;
                     Pad     : in Character := Space);

  31.    -- String selector subprograms

   function Trim (Source : in String;
                  Side   : in Trim_End)
      return String;

  32.    procedure Trim (Source  : in out String;
                   Side    : in Trim_End;
                   Justify : in Alignment := Left;
                   Pad     : in Character := Space);

  33.    function Trim (Source : in String;
                  Left   : in Maps.Character_Set;
                  Right  : in Maps.Character_Set)
      return String;

  34.    procedure Trim (Source  : in out String;
                   Left    : in Maps.Character_Set;
                   Right   : in Maps.Character_Set;
                   Justify : in Alignment := Strings.Left;
                   Pad     : in Character := Space);

  35.    function Head (Source : in String;
                  Count  : in Natural;
                  Pad    : in Character := Space)
      return String;

  36.    procedure Head (Source  : in out String;
                   Count   : in Natural;
                   Justify : in Alignment := Left;
                   Pad     : in Character := Space);

  37.    function Tail (Source : in String;
                  Count  : in Natural;
                  Pad    : in Character := Space)
      return String;

  38.    procedure Tail (Source  : in out String;
                   Count   : in Natural;
                   Justify : in Alignment := Left;
                   Pad     : in Character := Space);

  39.    --String constructor functions

  40.    function "*" (Left  : in Natural;
                 Right : in Character) return String;

  41.    function "*" (Left  : in Natural;
                 Right : in String) return String;

  42. end Ada.Strings.Fixed;
  43. The effects of the above subprograms are as follows. 
  44. procedure Move (Source  : in  String;
                Target  : out String;
                Drop    : in  Truncation := Error;
                Justify : in  Alignment  := Left;
                Pad     : in  Character  := Space);
    1. The Move procedure copies characters from Source to Target. If Source has the same length as Target, then the effect is to assign Source to Target. If Source is shorter than Target then:
      1. If Justify=Left, then Source is copied into the first Source'Length characters of Target.
      2. If Justify=Right, then Source is copied into the last Source'Length characters of Target.
      3. If Justify=Center, then Source is copied into the middle Source'Length characters of Target. In this case, if the difference in length between Target and Source is odd, then the extra Pad character is on the right.
      4. Pad is copied to each Target character not otherwise assigned.
    1. If Source is longer than Target, then the effect is based on Drop.
      1. If Drop=Left, then the rightmost Target'Length characters of Source are copied into Target.
      2. If Drop=Right, then the leftmost Target'Length characters of Source are copied into Target.
      3. If Drop=Error, then the effect depends on the value of the Justify parameter and also on whether any characters in Source other than Pad would fail to be copied:
        1. If Justify=Left, and if each of the rightmost Source'Length-Target'Length characters in Source is Pad, then the leftmost Target'Length characters of Source are copied to Target.
        2. If Justify=Right, and if each of the leftmost Source'Length-Target'Length characters in Source is Pad, then the rightmost Target'Length characters of Source are copied to Target.
        3. Otherwise, Length_Error is propagated. 
  1. function Index (Source   : in String;
                Pattern  : in String;
                Going    : in Direction := Forward;
                Mapping  : in Maps.Character_Mapping
                              := Maps.Identity)
   return Natural;

function Index (Source   : in String;
                Pattern  : in String;
                Going    : in Direction := Forward;
                Mapping  : in Maps.Character_Mapping_Function)
   return Natural;
    1. Each Index function searches for a slice of Source, with length Pattern'Length, that matches Pattern with respect to Mapping; the parameter Going indicates the direction of the lookup. If Going = Forward, then Index returns the smallest index I such that the slice of Source starting at I matches Pattern. If Going = Backward, then Index returns the largest index I such that the slice of Source starting at I matches Pattern. If there is no such slice, then 0 is returned. If Pattern is the null string then Pattern_Error is 
  1. function Index (Source : in String;
                Set    : in Maps.Character_Set;
                Test   : in Membership := Inside;
                Going  : in Direction  := Forward)
   return Natural;
    1. Index searches for the first or last occurrence of any of a set of characters (when Test=Inside), or any of the complement of a set of characters (when Test=Outside). It returns the smallest index I (if Going=Forward) or the largest index I (if Going=Backward) such that Source(I) satisfies the Test condition with respect to Set; it returns 0 if there is no such Character in Source. 
  1. function Index_Non_Blank (Source : in String;
                          Going  : in Direction := Forward)
   return Natural;
    1. Returns Index(Source, Maps.To_Set(Space), Outside, Going) 
  1. function Count (Source   : in String;
                Pattern  : in String;
                Mapping  : in Maps.Character_Mapping
                             := Maps.Identity)
   return Natural;

function Count (Source   : in String;
                Pattern  : in String;
                Mapping  : in Maps.Character_Mapping_Function)
   return Natural;
    1. Returns the maximum number of nonoverlapping slices of Source that match Pattern with respect to Mapping. If Pattern is the null string then Pattern_Error is propagated. 
  1. function Count (Source   : in String;
                Set      : in Maps.Character_Set)
   return Natural;
    1. Returns the number of occurrences in Source of characters that are in Set. 
  1. procedure Find_Token (Source : in String;
                      Set    : in Maps.Character_Set;
                      Test   : in Membership;
                      First  : out Positive;
                      Last   : out Natural);
    1. Find_Token returns in First and Last the indices of the beginning and end of the first slice of Source all of whose elements satisfy the Test condition, and such that the elements (if any) immediately before and after the slice do not satisfy the Test condition. If no such slice exists, then the value returned for Last is zero, and the value returned for First is Source'First. 
  1. function Translate (Source  : in String;
                    Mapping : in Maps.Character_Mapping)
   return String;

function Translate (Source  : in String;
                    Mapping : in Maps.Character_Mapping_Function)
   return String;
    1. Returns the string S whose length is Source'Length and such that S(I) is the character to which Mapping maps the corresponding element of Source, for I in 1..Source'Length. 
  1. procedure Translate (Source  : in out String;
                     Mapping : in Maps.Character_Mapping);

procedure Translate (Source  : in out String;
                     Mapping : in Maps.Character_Mapping_Function);
    1. Equivalent to Source := Translate(Source, Mapping). 
  1. function Replace_Slice (Source   : in String;
                        Low      : in Positive;
                        High     : in Natural;
                        By       : in String)
   return String;
    1. If Low > Source'Last+1, or High < Source'First-1, then Index_Error is propagated. Otherwise, if High >= Low then the returned string comprises Source(Source'First..Low-1) & By & Source(High+1..Source'Last), and if High < Low then the returned string is Insert(Source, Before=>Low, New_Item=>By). 
  1. procedure Replace_Slice (Source   : in out String;
                         Low      : in Positive;
                         High     : in Natural;
                         By       : in String;
                         Drop     : in Truncation := Error;
                         Justify  : in Alignment  := Left;
                         Pad      : in Character  := Space);
    1. Equivalent to Move(Replace_Slice(Source, Low, High, By), Source, Drop, Justify, Pad). 
  1. function Insert (Source   : in String;
                 Before   : in Positive;
                 New_Item : in String)
   return String;
      Propagates Index_Error if Before is not in Source'First .. Source'Last+1; otherwise returns Source(Source'First..Before-1) & New_Item & Source(Before..Source'Last), but with lower bound 1. 
  1. procedure Insert (Source   : in out String;
                  Before   : in Positive;
                  New_Item : in String;
                  Drop     : in Truncation := Error);
    1. Equivalent to Move(Insert(Source, Before, New_Item), Source, Drop). 
  1. function Overwrite (Source   : in String;
                    Position : in Positive;
                    New_Item : in String)
   return String;
    1. Propagates Index_Error if Position is not in Source'First .. Source'Last+1; otherwise returns the string obtained from Source by consecutively replacing characters starting at Position with corresponding characters from New_Item. If the end of Source is reached before the characters in New_Item are exhausted, the remaining characters from New_Item are appended to the string. 
  1. procedure Overwrite (Source   : in out String;
                     Position : in Positive;
                     New_Item : in String;
                     Drop     : in Truncation := Right);
    1. Equivalent to Move(Overwrite(Source, Position, New_Item), Source, Drop). 
  1. function Delete (Source  : in String;
                 From    : in Positive;
                 Through : in Natural)
   return String;
    1. If From <= Through, the returned string is Replace_Slice(Source, From, Through, ""), otherwise it is Source. 
  1. procedure Delete (Source  : in out String;
                  From    : in Positive;
                  Through : in Natural;
                  Justify : in Alignment := Left;
                  Pad     : in Character := Space);
    1. Equivalent to Move(Delete(Source, From, Through), Source, Justify => Justify, Pad => Pad). 
  1. function Trim (Source : in String;
               Side   : in Trim_End)
  return String;
    1. Returns the string obtained by removing from Source all leading Space characters (if Side = Left), all trailing Space characters (if Side = Right), or all leading and trailing Space characters (if Side = Both). 
  1. procedure Trim (Source  : in out String;
                Side    : in Trim_End;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);
    1. Equivalent to Move(Trim(Source, Side), Source, Justify=>Justify, Pad=>Pad). 
  1. function Trim (Source : in String;
               Left   : in Maps.Character_Set;
               Right  : in Maps.Character_Set)
   return String;
    1. Returns the string obtained by removing from Source all leading characters in Left and all trailing characters in Right. 
  1. procedure Trim (Source  : in out String;
                Left    : in Maps.Character_Set;
                Right   : in Maps.Character_Set;
                Justify : in Alignment := Strings.Left;
                Pad     : in Character := Space);
    1. Equivalent to Move(Trim(Source, Left, Right), Source, Justify => Justify, Pad=>Pad). 
  1. function Head (Source : in String;
               Count  : in Natural;
               Pad    : in Character := Space)
   return String;
    1. Returns a string of length Count. If Count <= Source'Length, the string comprises the first Count characters of Source. Otherwise its contents are Source concatenated with Count-Source'Length Pad characters. 
  1. procedure Head (Source  : in out String;
                Count   : in Natural;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);
    1. Equivalent to Move(Head(Source, Count, Pad), Source, Drop=>Error, Justify=>Justify, Pad=>Pad). 
  1. function Tail (Source : in String;
               Count  : in Natural;
               Pad    : in Character := Space)
   return String;
    1. Returns a string of length Count. If Count <= Source'Length, the string comprises the last Count characters of Source. Otherwise its contents are Count-Source'Length Pad characters concatenated with Source. 
  1. procedure Tail (Source  : in out String;
                Count   : in Natural;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);
    1. Equivalent to Move(Tail(Source, Count, Pad), Source, Drop=>Error, Justify=>Justify, Pad=>Pad). 
  1. function "*" (Left  : in Natural;
              Right : in Character) return String;

function "*" (Left  : in Natural;
              Right : in String) return String;
    1. These functions replicate a character or string a specified number of times. The first function returns a string whose length is Left and each of whose elements is Right. The second function returns a string whose length is Left*Right'Length and whose value is the null string if Left = 0 and is (Left-1)*Right & Right otherwise.
    NOTES
  1. (9) In the Index and Count functions taking Pattern and Mapping parameters, the actual String parameter passed to Pattern should comprise characters occurring as target characters of the mapping. Otherwise the pattern will not match.
  2. (10) In the Insert subprograms, inserting at the end of a string is obtained by passing Source'Last+1 as the Before parameter.
  3. (11) If a null Character_Mapping_Function is passed to any of the string handling subprograms, Constraint_Error is propagated.

Bounded-Length String Handling

  1. The language-defined package Strings.Bounded provides a generic package each of whose instances yields a private type Bounded_String and a set of operations. An object of a particular Bounded_String type represents a String whose low bound is 1 and whose length can vary conceptually between 0 and a maximum size established at the generic instantiation. The subprograms for fixed-length string handling are either overloaded directly for Bounded_String, or are modified as needed to reflect the variability in length. Additionally, since the Bounded_String type is private, appropriate constructor and selector operations are provided.

    Static Semantics

  2. The library package Strings.Bounded has the following declaration: 
  3. with Ada.Strings.Maps;
package Ada.Strings.Bounded is
   pragma Preelaborate(Bounded);

  4.    generic
      Max   : Positive;    -- Maximum length of a Bounded_String
   package Generic_Bounded_Length is

  5.       Max_Length : constant Positive := Max;

  6.       type Bounded_String is private;

  7.       Null_Bounded_String : constant Bounded_String;

  8.       subtype Length_Range is Natural range 0 .. Max_Length;

  9.       function Length (Source : in Bounded_String)
        return Length_Range;

  10.       -- Conversion, Concatenation, and Selection functions

  11.       function To_Bounded_String (Source : in String;
                                  Drop   : in Truncation := Error)
         return Bounded_String;

  12.       function To_String (Source : in Bounded_String) return String;

  13.       function Append (Left, Right : in Bounded_String;
                       Drop        : in Truncation  := Error)
         return Bounded_String;

  14.       function Append (Left  : in Bounded_String;
                       Right : in String;
                       Drop  : in Truncation := Error)
         return Bounded_String;

  15.       function Append (Left  : in String;
                       Right : in Bounded_String;
                       Drop  : in Truncation := Error)
         return Bounded_String;

  16.       function Append (Left  : in Bounded_String;
                       Right : in Character;
                       Drop  : in Truncation := Error)
         return Bounded_String;

  17.       function Append (Left  : in Character;
                       Right : in Bounded_String;
                       Drop  : in Truncation := Error)
         return Bounded_String;

  18.       procedure Append (Source   : in out Bounded_String;
                        New_Item : in Bounded_String;
                        Drop     : in Truncation  := Error);

  19.       procedure Append (Source   : in out Bounded_String;
                        New_Item : in String;
                        Drop     : in Truncation  := Error);

  20.       procedure Append (Source   : in out Bounded_String;
                        New_Item : in Character;
                        Drop     : in Truncation  := Error);

  21.       function "&" (Left, Right : in Bounded_String)
         return Bounded_String;

  22.       function "&" (Left : in Bounded_String; Right : in String)
         return Bounded_String;

  23.       function "&" (Left : in String; Right : in Bounded_String)
         return Bounded_String;

  24.       function "&" (Left : in Bounded_String; Right : in Character)
         return Bounded_String;

  25.       function "&" (Left : in Character; Right : in Bounded_String)
         return Bounded_String;

  26.       function Element (Source : in Bounded_String;
                        Index  : in Positive)
         return Character;

  27.       procedure Replace_Element (Source : in out Bounded_String;
                                 Index  : in Positive;
                                 By     : in Character);

  28.       function Slice (Source : in Bounded_String;
                      Low    : in Positive;
                      High   : in Natural)
         return String;

  29.       function "="  (Left, Right : in Bounded_String) return Boolean;
      function "="  (Left : in Bounded_String; Right : in String)
        return Boolean;

  30.       function "="  (Left : in String; Right : in Bounded_String)
        return Boolean;

  31.       function "<"  (Left, Right : in Bounded_String) return Boolean;

  32.       function "<"  (Left : in Bounded_String; Right : in String)
        return Boolean;

  33.       function "<"  (Left : in String; Right : in Bounded_String)
        return Boolean;

  34.       function "<=" (Left, Right : in Bounded_String) return Boolean;

  35.       function "<="  (Left : in Bounded_String; Right : in String)
        return Boolean;

  36.       function "<="  (Left : in String; Right : in Bounded_String)
        return Boolean;

  37.       function ">"  (Left, Right : in Bounded_String) return Boolean;

  38.       function ">"  (Left : in Bounded_String; Right : in String)
        return Boolean;

  39.       function ">"  (Left : in String; Right : in Bounded_String)
        return Boolean;

  40.       function ">=" (Left, Right : in Bounded_String) return Boolean;

  41.       function ">="  (Left : in Bounded_String; Right : in String)
        return Boolean;

  42.       function ">="  (Left : in String; Right : in Bounded_String)
        return Boolean;

  43.       -- Search functions

  44.       function Index (Source   : in Bounded_String;
                      Pattern  : in String;
                      Going    : in Direction := Forward;
                      Mapping  : in Maps.Character_Mapping
                                 := Maps.Identity)
         return Natural;

  45.       function Index (Source   : in Bounded_String;
                      Pattern  : in String;
                      Going    : in Direction := Forward;
                      Mapping  : in Maps.Character_Mapping_Function)
         return Natural;

  46.       function Index (Source : in Bounded_String;
                      Set    : in Maps.Character_Set;
                      Test   : in Membership := Inside;
                      Going  : in Direction  := Forward)
         return Natural;

  47.       function Index_Non_Blank (Source : in Bounded_String;
                                Going  : in Direction := Forward)
         return Natural;

  48.       function Count (Source   : in Bounded_String;
                      Pattern  : in String;
                      Mapping  : in Maps.Character_Mapping
                                   := Maps.Identity)
         return Natural;

  49.       function Count (Source   : in Bounded_String;
                      Pattern  : in String;
                      Mapping  : in Maps.Character_Mapping_Function)
         return Natural;

  50.       function Count (Source   : in Bounded_String;
                      Set      : in Maps.Character_Set)
         return Natural;

  51.       procedure Find_Token (Source : in Bounded_String;
                            Set    : in Maps.Character_Set;
                            Test   : in Membership;
                            First  : out Positive;
                            Last   : out Natural);

  52.       -- String translation subprograms

  53.       function Translate (Source  : in Bounded_String;
                          Mapping : in Maps.Character_Mapping)
         return Bounded_String;

  54.       procedure Translate (Source  : in out Bounded_String;
                           Mapping : in Maps.Character_Mapping);

  55.       function Translate
        (Source  : in Bounded_String;
         Mapping : in Maps.Character_Mapping_Function)
         return Bounded_String;

  56.       procedure Translate
        (Source  : in out Bounded_String;
         Mapping : in Maps.Character_Mapping_Function);

  57.       -- String transformation subprograms

  58.       function Replace_Slice (Source   : in Bounded_String;
                              Low      : in Positive;
                              High     : in Natural;
                              By       : in String;
                              Drop     : in Truncation := Error)
         return Bounded_String;

  59.       procedure Replace_Slice (Source   : in out Bounded_String;
                               Low      : in Positive;
                               High     : in Natural;
                               By       : in String;
                               Drop     : in Truncation := Error);

  60.       function Insert (Source   : in Bounded_String;
                       Before   : in Positive;
                       New_Item : in String;
                       Drop     : in Truncation := Error)
         return Bounded_String;

  61.       procedure Insert (Source   : in out Bounded_String;
                        Before   : in Positive;
                        New_Item : in String;
                        Drop     : in Truncation := Error);

  62.       function Overwrite (Source    : in Bounded_String;
                          Position  : in Positive;
                          New_Item  : in String;
                          Drop      : in Truncation := Error)
         return Bounded_String;

  63.       procedure Overwrite (Source    : in out Bounded_String;
                           Position  : in Positive;
                           New_Item  : in String;
                           Drop      : in Truncation := Error);

  64.       function Delete (Source  : in Bounded_String;
                       From    : in Positive;
                       Through : in Natural)
         return Bounded_String;

  65.       procedure Delete (Source  : in out Bounded_String;
                        From    : in Positive;
                        Through : in Natural);

  66.       -- String selector subprograms

  67.       function Trim (Source : in Bounded_String;
                     Side   : in Trim_End)
         return Bounded_String;

      procedure Trim (Source : in out Bounded_String;
                      Side   : in Trim_End);

  68.       function Trim (Source : in Bounded_String;
                     Left   : in Maps.Character_Set;
                     Right  : in Maps.Character_Set)
         return Bounded_String;

  69.       procedure Trim (Source : in out Bounded_String;
                      Left   : in Maps.Character_Set;
                      Right  : in Maps.Character_Set);

  70.       function Head (Source : in Bounded_String;
                     Count  : in Natural;
                     Pad    : in Character  := Space;
                     Drop   : in Truncation := Error)
         return Bounded_String;

  71.       procedure Head (Source : in out Bounded_String;
                      Count  : in Natural;
                      Pad    : in Character  := Space;
                      Drop   : in Truncation := Error);

  72.       function Tail (Source : in Bounded_String;
                     Count  : in Natural;
                     Pad    : in Character  := Space;
                     Drop   : in Truncation := Error)
         return Bounded_String;

  73.       procedure Tail (Source : in out Bounded_String;
                      Count  : in Natural;
                      Pad    : in Character  := Space;
                      Drop   : in Truncation := Error);

  74.       -- String constructor subprograms

  75.       function "*" (Left  : in Natural;
                    Right : in Character)
         return Bounded_String;

  76.       function "*" (Left  : in Natural;
                    Right : in String)
         return Bounded_String;

  77.       function "*" (Left  : in Natural;
                    Right : in Bounded_String)
         return Bounded_String;

  78.       function Replicate (Count : in Natural;
                          Item  : in Character;
                          Drop  : in Truncation := Error)
         return Bounded_String;

  79.       function Replicate (Count : in Natural;
                          Item  : in String;
                          Drop  : in Truncation := Error)
         return Bounded_String;

  80.       function Replicate (Count : in Natural;
                          Item  : in Bounded_String;
                          Drop  : in Truncation := Error)
         return Bounded_String;

  81.    private
       ... -- not specified by the language
   end Generic_Bounded_Length;

  82. end Ada.Strings.Bounded;
  83. Null_Bounded_String represents the null string. If an object of type Bounded_String is not otherwise initialized, it will be initialized to the same value as Null_Bounded_String. 
  84. function Length (Source : in Bounded_String) return Length_Range;
    1. The Length function returns the length of the string represented by Source. 
  1. function To_Bounded_String (Source : in String;
                            Drop   : in Truncation := Error)
   return Bounded_String;
    1. If Source'Length <= Max_Length then this function returns a Bounded_String that represents Source. Otherwise the effect depends on the value of Drop:
      1. If Drop=Left, then the result is a Bounded_String that represents the string comprising the rightmost Max_Length characters of Source.
      2. If Drop=Right, then the result is a Bounded_String that represents the string comprising the leftmost Max_Length characters of Source.
      3. If Drop=Error, then Strings.Length_Error is propagated. 
  1. function To_String (Source : in Bounded_String) return String;
    1. To_String returns the String value with lower bound 1 represented by Source. If B is a Bounded_String, then B = To_Bounded_String(To_String(B)).
  1. Each of the Append functions returns a Bounded_String obtained by concatenating the string or character given or represented by one of the parameters, with the string or character given or represented by the other parameter, and applying To_Bounded_String to the concatenation result string, with Drop as provided to the Append function.
  2. Each of the procedures Append(Source, New_Item, Drop) has the same effect as the corresponding assignment Source := Append(Source, New_Item, Drop).
  3. Each of the "&" functions has the same effect as the corresponding Append function, with Error as the Drop parameter. 
  4. function Element (Source : in Bounded_String;
                  Index  : in Positive)
   return Character;
    1. Returns the character at position Index in the string represented by Source; propagates Index_Error if Index > Length(Source). 
  1. procedure Replace_Element (Source : in out Bounded_String;
                           Index  : in Positive;
                           By     : in Character);
    1. Updates Source such that the character at position Index in the string represented by Source is By; propagates Index_Error if Index > Length(Source). 
  1. function Slice (Source : in Bounded_String;
                Low    : in Positive;
                High   : in Natural)
   return String;
    1. Returns the slice at positions Low through High in the string represented by Source; propagates Index_Error if Low > Length(Source)+1.
  1. Each of the functions "=", "<", ">","<=", and ">=" returns the same result as the corresponding String operation applied to the String values given or represented by the two parameters.
  2. Each of the search subprograms (Index, Index_Non_Blank, Count, Find_Token) has the same effect as the corresponding subprogram in Strings.Fixed applied to the string represented by the Bounded_String parameter.
  3. Each of the Translate subprograms, when applied to a Bounded_String, has an analogous effect to the corresponding subprogram in Strings.Fixed. For the Translate function, the translation is applied to the string represented by the Bounded_String parameter, and the result is converted (via To_Bounded_String) to a Bounded_String. For the Translate procedure, the string represented by the Bounded_String parameter after the translation is given by the Translate function for fixed-length strings applied to the string represented by the original value of the parameter.
  4. Each of the transformation subprograms (Replace_Slice, Insert, Overwrite, Delete), selector subprograms (Trim, Head, Tail), and constructor functions ("*") has an effect based on its corresponding subprogram in Strings.Fixed, and Replicate is based on Fixed."*". For each of these subprograms, the corresponding fixed-length string subprogram is applied to the string represented by the Bounded_String parameter. To_Bounded_String is applied the result string, with Drop (or Error in the case of Generic_Bounded_Length."*") determining the effect when the string length exceeds Max_Length.

    Implementation Advice

  5. Bounded string objects should not be implemented by implicit pointers and dynamic allocation.

Unbounded-Length String Handling

  1. The language-defined package Strings.Unbounded provides a private type Unbounded_String and a set of operations. An object of type Unbounded_String represents a String whose low bound is 1 and whose length can vary conceptually between 0 and Natural'Last. The subprograms for fixed-length string handling are either overloaded directly for Unbounded_String, or are modified as needed to reflect the flexibility in length. Since the Unbounded_String type is private, relevant constructor and selector operations are provided.

    Static Semantics

  2. The library package Strings.Unbounded has the following declaration: 
  3. with Ada.Strings.Maps;
package Ada.Strings.Unbounded is
   pragma Preelaborate(Unbounded);

  4.    type Unbounded_String is private;

  5.    Null_Unbounded_String : constant Unbounded_String;

  6.    function Length (Source : in Unbounded_String) return Natural;

  7.    type String_Access is access all String;
   procedure Free (X : in out String_Access);

  8.    -- Conversion, Concatenation, and Selection functions

  9.    function To_Unbounded_String (Source : in String)
      return Unbounded_String;

  10.    function To_Unbounded_String (Length : in Natural)
      return Unbounded_String;

  11.    function To_String (Source : in Unbounded_String) return String;

  12.    procedure Append (Source   : in out Unbounded_String;
                     New_Item : in Unbounded_String);

  13.    procedure Append (Source   : in out Unbounded_String;
                     New_Item : in String);

  14.    procedure Append (Source   : in out Unbounded_String;
                     New_Item : in Character);

  15.    function "&" (Left, Right : in Unbounded_String)
      return Unbounded_String;

  16.    function "&" (Left : in Unbounded_String; Right : in String)
      return Unbounded_String;

  17.    function "&" (Left : in String; Right : in Unbounded_String)
      return Unbounded_String;

  18.    function "&" (Left : in Unbounded_String; Right : in Character)
      return Unbounded_String;

  19.    function "&" (Left : in Character; Right : in Unbounded_String)
      return Unbounded_String;

  20.    function Element (Source : in Unbounded_String;
                     Index  : in Positive)
      return Character;

  21.    procedure Replace_Element (Source : in out Unbounded_String;
                              Index  : in Positive;
                              By     : in Character);

  22.    function Slice (Source : in Unbounded_String;
                   Low    : in Positive;
                   High   : in Natural)
      return String;

  23.    function "="  (Left, Right : in Unbounded_String) return Boolean;

  24.    function "="  (Left : in Unbounded_String; Right : in String)
     return Boolean;

  25.    function "="  (Left : in String; Right : in Unbounded_String)
     return Boolean;

  26.    function "<"  (Left, Right : in Unbounded_String) return Boolean;

  27.    function "<"  (Left : in Unbounded_String; Right : in String)
     return Boolean;

  28.    function "<"  (Left : in String; Right : in Unbounded_String)
     return Boolean;

  29.    function "<=" (Left, Right : in Unbounded_String) return Boolean;

  30.    function "<="  (Left : in Unbounded_String; Right : in String)
     return Boolean;

  31.    function "<="  (Left : in String; Right : in Unbounded_String)
     return Boolean;

  32.    function ">"  (Left, Right : in Unbounded_String) return Boolean;

  33.    function ">"  (Left : in Unbounded_String; Right : in String)
     return Boolean;

  34.    function ">"  (Left : in String; Right : in Unbounded_String)
     return Boolean;

  35.    function ">=" (Left, Right : in Unbounded_String) return Boolean;

  36.    function ">="  (Left : in Unbounded_String; Right : in String)
     return Boolean;

  37.    function ">="  (Left : in String; Right : in Unbounded_String)
     return Boolean;

  38.    -- Search subprograms

  39.    function Index (Source   : in Unbounded_String;
                   Pattern  : in String;
                   Going    : in Direction := Forward;
                   Mapping  : in Maps.Character_Mapping
                                := Maps.Identity)
      return Natural;

  40.    function Index (Source   : in Unbounded_String;
                   Pattern  : in String;
                   Going    : in Direction := Forward;
                   Mapping  : in Maps.Character_Mapping_Function)
      return Natural;

  41.    function Index (Source : in Unbounded_String;
                   Set    : in Maps.Character_Set;
                   Test   : in Membership := Inside;
                   Going  : in Direction  := Forward) return Natural;

  42.    function Index_Non_Blank (Source : in Unbounded_String;
                             Going  : in Direction := Forward)
      return Natural;

  43.    function Count (Source   : in Unbounded_String;
                   Pattern  : in String;
                   Mapping  : in Maps.Character_Mapping
                                := Maps.Identity)
      return Natural;

  44.    function Count (Source   : in Unbounded_String;
                   Pattern  : in String;
                   Mapping  : in Maps.Character_Mapping_Function)
      return Natural;

  45.    function Count (Source   : in Unbounded_String;
                   Set      : in Maps.Character_Set)
      return Natural;

  46.    procedure Find_Token (Source : in Unbounded_String;
                         Set    : in Maps.Character_Set;
                         Test   : in Membership;
                         First  : out Positive;
                         Last   : out Natural);

  47.    -- String translation subprograms

  48.    function Translate (Source  : in Unbounded_String;
                       Mapping : in Maps.Character_Mapping)
      return Unbounded_String;

  49.    procedure Translate (Source  : in out Unbounded_String;
                        Mapping : in Maps.Character_Mapping);

  50.    function Translate
     (Source  : in Unbounded_String;
      Mapping : in Maps.Character_Mapping_Function)
      return Unbounded_String;

  51.    procedure Translate
     (Source  : in out Unbounded_String;
      Mapping : in Maps.Character_Mapping_Function);

  52.    -- String transformation subprograms

  53.    function Replace_Slice (Source   : in Unbounded_String;
                           Low      : in Positive;
                           High     : in Natural;
                           By       : in String)
      return Unbounded_String;

  54.    procedure Replace_Slice (Source   : in out Unbounded_String;
                            Low      : in Positive;
                            High     : in Natural;
                            By       : in String);

  55.    function Insert (Source   : in Unbounded_String;
                    Before   : in Positive;
                    New_Item : in String)
      return Unbounded_String;

  56.    procedure Insert (Source   : in out Unbounded_String;
                     Before   : in Positive;
                     New_Item : in String);

  57.    function Overwrite (Source    : in Unbounded_String;
                       Position  : in Positive;
                       New_Item  : in String)
      return Unbounded_String;

  58.    procedure Overwrite (Source    : in out Unbounded_String;
                        Position  : in Positive;
                        New_Item  : in String);

  59.    function Delete (Source  : in Unbounded_String;
                    From    : in Positive;
                    Through : in Natural)
      return Unbounded_String;

  60.    procedure Delete (Source  : in out Unbounded_String;
                     From    : in Positive;
                     Through : in Natural);

  61.    function Trim (Source : in Unbounded_String;
                  Side   : in Trim_End)
      return Unbounded_String;

  62.    procedure Trim (Source : in out Unbounded_String;
                   Side   : in Trim_End);

  63.    function Trim (Source : in Unbounded_String;
                  Left   : in Maps.Character_Set;
                  Right  : in Maps.Character_Set)
      return Unbounded_String;

  64.    procedure Trim (Source : in out Unbounded_String;
                   Left   : in Maps.Character_Set;
                   Right  : in Maps.Character_Set);

  65.    function Head (Source : in Unbounded_String;
                  Count  : in Natural;
                  Pad    : in Character := Space)
      return Unbounded_String;

  66.    procedure Head (Source : in out Unbounded_String;
                   Count  : in Natural;
                   Pad    : in Character := Space);

  67.    function Tail (Source : in Unbounded_String;
                  Count  : in Natural;
                  Pad    : in Character := Space)
      return Unbounded_String;

  68.    procedure Tail (Source : in out Unbounded_String;
                   Count  : in Natural;
                   Pad    : in Character := Space);

  69.    function "*" (Left  : in Natural;
                 Right : in Character)
      return Unbounded_String;

  70.    function "*" (Left  : in Natural;
                 Right : in String)
      return Unbounded_String;

  71.    function "*" (Left  : in Natural;
                 Right : in Unbounded_String)
      return Unbounded_String;

  72. private
   ... -- not specified by the language
end Ada.Strings.Unbounded;
  73. Null_Unbounded_String represents the null String. If an object of type Unbounded_String is not otherwise initialized, it will be initialized to the same value as Null_Unbounded_String.
  74. The function Length returns the length of the String represented by Source.
  75. The type String_Access provides a (non-private) access type for explicit processing of unbounded-length strings. The procedure Free performs an unchecked deallocation of an object of type String_Access.
  76. The function To_Unbounded_String(Source : in String) returns an Unbounded_String that represents Source. The function To_Unbounded_String(Length : in Natural) returns an Unbounded_String that represents an uninitialized String whose length is Length.
  77. The function To_String returns the String with lower bound 1 represented by Source. To_String and To_Unbounded_String are related as follows:
    1. If S is a String, then To_String(To_Unbounded_String(S)) = S.
    2. If U is an Unbounded_String, then To_Unbounded_String(To_String(U)) = U.
  1. For each of the Append procedures, the resulting string represented by the Source parameter is given by the concatenation of the original value of Source and the value of New_Item.
  2. Each of the "&" functions returns an Unbounded_String obtained by concatenating the string or character given or represented by one of the parameters, with the string or character given or represented by the other parameter, and applying To_Unbounded_String to the concatenation result string.
  3. The Element, Replace_Element, and Slice subprograms have the same effect as the corresponding bounded-length string subprograms.
  4. Each of the functions "=", "<", ">","<=", and ">=" returns the same result as the corresponding String operation applied to the String values given or represented by Left and Right.
  5. Each of the search subprograms (Index, Index_Non_Blank, Count, Find_Token) has the same effect as the corresponding subprogram in Strings.Fixed applied to the string represented by the Unbounded_String parameter.
  6. The Translate function has an analogous effect to the corresponding subprogram in Strings.Fixed. The translation is applied to the string represented by the Unbounded_String parameter, and the result is converted (via To_Unbounded_String) to an Unbounded_String.
  7. Each of the transformation functions (Replace_Slice, Insert, Overwrite, Delete), selector functions (Trim, Head, Tail), and constructor functions ("*") is likewise analogous to its corresponding subprogram in Strings.Fixed. For each of the subprograms, the corresponding fixed-length string subprogram is applied to the string represented by the Unbounded_String parameter, and To_Unbounded_String is applied the result string.
  8. For each of the procedures Translate, Replace_Slice, Insert, Overwrite, Delete, Trim, Head, and Tail, the resulting string represented by the Source parameter is given by the corresponding function for fixed-length strings applied to the string represented by Source's original value.

    Implementation Requirements

  9. No storage associated with an Unbounded_String object shall be lost upon assignment or scope exit.

String-Handling Sets and Mappings

  1. The language-defined package Strings.Maps.Constants declares Character_Set and Character_Mapping constants corresponding to classification and conversion functions in package Characters.Handling.

    Static Semantics

  2. The library package Strings.Maps.Constants has the following declaration: 
  3. package Ada.Strings.Maps.Constants is
   pragma Preelaborate(Constants);

  4.    Control_Set           : constant Character_Set;
   Graphic_Set           : constant Character_Set;
   Letter_Set            : constant Character_Set;
   Lower_Set             : constant Character_Set;
   Upper_Set             : constant Character_Set;
   Basic_Set             : constant Character_Set;
   Decimal_Digit_Set     : constant Character_Set;
   Hexadecimal_Digit_Set : constant Character_Set;
   Alphanumeric_Set      : constant Character_Set;
   Special_Set           : constant Character_Set;
   ISO_646_Set           : constant Character_Set;

  5.    Lower_Case_Map        : constant Character_Mapping;
     --Maps to lower case for letters, else identity
   Upper_Case_Map        : constant Character_Mapping;
     --Maps to upper case for letters, else identity
   Basic_Map             : constant Character_Mapping;
     --Maps to basic letter for letters, else identity

  6. private
   ... -- not specified by the language
end Ada.Strings.Maps.Constants;
  7. Each of these constants represents a correspondingly named set of characters or character mapping in Characters.Handling, see section The Package Characters.Handling.

Wide_String Handling

  1. Facilities for handling strings of Wide_Character elements are found in the packages Strings.Wide_Maps, Strings.Wide_Fixed, Strings.Wide_Bounded, Strings.Wide_Unbounded, and Strings.Wide_Maps.Wide_Constants. They provide the same string-handling operations as the corresponding packages for strings of Character elements.

    Static Semantics

  2. The package Strings.Wide_Maps has the following declaration. 
  3. package Ada.Strings.Wide_Maps is
   pragma Preelaborate(Wide_Maps);

  4.    -- Representation for a set of Wide_Character values:
   type Wide_Character_Set is private;

  5.    Null_Set : constant Wide_Character_Set;

  6.    type Wide_Character_Range is
     record
         Low  : Wide_Character;
         High : Wide_Character;
     end record;
   -- Represents Wide_Character range Low..High

  7.    type Wide_Character_Ranges is array (Positive range <>)
     of Wide_Character_Range;

  8.    function To_Set (Ranges : in Wide_Character_Ranges)
     return Wide_Character_Set;

  9.    function To_Set (Span : in Wide_Character_Range)
     return Wide_Character_Set;

  10.    function To_Ranges (Set : in Wide_Character_Set)
     return Wide_Character_Ranges;

  11.    function "=" (Left, Right : in Wide_Character_Set) return Boolean;

  12.    function "not" (Right : in Wide_Character_Set)
     return Wide_Character_Set;
   function "and" (Left, Right : in Wide_Character_Set)
     return Wide_Character_Set;
   function "or"  (Left, Right : in Wide_Character_Set)
     return Wide_Character_Set;
   function "xor" (Left, Right : in Wide_Character_Set)
     return Wide_Character_Set;
   function "-"   (Left, Right : in Wide_Character_Set)
     return Wide_Character_Set;

  13.    function Is_In (Element : in Wide_Character;
                   Set     : in Wide_Character_Set)
      return Boolean;

  14.    function Is_Subset (Elements : in Wide_Character_Set;
                       Set      : in Wide_Character_Set)
      return Boolean;

  15.    function "<=" (Left  : in Wide_Character_Set;
                  Right : in Wide_Character_Set)
      return Boolean renames Is_Subset;

  16.    -- Alternative representation for a set of Wide_Character values:
   subtype Wide_Character_Sequence is Wide_String;

  17.    function To_Set (Sequence : in Wide_Character_Sequence)
     return Wide_Character_Set;

  18.    function To_Set (Singleton : in Wide_Character)
     return Wide_Character_Set;

  19.    function To_Sequence (Set : in Wide_Character_Set)
     return Wide_Character_Sequence;

  20.    -- Representation for a Wide_Character to Wide_Character mapping:
   type Wide_Character_Mapping is private;

  21.    function Value (Map     : in Wide_Character_Mapping;
                   Element : in Wide_Character)
      return Wide_Character;

  22.    Identity : constant Wide_Character_Mapping;

  23.    function To_Mapping (From, To : in Wide_Character_Sequence)
      return Wide_Character_Mapping;

  24.    function To_Domain (Map : in Wide_Character_Mapping)
      return Wide_Character_Sequence;

  25.    function To_Range  (Map : in Wide_Character_Mapping)
      return Wide_Character_Sequence;

  26.    type Wide_Character_Mapping_Function is access
      function (From : in Wide_Character) return Wide_Character;

  27. private
   ... -- not specified by the language
end Ada.Strings.Wide_Maps;
  28. The context clause for each of the packages Strings.Wide_Fixed, Strings.Wide_Bounded, and Strings.Wide_Unbounded identifies Strings.Wide_Maps instead of Strings.Maps.
  29. For each of the packages Strings.Fixed, Strings.Bounded, Strings.Unbounded, and Strings.Maps.Constants the corresponding wide string package has the same contents except that
    1. Wide_Space replaces Space
    2. Wide_Character replaces Character
    3. Wide_String replaces String
    4. Wide_Character_Set replaces Character_Set
    5. Wide_Character_Mapping replaces Character_Mapping
    6. Wide_Character_Mapping_Function replaces Character_Mapping_Function
    7. Wide_Maps replaces Maps
    8. Bounded_Wide_String replaces Bounded_String
    9. Null_Bounded_Wide_String replaces Null_Bounded_String
    10. To_Bounded_Wide_String replaces To_Bounded_String
    11. To_Wide_String replaces To_String
    12. Unbounded_Wide_String replaces Unbounded_String
    13. Null_Unbounded_Wide_String replaces Null_Unbounded_String
    14. Wide_String_Access replaces String_Access
    15. To_Unbounded_Wide_String replaces To_Unbounded_String
  1. The following additional declaration is present in Strings.Wide_Maps.Wide_Constants: 
  2. Character_Set : constant Wide_Maps.Wide_Character_Set;
--  Contains each Wide_Character value WC such that
--  Characters.Is_Character(WC) is True
    NOTES
  3. (12) If a null Wide_Character_Mapping_Function is passed to any of the Wide_String handling subprograms, Constraint_Error is propagated.
  4. (13) Each Wide_Character_Set constant in the package Strings.Wide_Maps.Wide_Constants contains no values outside the Character portion of Wide_Character. Similarly, each Wide_Character_Mapping constant in this package is the identity mapping when applied to any element outside the Character portion of Wide_Character.

The Numerics Packages

  1. The library package Numerics is the parent of several child units that provide facilities for mathematical computation. One child, the generic package Generic_Elementary_Functions, is defined in section Elementary Functions, together with nongeneric equivalents; two others, the package Float_Random and the generic package Discrete_Random, are defined in section Random Number Generation. Additional (optional) children are defined in section Numerics (normative).

    Static Semantics 

  1. package Ada.Numerics is
   pragma Pure(Numerics);
   Argument_Error : exception;
   Pi : constant :=
     3.14159_26535_89793_23846_26433_83279_50288_41971_69399_37511;
   e  : constant :=
     2.71828_18284_59045_23536_02874_71352_66249_77572_47093_69996;
end Ada.Numerics;
  2. The Argument_Error exception is raised by a subprogram in a child unit of Numerics to signal that one or more of the actual subprogram parameters are outside the domain of the corresponding mathematical function.

    Implementation Permissions

  3. The implementation may specify the values of Pi and e to a larger number of significant digits.

Elementary Functions

  1. Implementation-defined approximations to the mathematical functions known as the "elementary functions" are provided by the subprograms in Numerics.Generic_Elementary_Functions. Nongeneric equivalents of this generic package for each of the predefined floating point types are also provided as children of Numerics.

    Static Semantics

  2. The generic library package Numerics.Generic_Elementary_Functions has the following declaration: 
  3. generic
   type Float_Type is digits <>;
package Ada.Numerics.Generic_Elementary_Functions is
   pragma Pure(Generic_Elementary_Functions);

  4.    function Sqrt (X       : Float_Type'Base) return Float_Type'Base;
   function Log  (X       : Float_Type'Base) return Float_Type'Base;
   function Log  (X, Base : Float_Type'Base) return Float_Type'Base;
   function Exp  (X       : Float_Type'Base) return Float_Type'Base;
   function "**" (Left, Right : Float_Type'Base)
     return Float_Type'Base;

  5.    function Sin (X        : Float_Type'Base) return Float_Type'Base;
   function Sin (X, Cycle : Float_Type'Base) return Float_Type'Base;
   function Cos (X        : Float_Type'Base) return Float_Type'Base;
   function Cos (X, Cycle : Float_Type'Base) return Float_Type'Base;
   function Tan (X        : Float_Type'Base) return Float_Type'Base;
   function Tan (X, Cycle : Float_Type'Base) return Float_Type'Base;
   function Cot (X        : Float_Type'Base) return Float_Type'Base;
   function Cot (X, Cycle : Float_Type'Base) return Float_Type'Base;

  6.    function Arcsin (X        : Float_Type'Base)
     return Float_Type'Base;
   function Arcsin (X, Cycle : Float_Type'Base)
     return Float_Type'Base;
   function Arccos (X        : Float_Type'Base)
     return Float_Type'Base;
   function Arccos (X, Cycle : Float_Type'Base)
     return Float_Type'Base;
   function Arctan (Y        : Float_Type'Base;
                    X        : Float_Type'Base := 1.0)
     return Float_Type'Base;
   function Arctan (Y        : Float_Type'Base;
                    X        : Float_Type'Base := 1.0;
                    Cycle    : Float_Type'Base)
     return Float_Type'Base;
   function Arccot (X        : Float_Type'Base;
                    Y        : Float_Type'Base := 1.0)
     return Float_Type'Base;
   function Arccot (X        : Float_Type'Base;
                    Y        : Float_Type'Base := 1.0;
                    Cycle    : Float_Type'Base)
     return Float_Type'Base;

  7.    function Sinh    (X : Float_Type'Base) return Float_Type'Base;
   function Cosh    (X : Float_Type'Base) return Float_Type'Base;
   function Tanh    (X : Float_Type'Base) return Float_Type'Base;
   function Coth    (X : Float_Type'Base) return Float_Type'Base;
   function Arcsinh (X : Float_Type'Base) return Float_Type'Base;
   function Arccosh (X : Float_Type'Base) return Float_Type'Base;
   function Arctanh (X : Float_Type'Base) return Float_Type'Base;
   function Arccoth (X : Float_Type'Base) return Float_Type'Base;

  8. end Ada.Numerics.Generic_Elementary_Functions;
  9. The library package Numerics.Elementary_Functions defines the same subprograms as Numerics.Generic_Elementary_Functions, except that the predefined type Float is systematically substituted for Float_Type'Base throughout. Nongeneric equivalents of Numerics.Generic_Elementary_Functions for each of the other predefined floating point types are defined similarly, with the names Numerics.Short_Elementary_Functions, Numerics.Long_Elementary_Functions, etc.
  10. The functions have their usual mathematical meanings. When the Base parameter is specified, the Log function computes the logarithm to the given base; otherwise, it computes the natural logarithm. When the Cycle parameter is specified, the parameter X of the forward trigonometric functions (Sin, Cos, Tan, and Cot) and the results of the inverse trigonometric functions (Arcsin, Arccos, Arctan, and Arccot) are measured in units such that a full cycle of revolution has the given value; otherwise, they are measured in radians.
  11. The computed results of the mathematically multivalued functions are rendered single-valued by the following conventions, which are meant to imply the principal branch:
    1. The results of the Sqrt and Arccosh functions and that of the exponentiation operator are nonnegative.
    2. The result of the Arcsin function is in the quadrant containing the point (1.0, x), where x is the value of the parameter X. This quadrant is I or IV; thus, the range of the Arcsin function is approximately -Pi/2.0 to Pi/2.0 (-Cycle/4.0 to Cycle/4.0, if the parameter Cycle is specified).
    3. The result of the Arccos function is in the quadrant containing the point (x, 1.0), where x is the value of the parameter X. This quadrant is I or II; thus, the Arccos function ranges from 0.0 to approximately Pi (Cycle/2.0, if the parameter Cycle is specified).
    4. The results of the Arctan and Arccot functions are in the quadrant containing the point (x, y), where x and y are the values of the parameters X and Y, respectively. This may be any quadrant (I through IV) when the parameter X (resp., Y) of Arctan (resp., Arccot) is specified, but it is restricted to quadrants I and IV (resp., I and II) when that parameter is omitted. Thus, the range when that parameter is specified is approximately -Pi to Pi (-Cycle/2.0 to Cycle/2.0, if the parameter Cycle is specified); when omitted, the range of Arctan (resp., Arccot) is that of Arcsin (resp., Arccos), as given above. When the point (x, y) lies on the negative x-axis, the result approximates
      1. Pi (resp., -Pi) when the sign of the parameter Y is positive (resp., negative), if Float_Type'Signed_Zeros is True;
      2. Pi, if Float_Type'Signed_Zeros is False.
  1. (In the case of the inverse trigonometric functions, in which a result lying on or near one of the axes may not be exactly representable, the approximation inherent in computing the result may place it in an adjacent quadrant, close to but on the wrong side of the axis.)

    Dynamic Semantics

  2. The exception Numerics.Argument_Error is raised, signaling a parameter value outside the domain of the corresponding mathematical function, in the following cases:
    1. by any forward or inverse trigonometric function with specified cycle, when the value of the parameter Cycle is zero or negative;
    2. by the Log function with specified base, when the value of the parameter Base is zero, one, or negative;
    3. by the Sqrt and Log functions, when the value of the parameter X is negative;
    4. by the exponentiation operator, when the value of the left operand is negative or when both operands have the value zero;
    5. by the Arcsin, Arccos, and Arctanh functions, when the absolute value of the parameter X exceeds one;
    6. by the Arctan and Arccot functions, when the parameters X and Y both have the value zero;
    7. by the Arccosh function, when the value of the parameter X is less than one; and
    8. by the Arccoth function, when the absolute value of the parameter X is less than one.
  1. The exception Constraint_Error is raised, signaling a pole of the mathematical function (analogous to dividing by zero), in the following cases, provided that Float_Type'Machine_Overflows is True:
    1. by the Log, Cot, and Coth functions, when the value of the parameter X is zero;
    2. by the exponentiation operator, when the value of the left operand is zero and the value of the exponent is negative;
    3. by the Tan function with specified cycle, when the value of the parameter X is an odd multiple of the quarter cycle;
    4. by the Cot function with specified cycle, when the value of the parameter X is zero or a multiple of the half cycle; and
    5. by the Arctanh and Arccoth functions, when the absolute value of the parameter X is one.
  1. Constraint_Error can also be raised when a finite result overflows (see section Accuracy Requirements for the Elementary Functions) this may occur for parameter values sufficiently near poles, and, in the case of some of the functions, for parameter values with sufficiently large magnitudes. When Float_Type'Machine_Overflows is False, the result at poles is unspecified.
  2. When one parameter of a function with multiple parameters represents a pole and another is outside the function's domain, the latter takes precedence (i.e., Numerics.Argument_Error is raised).

    Implementation Requirements

  3. In the implementation of Numerics.Generic_Elementary_Functions, the range of intermediate values allowed during the calculation of a final result shall not be affected by any range constraint of the subtype Float_Type.
  4. In the following cases, evaluation of an elementary function shall yield the prescribed result, provided that the preceding rules do not call for an exception to be raised:
    1. When the parameter X has the value zero, the Sqrt, Sin, Arcsin, Tan, Sinh, Arcsinh, Tanh, and Arctanh functions yield a result of zero, and the Exp, Cos, and Cosh functions yield a result of one.
    2. When the parameter X has the value one, the Sqrt function yields a result of one, and the Log, Arccos, and Arccosh functions yield a result of zero.
    3. When the parameter Y has the value zero and the parameter X has a positive value, the Arctan and Arccot functions yield a result of zero.
    4. The results of the Sin, Cos, Tan, and Cot functions with specified cycle are exact when the mathematical result is zero; those of the first two are also exact when the mathematical result is +/-1.0.
    5. Exponentiation by a zero exponent yields the value one. Exponentiation by a unit exponent yields the value of the left operand. Exponentiation of the value one yields the value one. Exponentiation of the value zero yields the value zero.
  1. Other accuracy requirements for the elementary functions, which apply only in implementations conforming to the Numerics Annex, and then only in the "strict" mode defined there, see section Numeric Performance Requirements, are given in section Accuracy Requirements for the Elementary Functions.
  2. When Float_Type'Signed_Zeros is True, the sign of a zero result shall be as follows:
    1. A prescribed zero result delivered at the origin by one of the odd functions (Sin, Arcsin, Sinh, Arcsinh, Tan, Arctan or Arccot as a function of Y when X is fixed and positive, Tanh, and Arctanh) has the sign of the parameter X (Y, in the case of Arctan or Arccot).
    2. A prescribed zero result delivered by one of the odd functions away from the origin, or by some other elementary function, has an implementation-defined sign.
    3. A zero result that is not a prescribed result (i.e., one that results from rounding or underflow) has the correct mathematical sign.

Implementation Permissions

  1. The nongeneric equivalent packages may, but need not, be actual instantiations of the generic package for the appropriate predefined type.

Random Number Generation

  1. Facilities for the generation of pseudo-random floating point numbers are provided in the package Numerics.Float_Random; the generic package Numerics.Discrete_Random provides similar facilities for the generation of pseudo-random integers and pseudo-random values of enumeration types. For brevity, pseudo-random values of any of these types are called random numbers.
  2. Some of the facilities provided are basic to all applications of random numbers. These include a limited private type each of whose objects serves as the generator of a (possibly distinct) sequence of random numbers; a function to obtain the "next" random number from a given sequence of random numbers (that is, from its generator); and subprograms to initialize or reinitialize a given generator to a time-dependent state or a state denoted by a single integer.
  3. Other facilities are provided specifically for advanced applications. These include subprograms to save and restore the state of a given generator; a private type whose objects can be used to hold the saved state of a generator; and subprograms to obtain a string representation of a given generator state, or, given such a string representation, the corresponding state.

    Static Semantics

  4. The library package Numerics.Float_Random has the following declaration: 
  5. package Ada.Numerics.Float_Random is

  6.    -- Basic facilities

  7.    type Generator is limited private;

  8.    subtype Uniformly_Distributed is Float range 0.0 .. 1.0;
   function Random (Gen : Generator) return Uniformly_Distributed;

  9.    procedure Reset (Gen       : in Generator;
                    Initiator : in Integer);
   procedure Reset (Gen       : in Generator);

  10.    -- Advanced facilities

  11.    type State is private;

  12.    procedure Save  (Gen        : in  Generator;
                    To_State   : out State);
   procedure Reset (Gen        : in  Generator;
                    From_State : in  State);

  13.    Max_Image_Width : constant
     := implementation-defined integer value;

  14.    function Image (Of_State    : State)  return String;
   function Value (Coded_State : String) return State;

  15. private
   ... -- not specified by the language
end Ada.Numerics.Float_Random;
  16. The generic library package Numerics.Discrete_Random has the following declaration: 
  17. generic
   type Result_Subtype is (<>);
package Ada.Numerics.Discrete_Random is

  18.    -- Basic facilities

  19.    type Generator is limited private;

  20.    function Random (Gen : Generator) return Result_Subtype;

  21.    procedure Reset (Gen       : in Generator;
                    Initiator : in Integer);
   procedure Reset (Gen       : in Generator);

  22.    -- Advanced facilities

  23.    type State is private;

  24.    procedure Save  (Gen        : in  Generator;
                    To_State   : out State);
   procedure Reset (Gen        : in  Generator;
                    From_State : in  State);

  25.    Max_Image_Width : constant
     := implementation-defined integer value;

  26.    function Image (Of_State    : State)  return String;
   function Value (Coded_State : String) return State;

  27. private
   ... -- not specified by the language
end Ada.Numerics.Discrete_Random;
  28. An object of the limited private type Generator is associated with a sequence of random numbers. Each generator has a hidden (internal) state, which the operations on generators use to determine the position in the associated sequence. All generators are implicitly initialized to an unspecified state that does not vary from one program execution to another; they may also be explicitly initialized, or reinitialized, to a time-dependent state, to a previously saved state, or to a state uniquely denoted by an integer value.
  29. An object of the private type State can be used to hold the internal state of a generator. Such objects are only needed if the application is designed to save and restore generator states or to examine or manufacture them.
  30. The operations on generators affect the state and therefore the future values of the associated sequence. The semantics of the operations on generators and states are defined below. 
  31. function Random (Gen : Generator) return Uniformly_Distributed;

function Random (Gen : Generator) return Result_Subtype;
    1. Obtains the "next" random number from the given generator, relative to its current state, according to an implementation-defined algorithm. The result of the function in Numerics.Float_Random is delivered as a value of the subtype Uniformly_Distributed, which is a subtype of the predefined type Float having a range of 0.0 .. 1.0. The result of the function in an instantiation of Numerics.Discrete_Random is delivered as a value of the generic formal subtype Result_Subtype. 
  1. procedure Reset (Gen       : in Generator;
                 Initiator : in Integer);

procedure Reset (Gen       : in Generator);
    1. Sets the state of the specified generator to one that is an unspecified function of the value of the parameter Initiator (or to a time-dependent state, if only a generator parameter is specified). The latter form of the procedure is known as the time-dependent Reset procedure. 
  1. procedure Save  (Gen        : in  Generator;
                 To_State   : out State);

procedure Reset (Gen        : in  Generator;
                 From_State : in  State);
    1. Save obtains the current state of a generator. Reset gives a generator the specified state. A generator that is reset to a state previously obtained by invoking Save is restored to the state it had when Save was invoked. 
  1. function Image (Of_State    : State)  return String;

function Value (Coded_State : String) return State;
    1. Image provides a representation of a state coded (in an implementation-defined way) as a string whose length is bounded by the value of Max_Image_Width. Value is the inverse of Image: Value(Image(S)) = S for each state S that can be obtained from a generator by invoking Save.

Dynamic Semantics

  1. Instantiation of Numerics.Discrete_Random with a subtype having a null range raises Constraint_Error.
  2. Invoking Value with a string that is not the image of any generator state raises Constraint_Error.

    Implementation Requirements

  3. A sufficiently long sequence of random numbers obtained by successive calls to Random is approximately uniformly distributed over the range of the result subtype.
  4. The Random function in an instantiation of Numerics.Discrete_Random is guaranteed to yield each value in its result subtype in a finite number of calls, provided that the number of such values does not exceed 2 ** 15.
  5. Other performance requirements for the random number generator, which apply only in implementations conforming to the Numerics Annex, and then only in the "strict" mode defined there, see section Numeric Performance Requirements, are given in section Performance Requirements for Random Number Generation.

    Documentation Requirements

  6. No one algorithm for random number generation is best for all applications. To enable the user to determine the suitability of the random number generators for the intended application, the implementation shall describe the algorithm used and shall give its period, if known exactly, or a lower bound on the period, if the exact period is unknown. Periods that are so long that the periodicity is unobservable in practice can be described in such terms, without giving a numerical bound.
  7. The implementation also shall document the minimum time interval between calls to the time-dependent Reset procedure that are guaranteed to initiate different sequences, and it shall document the nature of the strings that Value will accept without raising Constraint_Error.

    Implementation Advice

  8. Any storage associated with an object of type Generator should be reclaimed on exit from the scope of the object.
  9. If the generator period is sufficiently long in relation to the number of distinct initiator values, then each possible value of Initiator passed to Reset should initiate a sequence of random numbers that does not, in a practical sense, overlap the sequence initiated by any other value. If this is not possible, then the mapping between initiator values and generator states should be a rapidly varying function of the initiator value. NOTES
  10. (14) If two or more tasks are to share the same generator, then the tasks have to synchronize their access to the generator as for any shared variable, see section Shared Variables.
  11. (15) Within a given implementation, a repeatable random number sequence can be obtained by relying on the implicit initialization of generators or by explicitly initializing a generator with a repeatable initiator value. Different sequences of random numbers can be obtained from a given generator in different program executions by explicitly initializing the generator to a time-dependent state.
  12. (16) A given implementation of the Random function in Numerics.Float_Random may or may not be capable of delivering the values 0.0 or 1.0. Portable applications should assume that these values, or values sufficiently close to them to behave indistinguishably from them, can occur. If a sequence of random integers from some fixed range is needed, the application should use the Random function in an appropriate instantiation of Numerics.Discrete_Random, rather than transforming the result of the Random function in Numerics.Float_Random. However, some applications with unusual requirements, such as for a sequence of random integers each drawn from a different range, will find it more convenient to transform the result of the floating point Random function. For M>=1, the expression 
  13. Integer(Float(M) * Random(G)) mod M
  14. transforms the result of Random(G) to an integer uniformly distributed over the range 0 .. M-1; it is valid even if Random delivers 0.0 or 1.0. Each value of the result range is possible, provided that M is not too large. Exponentially distributed (floating point) random numbers with mean and standard deviation 1.0 can be obtained by the transformation 
  15. -Log(Random(G) + Float'Model_Small))
  16. where Log comes from Numerics.Elementary_Functions, see section Elementary Functions, in this expression, the addition of Float'Model_Small avoids the exception that would be raised were Log to be given the value zero, without affecting the result (in most implementations) when Random returns a nonzero value.

    Examples

  17. Example of a program that plays a simulated dice game: 
  18. with Ada.Numerics.Discrete_Random;
procedure Dice_Game is
   subtype Die is Integer range 1 .. 6;
   subtype Dice is Integer range 2*Die'First .. 2*Die'Last;
   package Random_Die is new Ada.Numerics.Discrete_Random (Die);
   use Random_Die;
   G : Generator;
   D : Dice;
begin
   Reset (G);  -- Start the generator in a unique state in each run
   loop
      -- Roll a pair of dice; sum and process the results
      D := Random(G) + Random(G);
      ...
   end loop;
end Dice_Game;
  19. Example of a program that simulates coin tosses: 
  20. with Ada.Numerics.Discrete_Random;
procedure Flip_A_Coin is
   type Coin is (Heads, Tails);
   package Random_Coin is new Ada.Numerics.Discrete_Random (Coin);
   use Random_Coin;
   G : Generator;
begin
   Reset (G);  -- Start the generator in a unique state in each run
   loop
      -- Toss a coin and process the result
      case Random(G) is
          when Heads =>
             ...
          when Tails =>
             ...
      end case;
   ...
   end loop;
end Flip_A_Coin;
  21. Example of a parallel simulation of a physical system, with a separate generator of event probabilities in each task: 
  22. with Ada.Numerics.Float_Random;
procedure Parallel_Simulation is
   use Ada.Numerics.Float_Random;
   task type Worker is
      entry Initialize_Generator (Initiator : in Integer);
      ...
   end Worker;
   W : array (1 .. 10) of Worker;
   task body Worker is
      G : Generator;
      Probability_Of_Event : Uniformly_Distributed;
   begin
      accept Initialize_Generator (Initiator : in Integer) do
         Reset (G, Initiator);
      end Initialize_Generator;
      loop
         ...
         Probability_Of_Event := Random(G);
         ...
      end loop;
   end Worker;
begin
   -- Initialize the generators in the Worker tasks
   -- to different states
   for I in W'Range loop
      W(I).Initialize_Generator (I);
   end loop;
   ... -- Wait for the Worker tasks to terminate
end Parallel_Simulation;
    NOTES
  23. (17) Notes on the last example: Although each Worker task initializes its generator to a different state, those states will be the same in every execution of the program. The generator states can be initialized uniquely in each program execution by instantiating Ada.Numerics.Discrete_Random for the type Integer in the main procedure, resetting the generator obtained from that instance to a time-dependent state, and then using random integers obtained from that generator to initialize the generators in each Worker task.

Attributes of Floating Point Types

Static Semantics

  1. The following representation-oriented attributes are defined for every subtype S of a floating point type T.
  2. S'Machine_Radix 
    Yields the radix of the hardware representation of the type
T. The value of this attribute is of the type universal_integer.
  3. The values of other representation-oriented attributes of a floating point subtype, and of the "primitive function" attributes of a floating point subtype described later, are defined in terms of a particular representation of nonzero values called the canonical form. The canonical form (for the type T) is the form 
    +/-mantissa*T'Machine_Radix ** exponent
    where
    1. mantissa is a fraction in the number base T'Machine_Radix, the first digit of which is nonzero, and
    2. exponent is an integer.
  1. S'Machine_Mantissa 
    Yields the largest value of p such that every value
expressible in the canonical form (for the type T), having a
p-digit mantissa and an exponent between T'Machine_Emin and
T'Machine_Emax, is a machine number, see section Floating Point Types, of the type
T. This attribute yields a value of the type
universal_integer.
  2. S'Machine_Emin 
    Yields the smallest (most negative) value of exponent such
that every value expressible in the canonical form (for the
type T), having a mantissa of T'Machine_Mantissa digits, is a
machine number, see section Floating Point Types, of the type T. This attribute
yields a value of the type universal_integer.
  3. S'Machine_Emax 
    Yields the largest (most positive) value of exponent such
that every value expressible in the canonical form (for the
type T), having a mantissa of T'Machine_Mantissa digits, is a
machine number (see section Floating Point Types) of the type T. This attribute
yields a value of the type universal_integer.
  4. S'Denorm 
    Yields the value True if every value expressible in the form

    +/-mantissa*T'Machine_Radix ** T'Machine_Emin

where mantissa is a nonzero T'Machine_Mantissa-digit fraction
in the number base T'Machine_Radix, the first digit of which
is zero, is a machine number, see section Floating Point Types, of the type T;
yields the value False otherwise. The value of this
attribute is of the predefined type Boolean.
  5. The values described by the formula in the definition of S'Denorm are called denormalized numbers. A nonzero machine number that is not a denormalized number is a normalized number. A normalized number x of a given type T is said to be represented in canonical form when it is expressed in the canonical form (for the type T) with a mantissa having T'Machine_Mantissa digits; the resulting form is the canonical-form representation of x.
  6. S'Machine_Rounds 
    Yields the value True if rounding is performed on inexact
results of every predefined operation that yields a result of
the type T; yields the value False otherwise. The value of
this attribute is of the predefined type Boolean.
  7. S'Machine_Overflows 
    Yields the value True if overflow and divide-by-zero are
detected and reported by raising Constraint_Error for every
predefined operation that yields a result of the type T;
yields the value False otherwise. The value of this
attribute is of the predefined type Boolean.
  8. S'Signed_Zeros 
    Yields the value True if the hardware representation for the
type T has the capability of representing both positively and
negatively signed zeros, these being generated and used by
the predefined operations of the type T as specified in IEC
559:1989; yields the value False otherwise. The value of
this attribute is of the predefined type Boolean.
  9. For every value x of a floating point type T, the normalized exponent of x is defined as follows:
    1. the normalized exponent of zero is (by convention) zero;
    2. for nonzero x, the normalized exponent of x is the unique integer k such that T'Machine_Radix ** (k - 1) <=|x|<T'Machine_Radix ** k.
  1. The following primitive function attributes are defined for any subtype S of a floating point type T.
  2. S'Exponent 
    S'Exponent denotes a function with the following specification:

    1. function S'Exponent (X : T)
  return universal_integer
    2. The function yields the normalized exponent of X.
  1. S'Fraction 
    S'Fraction denotes a function with the following specification:

    1. function S'Fraction (X : T)
  return T
    2. The function yields the value X*T'Machine_Radix ** -k, where k is the normalized exponent of X. A zero result, which can only occur when X is zero, has the sign of X.
  1. S'Compose 
    S'Compose denotes a function with the following specification:

    1. function S'Compose (Fraction : T;
                    Exponent : universal_integer)
  return T
    2. Let v be the value Fraction*T'Machine_Radix ** (Exponent-k), where k is the normalized exponent of Fraction. If v is a machine number of the type T, or if |v|>=T'Model_Small, the function yields v; otherwise, it yields either one of the machine numbers of the type T adjacent to v. Constraint_Error is optionally raised if v is outside the base range of S. A zero result has the sign of Fraction when S'Signed_Zeros is True.
  1. S'Scaling 
    1. S'Scaling denotes a function with the following specification:

    2. function S'Scaling (X          : T;
                    Adjustment : universal_integer)
  return T
    3. Let v be the value X*T'Machine_Radix ** (Adjustment). If v is a machine number of the type T, or if |v|>=T'Model_Small, the function yields v; otherwise, it yields either one of the machine numbers of the type T adjacent to v. Constraint_Error is optionally raised if v is outside the base range of S. A zero result has the sign of X when S'Signed_Zeros is True.
  1. S'Floor 
    S'Floor denotes a function with the following specification:

    1. function S'Floor (X : T)
  return T
    2. The function yields the value Floor(X), i.e., the largest (most positive) integral value less than or equal to X. When X is zero, the result has the sign of X; a zero result otherwise has a positive sign.
  1. S'Ceiling 
    S'Ceiling denotes a function with the following specification:

    1. function S'Ceiling (X : T)
  return T
    2. The function yields the value Ceiling(X), i.e., the smallest (most negative) integral value greater than or equal to X. When X is zero, the result has the sign of X; a zero result otherwise has a negative sign when S'Signed_Zeros is True.
  1. S'Rounding 
    S'Rounding denotes a function with the following specification:

    1. function S'Rounding (X : T)
  return T
    2. The function yields the integral value nearest to X, rounding away from zero if X lies exactly halfway between two integers. A zero result has the sign of X when S'Signed_Zeros is True.
  1. S'Unbiased_Rounding 
    S'Unbiased_Rounding denotes a function with the following
specification:

    1. function S'Unbiased_Rounding (X : T)
  return T
    2. The function yields the integral value nearest to X, rounding toward the even integer if X lies exactly halfway between two integers. A zero result has the sign of X when S'Signed_Zeros is True.
  1. S'Truncation 
    S'Truncation denotes a function with the following
specification:

    1. function S'Truncation (X : T)
  return T
    2. The function yields the value Ceiling(X) when X is negative, and Floor(X) otherwise. A zero result has the sign of X when S'Signed_Zeros is True.
  1. S'Remainder 
    S'Remainder denotes a function with the following
specification:

    1. function S'Remainder (X, Y : T)
  return T
    2. For nonzero Y, let v be the value X-n*Y, where n is the integer nearest to the exact value of X/Y; if |n-X/Y|=1/2, then n is chosen to be even. If v is a machine number of the type T, the function yields v; otherwise, it yields zero. Constraint_Error is raised if Y is zero. A zero result has the sign of X when S'Signed_Zeros is True.
  1. S'Adjacent 
    S'Adjacent denotes a function with the following specification:

    1. function S'Adjacent (X, Towards : T)
  return T
    2. If Towards=X, the function yields X; otherwise, it yields the machine number of the type T adjacent to X in the direction of Towards, if that machine number exists. If the result would be outside the base range of S, Constraint_Error is raised. When T'Signed_Zeros is True, a zero result has the sign of X. When Towards is zero, its sign has no bearing on the result.
  1. S'Copy_Sign 
    S'Copy_Sign denotes a function with the following
specification:

    1. function S'Copy_Sign (Value, Sign : T)
  return T
    2. If the value of Value is nonzero, the function yields a result whose magnitude is that of Value and whose sign is that of Sign; otherwise, it yields the value zero. Constraint_Error is optionally raised if the result is outside the base range of S. A zero result has the sign of Sign when S'Signed_Zeros is True.
  1. S'Leading_Part 
    S'Leading_Part denotes a function with the following
specification:

    1. function S'Leading_Part (X : T;
                         Radix_Digits : universal_integer)
  return T
    2. Let v be the value T'Machine_Radix ** (k-Radix_Digits), where k is the normalized exponent of X. The function yields the value
      1. Floor(X/v)*v, when X is nonnegative and Radix_Digits is positive;
      2. Ceiling(X/v)*v, when X is negative and Radix_Digits is positive.
    1. Constraint_Error is raised when Radix_Digits is zero or negative. A zero result, which can only occur when X is zero, has the sign of X.
  1. S'Machine 
    S'Machine denotes a function with the following specification:

    1. function S'Machine (X : T)
  return T
    2. If X is a machine number of the type T, the function yields X; otherwise, it yields the value obtained by rounding or truncating X to either one of the adjacent machine numbers of the type T. Constraint_Error is raised if rounding or truncating X to the precision of the machine numbers results in a value outside the base range of S. A zero result has the sign of X when S'Signed_Zeros is True.
  1. The following model-oriented attributes are defined for any subtype S of a floating point type T.
  2. S'Model_Mantissa 
    If the Numerics Annex is not supported, this attribute yields
an implementation defined value that is greater than or equal
to Ceiling(d*log (10)/log (T'Machine_Radix))+1, where d is
the requested decimal precision of T, and less than or equal
to the value of T'Machine_Mantissa. See section Model-Oriented Attributes of Floating Point Types for further
requirements that apply to implementations supporting the
Numerics Annex. The value of this attribute is of the type
universal_integer.
  3. S'Model_Emin 
    If the Numerics Annex is not supported, this attribute yields
an implementation defined value that is greater than or equal
to the value of T'Machine_Emin. See section Model-Oriented Attributes of Floating Point Types for further
requirements that apply to implementations supporting the
Numerics Annex. The value of this attribute is of the type
universal_integer.
  4. S'Model_Epsilon 
    Yields the value T'Machine_Radix ** 1-T'Model_Mantissa. The value
of this attribute is of the type universal_real.
  5. S'Model_Small 
    Yields the value T'Machine_Radix ** T'Model_Emin-1. The value of
this attribute is of the type universal_real.
  6. S'Model 
    S'Model denotes a function with the following specification:

    1. function S'Model (X : T)
  return T
    2. If the Numerics Annex is not supported, the meaning of this attribute is implementation defined; See section Model-Oriented Attributes of Floating Point Types for the definition that applies to implementations supporting the Numerics Annex.
  1. S'Safe_First 
    Yields the lower bound of the safe range, see section Floating Point Types, of the
type T. If the Numerics Annex is not supported, the value of
this attribute is implementation defined;  See section Model-Oriented Attributes of Floating Point Types for the
definition that applies to implementations supporting the
Numerics Annex. The value of this attribute is of the type
universal_real.
  2. S'Safe_Last 
    Yields the upper bound of the safe range, see section Floating Point Types, of the
type T. If the Numerics Annex is not supported, the value of
this attribute is implementation defined;  See section Model-Oriented Attributes of Floating Point Types for the
definition that applies to implementations supporting the
Numerics Annex. The value of this attribute is of the type
universal_real.

Attributes of Fixed Point Types

Static Semantics

  1. The following representation-oriented attributes are defined for every subtype S of a fixed point type T.
  2. S'Machine_Radix 
    Yields the radix of the hardware representation of the type
T. The value of this attribute is of the type
universal_integer.
  3. S'Machine_Rounds 
    Yields the value True if rounding is performed on inexact
results of every predefined operation that yields a result of
the type T; yields the value False otherwise. The value of
this attribute is of the predefined type Boolean.
  4. S'Machine_Overflows 
    Yields the value True if overflow and divide-by-zero are
detected and reported by raising Constraint_Error for every
predefined operation that yields a result of the type T;
yields the value False otherwise. The value of this
attribute is of the predefined type Boolean.

Input-Output

  1. Input-output is provided through language-defined packages, each of which is a child of the root package Ada. The generic packages Sequential_IO and Direct_IO define input-output operations applicable to files containing elements of a given type. The generic package Storage_IO supports reading from and writing to an in-memory buffer. Additional operations for text input-output are supplied in the packages Text_IO and Wide_Text_IO. Heterogeneous input-output is provided through the child packages Streams.Stream_IO and Text_IO.Text_Streams, see also section Streams. The package IO_Exceptions defines the exceptions needed by the predefined input-output packages.

External Files and File Objects

Static Semantics

  1. Values input from the external environment of the program, or output to the external environment, are considered to occupy external files. An external file can be anything external to the program that can produce a value to be read or receive a value to be written. An external file is identified by a string (the name). A second string (the form) gives further system-dependent characteristics that may be associated with the file, such as the physical organization or access rights. The conventions governing the interpretation of such strings shall be documented.
  2. Input and output operations are expressed as operations on objects of some file type, rather than directly in terms of the external files. In the remainder of this section, the term file is always used to refer to a file object; the term external file is used otherwise.
  3. Input-output for sequential files of values of a single element type is defined by means of the generic package Sequential_IO. In order to define sequential input-output for a given element type, an instantiation of this generic unit, with the given type as actual parameter, has to be declared. The resulting package contains the declaration of a file type (called File_Type) for files of such elements, as well as the operations applicable to these files, such as the Open, Read, and Write procedures.
  4. Input-output for direct access files is likewise defined by a generic package called Direct_IO. Input-output in human-readable form is defined by the (nongeneric) packages Text_IO for Character and String data, and Wide_Text_IO for Wide_Character and Wide_String data. Input-output for files containing streams of elements representing values of possibly different types is defined by means of the (nongeneric) package Streams.Stream_IO.
  5. Before input or output operations can be performed on a file, the file first has to be associated with an external file. While such an association is in effect, the file is said to be open, and otherwise the file is said to be closed.
  6. The language does not define what happens to external files after the completion of the main program and all the library tasks (in particular, if corresponding files have not been closed). The effect of input-output for access types is unspecified.
  7. An open file has a current mode, which is a value of one of the following enumeration types: 
  8. type File_Mode is (In_File, Inout_File, Out_File);  --  for Direct_IO
    1. These values correspond respectively to the cases where only reading, both reading and writing, or only writing are to be performed. 
  1. type File_Mode is (In_File, Out_File, Append_File);
--  for Sequential_IO, Text_IO, Wide_Text_IO, and Stream_IO
    1. These values correspond respectively to the cases where only reading, only writing, or only appending are to be performed.
    2. The mode of a file can be changed.
  1. Several file management operations are common to Sequential_IO, Direct_IO, Text_IO, and Wide_Text_IO. These operations are described in subclause section File Management, for sequential and direct files. Any additional effects concerning text input-output are described in section Text File Management.
  2. The exceptions that can be propagated by the execution of an input-output subprogram are defined in the package IO_Exceptions; the situations in which they can be propagated are described following the description of the subprogram (and in section Exceptions in Input-Output). The exceptions Storage_Error and Program_Error may be propagated. (Program_Error can only be propagated due to errors made by the caller of the subprogram.) Finally, exceptions can be propagated in certain implementation-defined situations. NOTES
  3. (18) Each instantiation of the generic packages Sequential_IO and Direct_IO declares a different type File_Type. In the case of Text_IO, Wide_Text_IO, and Streams.Stream_IO, the corresponding type File_Type is unique.
  4. (19) A bidirectional device can often be modeled as two sequential files associated with the device, one of mode In_File, and one of mode Out_File. An implementation may restrict the number of files that may be associated with a given external file.

Sequential and Direct Files

Static Semantics

  1. Two kinds of access to external files are defined in this subclause: sequential access and direct access. The corresponding file types and the associated operations are provided by the generic packages Sequential_IO and Direct_IO. A file object to be used for sequential access is called a sequential file, and one to be used for direct access is called a direct file. Access to stream files is described in section The Package Streams.Stream_IO.
  2. For sequential access, the file is viewed as a sequence of values that are transferred in the order of their appearance (as produced by the program or by the external environment). When the file is opened with mode In_File or Out_File, transfer starts respectively from or to the beginning of the file. When the file is opened with mode Append_File, transfer to the file starts after the last element of the file.
  3. For direct access, the file is viewed as a set of elements occupying consecutive positions in linear order; a value can be transferred to or from an element of the file at any selected position. The position of an element is specified by its index, which is a number, greater than zero, of the implementation-defined integer type Count. The first element, if any, has index one; the index of the last element, if any, is called the current size; the current size is zero if there are no elements. The current size is a property of the external file.
  4. An open direct file has a current index, which is the index that will be used by the next read or write operation. When a direct file is opened, the current index is set to one. The current index of a direct file is a property of a file object, not of an external file.

The Generic Package Sequential_IO

Static Semantics

  1. The generic library package Sequential_IO has the following declaration: 
  2. with Ada.IO_Exceptions;
generic
   type Element_Type(<>) is private;
package Ada.Sequential_IO is

  3.    type File_Type is limited private;

  4.    type File_Mode is (In_File, Out_File, Append_File);

  5.    -- File management

  6.    procedure Create(File : in out File_Type;
                    Mode : in File_Mode := Out_File;
                    Name : in String := "";
                    Form : in String := "");

  7.    procedure Open  (File : in out File_Type;
                    Mode : in File_Mode;
                    Name : in String;
                    Form : in String := "");

  8.    procedure Close (File : in out File_Type);
   procedure Delete(File : in out File_Type);
   procedure Reset (File : in out File_Type; Mode : in File_Mode);
   procedure Reset (File : in out File_Type);

  9.    function Mode   (File : in File_Type) return File_Mode;
   function Name   (File : in File_Type) return String;
   function Form   (File : in File_Type) return String;

  10.    function Is_Open(File : in File_Type) return Boolean;

  11.    -- Input and output operations

  12.    procedure Read  (File : in File_Type; Item : out Element_Type);
   procedure Write (File : in File_Type; Item : in Element_Type);

  13.    function End_Of_File(File : in File_Type) return Boolean;

  14.    -- Exceptions

  15.    Status_Error : exception renames IO_Exceptions.Status_Error;
   Mode_Error   : exception renames IO_Exceptions.Mode_Error;
   Name_Error   : exception renames IO_Exceptions.Name_Error;
   Use_Error    : exception renames IO_Exceptions.Use_Error;
   Device_Error : exception renames IO_Exceptions.Device_Error;
   End_Error    : exception renames IO_Exceptions.End_Error;
   Data_Error   : exception renames IO_Exceptions.Data_Error;

  16. private
   ... -- not specified by the language
end Ada.Sequential_IO;

File Management

Static Semantics

  1. The procedures and functions described in this subclause provide for the control of external files; their declarations are repeated in each of the packages for sequential, direct, text, and stream input-output. For text input-output, the procedures Create, Open, and Reset have additional effects described in subclause (see section Text File Management). 
  2. procedure Create(File : in out File_Type;
                 Mode : in File_Mode := default_mode;
                 Name : in String := "";
                 Form : in String := "");
    1. Establishes a new external file, with the given name and form, and associates this external file with the given file. The given file is left open. The current mode of the given file is set to the given access mode. The default access mode is the mode Out_File for sequential and text input-output; it is the mode Inout_File for direct input-output. or direct access, the size of the created file is implementation defined.
    2. A null string for Name specifies an external file that is not accessible after the completion of the main program (a temporary file). A null string for Form specifies the use of the default options of the implementation for the external file.
    3. The exception Status_Error is propagated if the given file is already open. The exception Name_Error is propagated if the string given as Name does not allow the identification of an external file. The exception Use_Error is propagated if, for the specified mode, the external environment does not support creation of an external file with the given name (in the absence of Name_Error) and form. 
  1. procedure Open(File : in out File_Type;
               Mode : in File_Mode;
               Name : in String;
               Form : in String := "");
    1. Associates the given file with an existing external file having the given name and form, and sets the current mode of the given file to the given mode. The given file is left open.
    2. The exception Status_Error is propagated if the given file is already open. The exception Name_Error is propagated if the string given as Name does not allow the identification of an external file; in particular, this exception is propagated if no external file with the given name exists. The exception Use_Error is propagated if, for the specified mode, the external environment does not support opening for an external file with the given name (in the absence of Name_Error) and form. 
  1. procedure Close(File : in out File_Type);
    1. Severs the association between the given file and its associated external file. The given file is left closed. In addition, for sequential files, if the file being closed has mode Out_File or Append_File, then the last element written since the most recent open or reset is the last element that can be read from the file. If no elements have been written and the file mode is Out_File, then the closed file is empty. If no elements have been written and the file mode is Append_File, then the closed file is unchanged.
    2. The exception Status_Error is propagated if the given file is not open. 
  1. procedure Delete(File : in out File_Type);
    1. Deletes the external file associated with the given file. The given file is closed, and the external file ceases to exist.
    2. The exception Status_Error is propagated if the given file is not open. The exception Use_Error is propagated if deletion of the external file is not supported by the external environment. 
  1. procedure Reset(File : in out File_Type; Mode : in File_Mode);
procedure Reset(File : in out File_Type);
    1. Resets the given file so that reading from its elements can be restarted from the beginning of the file (for modes In_File and Inout_File), and so that writing to its elements can be restarted at the beginning of the file (for modes Out_File and Inout_File) or after the last element of the file (for mode Append_File). In particular, for direct access this means that the current index is set to one. If a Mode parameter is supplied, the current mode of the given file is set to the given mode. In addition, for sequential files, if the given file has mode Out_File or Append_File when Reset is called, the last element written since the most recent open or reset is the last element that can be read from the file. If no elements have been written and the file mode is Out_File, the reset file is empty. If no elements have been written and the file mode is Append_File, then the reset file is unchanged.
    2. The exception Status_Error is propagated if the file is not open. The exception Use_Error is propagated if the external environment does not support resetting for the external file and, also, if the external environment does not support resetting to the specified mode for the external file. 
  1. function Mode(File : in File_Type) return File_Mode;
    1. Returns the current mode of the given file.
    2. The exception Status_Error is propagated if the file is not open. 
  1. function Name(File : in File_Type) return String;
    1. Returns a string which uniquely identifies the external file currently associated with the given file (and may thus be used in an Open operation). If an external environment allows alternative specifications of the name (for example, abbreviations), the string returned by the function should correspond to a full specification of the name.
    2. The exception Status_Error is propagated if the given file is not open. The exception Use_Error is propagated if the associated external file is a temporary file that cannot be opened by any name. 
  1. function Form(File : in File_Type) return String;
    1. Returns the form string for the external file currently associated with the given file. If an external environment allows alternative specifications of the form (for example, abbreviations using default options), the string returned by the function should correspond to a full specification (that is, it should indicate explicitly all options selected, including default options).
    2. The exception Status_Error is propagated if the given file is not open. 
  1. function Is_Open(File : in File_Type) return Boolean;
    1. Returns True if the file is open (that is, if it is associated with an external file), otherwise returns False.

Implementation Permissions

  1. An implementation may propagate Name_Error or Use_Error if an attempt is made to use an I/O feature that cannot be supported by the implementation due to limitations in the external environment. Any such restriction should be documented.

Sequential Input-Output Operations

Static Semantics

  1. The operations available for sequential input and output are described in this subclause. The exception Status_Error is propagated if any of these operations is attempted for a file that is not open. 
  2. procedure Read(File : in File_Type; Item : out Element_Type);
    1. Operates on a file of mode In_File. Reads an element from the given file, and returns the value of this element in the Item parameter.
    2. The exception Mode_Error is propagated if the mode is not In_File. The exception End_Error is propagated if no more elements can be read from the given file. The exception Data_Error can be propagated if the element read cannot be interpreted as a value of the subtype Element_Type, see section Exceptions in Input-Output. 
  1. procedure Write(File : in File_Type; Item : in Element_Type);
    1. Operates on a file of mode Out_File or Append_File. Writes the value of Item to the given file.
    2. The exception Mode_Error is propagated if the mode is not Out_File or Append_File. The exception Use_Error is propagated if the capacity of the external file is exceeded. 
  1. function End_Of_File(File : in File_Type) return Boolean;
    1. Operates on a file of mode In_File. Returns True if no more elements can be read from the given file; otherwise returns False.
    2. The exception Mode_Error is propagated if the mode is not In_File.

The Generic Package Direct_IO

Static Semantics

  1. The generic library package Direct_IO has the following declaration: 
  2. with Ada.IO_Exceptions;
generic
   type Element_Type is private;
package Ada.Direct_IO is

  3.    type File_Type is limited private;

  4.    type File_Mode is (In_File, Inout_File, Out_File);
   type Count     is range 0 .. implementation-defined;
   subtype Positive_Count is Count range 1 .. Count'Last;

  5.    -- File management

  6.    procedure Create(File : in out File_Type;
                    Mode : in File_Mode := Inout_File;
                    Name : in String := "";
                    Form : in String := "");

  7.    procedure Open  (File : in out File_Type;
                    Mode : in File_Mode;
                    Name : in String;
                    Form : in String := "");

  8.    procedure Close (File : in out File_Type);
   procedure Delete(File : in out File_Type);
   procedure Reset (File : in out File_Type; Mode : in File_Mode);
   procedure Reset (File : in out File_Type);

  9.    function Mode   (File : in File_Type) return File_Mode;
   function Name   (File : in File_Type) return String;
   function Form   (File : in File_Type) return String;

  10.    function Is_Open(File : in File_Type) return Boolean;

  11.    -- Input and output operations

  12.    procedure Read (File : in File_Type; Item : out Element_Type;
                                        From : in Positive_Count);
   procedure Read (File : in File_Type; Item : out Element_Type);

  13.    procedure Write(File : in File_Type; Item : in  Element_Type;
                                        To   : in Positive_Count);
   procedure Write(File : in File_Type; Item : in Element_Type);

  14.    procedure Set_Index(File : in File_Type; To : in Positive_Count);

  15.    function Index(File : in File_Type) return Positive_Count;
   function Size (File : in File_Type) return Count;

  16.    function End_Of_File(File : in File_Type) return Boolean;

  17.    -- Exceptions

  18.    Status_Error : exception renames IO_Exceptions.Status_Error;
   Mode_Error   : exception renames IO_Exceptions.Mode_Error;
   Name_Error   : exception renames IO_Exceptions.Name_Error;
   Use_Error    : exception renames IO_Exceptions.Use_Error;
   Device_Error : exception renames IO_Exceptions.Device_Error;
   End_Error    : exception renames IO_Exceptions.End_Error;
   Data_Error   : exception renames IO_Exceptions.Data_Error;

  19. private
   ... -- not specified by the language
end Ada.Direct_IO;

Direct Input-Output Operations

Static Semantics

  1. The operations available for direct input and output are described in this subclause. The exception Status_Error is propagated if any of these operations is attempted for a file that is not open. 
  2. procedure Read(File : in File_Type; Item : out Element_Type;
                                    From : in  Positive_Count);

procedure Read(File : in File_Type; Item : out Element_Type);
    1. Operates on a file of mode In_File or Inout_File. In the case of the first form, sets the current index of the given file to the index value given by the parameter From. Then (for both forms) returns, in the parameter Item, the value of the element whose position in the given file is specified by the current index of the file; finally, increases the current index by one.
    2. The exception Mode_Error is propagated if the mode of the given file is Out_File. The exception End_Error is propagated if the index to be used exceeds the size of the external file. The exception Data_Error can be propagated if the element read cannot be interpreted as a value of the subtype Element_Type, see section Exceptions in Input-Output. 
  1. procedure Write(File : in File_Type; Item : in Element_Type;
                                     To   : in Positive_Count);

procedure Write(File : in File_Type; Item : in Element_Type);
    1. Operates on a file of mode Inout_File or Out_File. In the case of the first form, sets the index of the given file to the index value given by the parameter To. Then (for both forms) gives the value of the parameter Item to the element whose position in the given file is specified by the current index of the file; finally, increases the current index by one.
    2. The exception Mode_Error is propagated if the mode of the given file is In_File. The exception Use_Error is propagated if the capacity of the external file is exceeded. 
  1. procedure Set_Index(File : in File_Type; To : in Positive_Count);
    1. Operates on a file of any mode. Sets the current index of the given file to the given index value (which may exceed the current size of the file). 
  1. function Index(File : in File_Type) return Positive_Count;
    1. Operates on a file of any mode. Returns the current index of the given file. 
  1. function Size(File : in File_Type) return Count;
    1. Operates on a file of any mode. Returns the current size of the external file that is associated with the given file. 
  1. function End_Of_File(File : in File_Type) return Boolean;
    1. Operates on a file of mode In_File or Inout_File. Returns True if the current index exceeds the size of the external file; otherwise returns False.
    2. The exception Mode_Error is propagated if the mode of the given file is Out_File.
    NOTES
  1. (20) Append_File mode is not supported for the generic package Direct_IO.

The Generic Package Storage_IO

  1. The generic package Storage_IO provides for reading from and writing to an in-memory buffer. This generic package supports the construction of user-defined input-output packages.

    Static Semantics

  2. The generic library package Storage_IO has the following declaration: 
  3. with Ada.IO_Exceptions;
with System.Storage_Elements;
generic
   type Element_Type is private;
package Ada.Storage_IO is
   pragma Preelaborate(Storage_IO);

  4.    Buffer_Size : constant System.Storage_Elements.Storage_Count
     := implementation-defined;
   subtype Buffer_Type is
     System.Storage_Elements.Storage_Array (1..Buffer_Size);

  5.    -- Input and output operations

  6.    procedure Read (Buffer : in      Buffer_Type;
                   Item   :     out Element_Type);

  7.    procedure Write(Buffer :    out Buffer_Type;
                   Item   : in     Element_Type);

  8.    -- Exceptions

  9.    Data_Error : exception renames IO_Exceptions.Data_Error;
end Ada.Storage_IO;
  10. In each instance, the constant Buffer_Size has a value that is the size (in storage elements) of the buffer required to represent the content of an object of subtype Element_Type, including any implicit levels of indirection used by the implementation. The Read and Write procedures of Storage_IO correspond to the Read and Write procedures of Direct_IO (see section The Generic Package Direct_IO) but with the content of the Item parameter being read from or written into the specified Buffer, rather than an external file. NOTES
  11. (21) A buffer used for Storage_IO holds only one element at a time; an external file used for Direct_IO holds a sequence of elements.

Text Input-Output

Static Semantics

  1. This clause describes the package Text_IO, which provides facilities for input and output in human-readable form. Each file is read or written sequentially, as a sequence of characters grouped into lines, and as a sequence of lines grouped into pages. The specification of the package is given below in subclause (see section The Package Text_IO).
  2. The facilities for file management given above, in section File Management and section Sequential Input-Output Operations, are available for text input-output. In place of Read and Write, however, there are procedures Get and Put that input values of suitable types from text files, and output values to them. These values are provided to the Put procedures, and returned by the Get procedures, in a parameter Item. Several overloaded procedures of these names exist, for different types of Item. These Get procedures analyze the input sequences of characters based on lexical elements (see section Lexical Elements.) and return the corresponding values; the Put procedures output the given values as appropriate lexical elements. Procedures Get and Put are also available that input and output individual characters treated as character values rather than as lexical elements. Related to character input are procedures to look ahead at the next character without reading it, and to read a character "immediately" without waiting for an end-of-line to signal availability.
  3. In addition to the procedures Get and Put for numeric and enumeration types of Item that operate on text files, analogous procedures are provided that read from and write to a parameter of type String. These procedures perform the same analysis and composition of character sequences as their counterparts which have a file parameter.
  4. For all Get and Put procedures that operate on text files, and for many other subprograms, there are forms with and without a file parameter. Each such Get procedure operates on an input file, and each such Put procedure operates on an output file. If no file is specified, a default input file or a default output file is used.
  5. At the beginning of program execution the default input and output files are the so-called standard input file and standard output file. These files are open, have respectively the current modes In_File and Out_File, and are associated with two implementation-defined external files. Procedures are provided to change the current default input file and the current default output file.
  6. At the beginning of program execution a default file for program-dependent error-related text output is the so-called standard error file. This file is open, has the current mode Out_File, and is associated with an implementation-defined external file. A procedure is provided to change the current default error file.
  7. From a logical point of view, a text file is a sequence of pages, a page is a sequence of lines, and a line is a sequence of characters; the end of a line is marked by a line terminator; the end of a page is marked by the combination of a line terminator immediately followed by a page terminator; and the end of a file is marked by the combination of a line terminator immediately followed by a page terminator and then a file terminator. Terminators are generated during output; either by calls of procedures provided expressly for that purpose; or implicitly as part of other operations, for example, when a bounded line length, a bounded page length, or both, have been specified for a file.
  8. The actual nature of terminators is not defined by the language and hence depends on the implementation. Although terminators are recognized or generated by certain of the procedures that follow, they are not necessarily implemented as characters or as sequences of characters. Whether they are characters (and if so which ones) in any particular implementation need not concern a user who neither explicitly outputs nor explicitly inputs control characters. The effect of input (Get) or output (Put) of control characters (other than horizontal tabulation) is not specified by the language.
  9. The characters of a line are numbered, starting from one; the number of a character is called its column number. For a line terminator, a column number is also defined: it is one more than the number of characters in the line. The lines of a page, and the pages of a file, are similarly numbered. The current column number is the column number of the next character or line terminator to be transferred. The current line number is the number of the current line. The current page number is the number of the current page. These numbers are values of the subtype Positive_Count of the type Count (by convention, the value zero of the type Count is used to indicate special conditions). 
  10. type Count is range 0 .. implementation-defined;
subtype Positive_Count is Count range 1 .. Count'Last;
  11. For an output file or an append file, a maximum line length can be specified and a maximum page length can be specified. If a value to be output cannot fit on the current line, for a specified maximum line length, then a new line is automatically started before the value is output; if, further, this new line cannot fit on the current page, for a specified maximum page length, then a new page is automatically started before the value is output. Functions are provided to determine the maximum line length and the maximum page length. When a file is opened with mode Out_File or Append_File, both values are zero: by convention, this means that the line lengths and page lengths are unbounded. (Consequently, output consists of a single line if the subprograms for explicit control of line and page structure are not used.) The constant Unbounded is provided for this purpose.

The Package Text_IO

Static Semantics

  1. The library package Text_IO has the following declaration: 
  2. with Ada.IO_Exceptions;
package Ada.Text_IO is

  3.    type File_Type is limited private;

  4.    type File_Mode is (In_File, Out_File, Append_File);

  5.    type Count is range 0 .. implementation-defined;
   subtype Positive_Count is Count range 1 .. Count'Last;
   Unbounded : constant Count := 0; -- line and page length

  6.    subtype Field       is Integer range 0 .. implementation-defined;
   subtype Number_Base is Integer range 2 .. 16;

  7.    type Type_Set is (Lower_Case, Upper_Case);

  8.    -- File Management

  9.    procedure Create (File : in out File_Type;
                     Mode : in File_Mode := Out_File;
                     Name : in String    := "";
                     Form : in String    := "");

  10.    procedure Open   (File : in out File_Type;
                     Mode : in File_Mode;
                     Name : in String;
                     Form : in String := "");

  11.    procedure Close  (File : in out File_Type);
   procedure Delete (File : in out File_Type);
   procedure Reset  (File : in out File_Type; Mode : in File_Mode);
   procedure Reset  (File : in out File_Type);

  12.    function  Mode   (File : in File_Type) return File_Mode;
   function  Name   (File : in File_Type) return String;
   function  Form   (File : in File_Type) return String;

  13.    function  Is_Open(File : in File_Type) return Boolean;

  14.    -- Control of default input and output files

  15.    procedure Set_Input (File : in File_Type);
   procedure Set_Output(File : in File_Type);
   procedure Set_Error (File : in File_Type);

  16.    function Standard_Input  return File_Type;
   function Standard_Output return File_Type;
   function Standard_Error  return File_Type;

  17.    function Current_Input   return File_Type;
   function Current_Output  return File_Type;
   function Current_Error   return File_Type;

  18.    type File_Access is access constant File_Type;

  19.    function Standard_Input  return File_Access;
   function Standard_Output return File_Access;
   function Standard_Error  return File_Access;

  20.    function Current_Input   return File_Access;
   function Current_Output  return File_Access;
   function Current_Error   return File_Access;

  21.    --Buffer control

   procedure Flush (File : in out File_Type);
   procedure Flush;

  22.    -- Specification of line and page lengths

  23.    procedure Set_Line_Length(File : in File_Type; To : in Count);
   procedure Set_Line_Length(To   : in Count);

  24.    procedure Set_Page_Length(File : in File_Type; To : in Count);
   procedure Set_Page_Length(To   : in Count);

  25.    function  Line_Length(File : in File_Type) return Count;
   function  Line_Length return Count;

  26.    function  Page_Length(File : in File_Type) return Count;
   function  Page_Length return Count;

  27.    -- Column, Line, and Page Control

  28.    procedure New_Line   (File    : in File_Type;
                         Spacing : in Positive_Count := 1);
   procedure New_Line   (Spacing : in Positive_Count := 1);

  29.    procedure Skip_Line  (File    : in File_Type;
                         Spacing : in Positive_Count := 1);
   procedure Skip_Line  (Spacing : in Positive_Count := 1);

  30.    function  End_Of_Line(File : in File_Type) return Boolean;
   function  End_Of_Line return Boolean;

  31.    procedure New_Page   (File : in File_Type);
   procedure New_Page;

  32.    procedure Skip_Page  (File : in File_Type);
   procedure Skip_Page;

  33.    function  End_Of_Page(File : in File_Type) return Boolean;
   function  End_Of_Page return Boolean;

  34.    function  End_Of_File(File : in File_Type) return Boolean;
   function  End_Of_File return Boolean;

  35.    procedure Set_Col (File : in File_Type; To : in Positive_Count);
   procedure Set_Col (To   : in Positive_Count);

  36.    procedure Set_Line(File : in File_Type; To : in Positive_Count);
   procedure Set_Line(To   : in Positive_Count);

  37.    function Col (File : in File_Type) return Positive_Count;
   function Col  return Positive_Count;

  38.    function Line(File : in File_Type) return Positive_Count;
   function Line return Positive_Count;

  39.    function Page(File : in File_Type) return Positive_Count;
   function Page return Positive_Count;

  40.    -- Character Input-Output

  41.    procedure Get(File : in  File_Type; Item : out Character);
   procedure Get(Item : out Character);

  42.    procedure Put(File : in  File_Type; Item : in Character);
   procedure Put(Item : in  Character);

  43.    procedure Look_Ahead (File        : in  File_Type;
                         Item        : out Character;
                         End_Of_Line : out Boolean);
   procedure Look_Ahead (Item        : out Character;
                         End_Of_Line : out Boolean);

  44.    procedure Get_Immediate(File      : in  File_Type;
                           Item      : out Character);
   procedure Get_Immediate(Item      : out Character);

  45.    procedure Get_Immediate(File      : in  File_Type;
                           Item      : out Character;
                           Available : out Boolean);
   procedure Get_Immediate(Item      : out Character;
                           Available : out Boolean);

  46.    -- String Input-Output

  47.    procedure Get(File : in  File_Type; Item : out String);
   procedure Get(Item : out String);

  48.    procedure Put(File : in  File_Type; Item : in String);
   procedure Put(Item : in  String);

  49.    procedure Get_Line(File : in  File_Type;
                      Item : out String;
                      Last : out Natural);
   procedure Get_Line(Item : out String; Last : out Natural);

  50.    procedure Put_Line(File : in  File_Type; Item : in String);
   procedure Put_Line(Item : in  String);

  51.    -- Generic packages for Input-Output of Integer Types

  52.    generic
      type Num is range <>;
   package Integer_IO is

  53.       Default_Width : Field := Num'Width;
      Default_Base  : Number_Base := 10;

  54.       procedure Get(File  : in  File_Type;
                    Item  : out Num;
                    Width : in Field := 0);
      procedure Get(Item  : out Num;
                    Width : in  Field := 0);

  55.       procedure Put(File  : in File_Type;
                    Item  : in Num;
                    Width : in Field := Default_Width;
                    Base  : in Number_Base := Default_Base);
      procedure Put(Item  : in Num;
                    Width : in Field := Default_Width;
                    Base  : in Number_Base := Default_Base);
      procedure Get(From : in  String;
                    Item : out Num;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in Num;
                    Base : in Number_Base := Default_Base);

  56.    end Integer_IO;

  57.    generic
      type Num is mod <>;
   package Modular_IO is

  58.       Default_Width : Field := Num'Width;
      Default_Base  : Number_Base := 10;

  59.       procedure Get(File  : in  File_Type;
                    Item  : out Num;
                    Width : in Field := 0);
      procedure Get(Item  : out Num;
                    Width : in  Field := 0);

  60.       procedure Put(File  : in File_Type;
                    Item  : in Num;
                    Width : in Field := Default_Width;
                    Base  : in Number_Base := Default_Base);
      procedure Put(Item  : in Num;
                    Width : in Field := Default_Width;
                    Base  : in Number_Base := Default_Base);
      procedure Get(From : in  String;
                    Item : out Num;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in Num;
                    Base : in Number_Base := Default_Base);

  61.    end Modular_IO;

  62.    -- Generic packages for Input-Output of Real Types

  63.    generic
      type Num is digits <>;
   package Float_IO is

  64.       Default_Fore : Field := 2;
      Default_Aft  : Field := Num'Digits-1;
      Default_Exp  : Field := 3;

  65.       procedure Get(File  : in  File_Type;
                    Item  : out Num;
                    Width : in  Field := 0);
      procedure Get(Item  : out Num;
                    Width : in  Field := 0);

  66.       procedure Put(File : in File_Type;
                    Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
      procedure Put(Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);

  67.       procedure Get(From : in String;
                    Item : out Num;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in Num;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
   end Float_IO;

  68.    generic
      type Num is delta <>;
   package Fixed_IO is

  69.       Default_Fore : Field := Num'Fore;
      Default_Aft  : Field := Num'Aft;
      Default_Exp  : Field := 0;

  70.       procedure Get(File  : in  File_Type;
                    Item  : out Num;
                    Width : in  Field := 0);
      procedure Get(Item  : out Num;
                    Width : in  Field := 0);

  71.       procedure Put(File : in File_Type;
                    Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
      procedure Put(Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);

  72.       procedure Get(From : in  String;
                    Item : out Num;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in Num;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
   end Fixed_IO;

  73.    generic
      type Num is delta <> digits <>;
   package Decimal_IO is

  74.       Default_Fore : Field := Num'Fore;
      Default_Aft  : Field := Num'Aft;
      Default_Exp  : Field := 0;

  75.       procedure Get(File  : in  File_Type;
                    Item  : out Num;
                    Width : in  Field := 0);
      procedure Get(Item  : out Num;
                    Width : in  Field := 0);

  76.       procedure Put(File : in File_Type;
                    Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
      procedure Put(Item : in Num;
                    Fore : in Field := Default_Fore;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);

  77.       procedure Get(From : in  String;
                    Item : out Num;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in Num;
                    Aft  : in Field := Default_Aft;
                    Exp  : in Field := Default_Exp);
   end Decimal_IO;

  78.    -- Generic package for Input-Output of Enumeration Types

  79.    generic
      type Enum is (<>);
   package Enumeration_IO is

  80.       Default_Width   : Field := 0;
      Default_Setting : Type_Set := Upper_Case;

  81.       procedure Get(File : in  File_Type;
                    Item : out Enum);
      procedure Get(Item : out Enum);

  82.       procedure Put(File  : in File_Type;
                    Item  : in Enum;
                    Width : in Field    := Default_Width;
                    Set   : in Type_Set := Default_Setting);
      procedure Put(Item  : in Enum;
                    Width : in Field    := Default_Width;
                    Set   : in Type_Set := Default_Setting);

  83.       procedure Get(From : in  String;
                    Item : out Enum;
                    Last : out Positive);
      procedure Put(To   : out String;
                    Item : in  Enum;
                    Set  : in  Type_Set := Default_Setting);
   end Enumeration_IO;

  84.    -- Exceptions

  85.    Status_Error : exception renames IO_Exceptions.Status_Error;
   Mode_Error   : exception renames IO_Exceptions.Mode_Error;
   Name_Error   : exception renames IO_Exceptions.Name_Error;
   Use_Error    : exception renames IO_Exceptions.Use_Error;
   Device_Error : exception renames IO_Exceptions.Device_Error;
   End_Error    : exception renames IO_Exceptions.End_Error;
   Data_Error   : exception renames IO_Exceptions.Data_Error;
   Layout_Error : exception renames IO_Exceptions.Layout_Error;
private
   ... -- not specified by the language
end Ada.Text_IO;

Text File Management

Static Semantics

  1. The only allowed file modes for text files are the modes In_File, Out_File, and Append_File. The subprograms given in section File Management, for the control of external files, and the function End_Of_File given in section Sequential Input-Output Operations, for sequential input-output, are also available for text files. There is also a version of End_Of_File that refers to the current default input file. For text files, the procedures have the following additional effects:
    1. For the procedures Create and Open: After a file with mode Out_File or Append_File is opened, the page length and line length are unbounded (both have the conventional value zero). After a file (of any mode) is opened, the current column, current line, and current page numbers are set to one. If the mode is Append_File, it is implementation defined whether a page terminator will separate preexisting text in the file from the new text to be written.
    2. For the procedure Close: If the file has the current mode Out_File or Append_File, has the effect of calling New_Page, unless the current page is already terminated; then outputs a file terminator.
    3. For the procedure Reset: If the file has the current mode Out_File or Append_File, has the effect of calling New_Page, unless the current page is already terminated; then outputs a file terminator. The current column, line, and page numbers are set to one, and the line and page lengths to Unbounded. If the new mode is Append_File, it is implementation defined whether a page terminator will separate preexisting text in the file from the new text to be written.
  1. The exception Mode_Error is propagated by the procedure Reset upon an attempt to change the mode of a file that is the current default input file, the current default output file, or the current default error file. NOTES
  2. (22) An implementation can define the Form parameter of Create and Open to control effects including the following:
    1. the interpretation of line and column numbers for an interactive file, and
    2. the interpretation of text formats in a file created by a foreign program.

Default Input, Output, and Error Files

Static Semantics

  1. The following subprograms provide for the control of the particular default files that are used when a file parameter is omitted from a Get, Put, or other operation of text input-output described below, or when application-dependent error-related text is to be output. 
  2. procedure Set_Input(File : in File_Type);
    1. Operates on a file of mode In_File. Sets the current default input file to File.
    2. The exception Status_Error is propagated if the given file is not open. The exception Mode_Error is propagated if the mode of the given file is not In_File. 
  1. procedure Set_Output(File : in File_Type);
procedure Set_Error (File : in File_Type);
    1. Each operates on a file of mode Out_File or Append_File. Set_Output sets the current default output file to File. Set_Error sets the current default error file to File. The exception Status_Error is propagated if the given file is not open. The exception Mode_Error is propagated if the mode of the given file is not Out_File or Append_File. 
  1. function Standard_Input return File_Type;
function Standard_Input return File_Access;
    1. Returns the standard input file, see section Text Input-Output, or an access value designating the standard input file, respectively. 
  1. function Standard_Output return File_Type;
function Standard_Output return File_Access;
    1. Returns the standard output file, see section Text Input-Output, or an access value designating the standard output file, respectively. 
  1. function Standard_Error return File_Type;
function Standard_Error return File_Access;
    1. Returns the standard error file, see section Text Input-Output, or an access value designating the standard output file, respectively.
    2. The Form strings implicitly associated with the opening of Standard_Input, Standard_Output, and Standard_Error at the start of program execution are implementation defined. 
  1. function Current_Input return File_Type;
function Current_Input return File_Access;
    1. Returns the current default input file, or an access value designating the current default input file, respectively. 
  1. function Current_Output return File_Type;
function Current_Output return File_Access;
    1. Returns the current default output file, or an access value designating the current default output file, respectively. 
  1. function Current_Error return File_Type;
function Current_Error return File_Access;
    1. Returns the current default error file, or an access value designating the current default error file, respectively. 
  1. procedure Flush (File : in out File_Type);
procedure Flush;
    1. The effect of Flush is the same as the corresponding subprogram in Streams.Stream_IO, see section The Package Streams.Stream_IO. If File is not explicitly specified, Current_Output is used.

Erroneous Execution

  1. The execution of a program is erroneous if it attempts to use a current default input, default output, or default error file that no longer exists.
  2. If the Close operation is applied to a file object that is also serving as the default input, default output, or default error file, then subsequent operations on such a default file are erroneous. NOTES
  3. (23) The standard input, standard output, and standard error files cannot be opened, closed, reset, or deleted, because the parameter File of the corresponding procedures has the mode in out.
  4. (24) The standard input, standard output, and standard error files are different file objects, but not necessarily different external files.

Specification of Line and Page Lengths

Static Semantics

  1. The subprograms described in this subclause are concerned with the line and page structure of a file of mode Out_File or Append_File. They operate either on the file given as the first parameter, or, in the absence of such a file parameter, on the current default output file. They provide for output of text with a specified maximum line length or page length. In these cases, line and page terminators are output implicitly and automatically when needed. When line and page lengths are unbounded (that is, when they have the conventional value zero), as in the case of a newly opened file, new lines and new pages are only started when explicitly called for.
  2. In all cases, the exception Status_Error is propagated if the file to be used is not open; the exception Mode_Error is propagated if the mode of the file is not Out_File or Append_File. 
  3. procedure Set_Line_Length(File : in File_Type; To : in Count);
procedure Set_Line_Length(To   : in Count);
    1. Sets the maximum line length of the specified output or append file to the number of characters specified by To. The value zero for To specifies an unbounded line length.
    2. The exception Use_Error is propagated if the specified line length is inappropriate for the associated external file. 
  1. procedure Set_Page_Length(File : in File_Type; To : in Count);
procedure Set_Page_Length(To   : in Count);
    1. Sets the maximum page length of the specified output or append file to the number of lines specified by To. The value zero for To specifies an unbounded page length.
    2. The exception Use_Error is propagated if the specified page length is inappropriate for the associated external file. 
  1. function Line_Length(File : in File_Type) return Count;
function Line_Length return Count;
    1. Returns the maximum line length currently set for the specified output or append file, or zero if the line length is unbounded. 
  1. function Page_Length(File : in File_Type) return Count;
function Page_Length return Count;
    1. Returns the maximum page length currently set for the specified output or append file, or zero if the page length is unbounded.

Operations on Columns, Lines, and Pages

Static Semantics

  1. The subprograms described in this subclause provide for explicit control of line and page structure; they operate either on the file given as the first parameter, or, in the absence of such a file parameter, on the appropriate (input or output) current default file. The exception Status_Error is propagated by any of these subprograms if the file to be used is not open. 
  2. procedure New_Line(File    : in File_Type;
                   Spacing : in Positive_Count := 1);
procedure New_Line(Spacing : in Positive_Count := 1);
    1. Operates on a file of mode Out_File or Append_File.
    2. For a Spacing of one: Outputs a line terminator and sets the current column number to one. Then increments the current line number by one, except in the case that the current line number is already greater than or equal to the maximum page length, for a bounded page length; in that case a page terminator is output, the current page number is incremented by one, and the current line number is set to one.
    3. For a Spacing greater than one, the above actions are performed Spacing times.
    4. The exception Mode_Error is propagated if the mode is not Out_File or Append_File. 
  1. procedure Skip_Line(File    : in File_Type;
                    Spacing : in Positive_Count := 1);
procedure Skip_Line(Spacing : in Positive_Count := 1);
    1. Operates on a file of mode In_File.
    2. For a Spacing of one: Reads and discards all characters until a line terminator has been read, and then sets the current column number to one. If the line terminator is not immediately followed by a page terminator, the current line number is incremented by one. Otherwise, if the line terminator is immediately followed by a page terminator, then the page terminator is skipped, the current page number is incremented by one, and the current line number is set to one.
    3. For a Spacing greater than one, the above actions are performed Spacing times.
    4. The exception Mode_Error is propagated if the mode is not In_File. The exception End_Error is propagated if an attempt is made to read a file terminator. 
  1. function End_Of_Line(File : in File_Type) return Boolean;
function End_Of_Line return Boolean;
    1. Operates on a file of mode In_File. Returns True if a line terminator or a file terminator is next; otherwise returns False.
    2. The exception Mode_Error is propagated if the mode is not In_File. 
  1. procedure New_Page(File : in File_Type);
procedure New_Page;
    1. Operates on a file of mode Out_File or Append_File. Outputs a line terminator if the current line is not terminated, or if the current page is empty (that is, if the current column and line numbers are both equal to one). Then outputs a page terminator, which terminates the current page. Adds one to the current page number and sets the current column and line numbers to one.
    2. The exception Mode_Error is propagated if the mode is not Out_File or Append_File. 
  1. procedure Skip_Page(File : in File_Type);
procedure Skip_Page;
    1. Operates on a file of mode In_File. Reads and discards all characters and line terminators until a page terminator has been read. Then adds one to the current page number, and sets the current column and line numbers to one.
    2. The exception Mode_Error is propagated if the mode is not In_File. The exception End_Error is propagated if an attempt is made to read a file terminator. 
  1. function End_Of_Page(File : in File_Type) return Boolean;
function End_Of_Page return Boolean;
    1. Operates on a file of mode In_File. Returns True if the combination of a line terminator and a page terminator is next, or if a file terminator is next; otherwise returns False.
    2. The exception Mode_Error is propagated if the mode is not In_File. 
  1. function End_Of_File(File : in File_Type) return Boolean;
function End_Of_File return Boolean;
    1. Operates on a file of mode In_File. Returns True if a file terminator is next, or if the combination of a line, a page, and a file terminator is next; otherwise returns False.
    2. The exception Mode_Error is propagated if the mode is not In_File.
    3. The following subprograms provide for the control of the current position of reading or writing in a file. In all cases, the default file is the current output file. 
  1. procedure Set_Col(File : in File_Type; To : in Positive_Count);
procedure Set_Col(To   : in Positive_Count);
    1. If the file mode is Out_File or Append_File:
      1. If the value specified by To is greater than the current column number, outputs spaces, adding one to the current column number after each space, until the current column number equals the specified value. If the value specified by To is equal to the current column number, there is no effect. If the value specified by To is less than the current column number, has the effect of calling New_Line (with a spacing of one), then outputs (To - 1) spaces, and sets the current column number to the specified value.
      2. The exception Layout_Error is propagated if the value specified by To exceeds Line_Length when the line length is bounded (that is, when it does not have the conventional value zero).
    1. If the file mode is In_File:
      1. Reads (and discards) individual characters, line terminators, and page terminators, until the next character to be read has a column number that equals the value specified by To; there is no effect if the current column number already equals this value. Each transfer of a character or terminator maintains the current column, line, and page numbers in the same way as a Get procedure, see section Get and Put Procedures. (Short lines will be skipped until a line is reached that has a character at the specified column position.)
      2. The exception End_Error is propagated if an attempt is made to read a file terminator. 
  1. procedure Set_Line(File : in File_Type; To : in Positive_Count);
procedure Set_Line(To   : in Positive_Count);
    1. If the file mode is Out_File or Append_File:
      1. If the value specified by To is greater than the current line number, has the effect of repeatedly calling New_Line (with a spacing of one), until the current line number equals the specified value. If the value specified by To is equal to the current line number, there is no effect. If the value specified by To is less than the current line number, has the effect of calling New_Page followed by a call of New_Line with a spacing equal to (To - 1).
      2. The exception Layout_Error is propagated if the value specified by To exceeds Page_Length when the page length is bounded (that is, when it does not have the conventional value zero).
    1. If the mode is In_File:
      1. Has the effect of repeatedly calling Skip_Line (with a spacing of one), until the current line number equals the value specified by To; there is no effect if the current line number already equals this value. (Short pages will be skipped until a page is reached that has a line at the specified line position.)
      2. The exception End_Error is propagated if an attempt is made to read a file terminator. 
  1. function Col(File : in File_Type) return Positive_Count;
function Col return Positive_Count;
    1. Returns the current column number.
    2. The exception Layout_Error is propagated if this number exceeds Count'Last. 
  1. function Line(File : in File_Type) return Positive_Count;
function Line return Positive_Count;
    1. Returns the current line number.
    2. The exception Layout_Error is propagated if this number exceeds Count'Last. 
  1. function Page(File : in File_Type) return Positive_Count;
function Page return Positive_Count;
    1. Returns the current page number.
    2. The exception Layout_Error is propagated if this number exceeds Count'Last.
  1. The column number, line number, or page number are allowed to exceed Count'Last (as a consequence of the input or output of sufficiently many characters, lines, or pages). These events do not cause any exception to be propagated. However, a call of Col, Line, or Page propagates the exception Layout_Error if the corresponding number exceeds Count'Last. NOTES
  2. (25) A page terminator is always skipped whenever the preceding line terminator is skipped. An implementation may represent the combination of these terminators by a single character, provided that it is properly recognized on input.

Get and Put Procedures

Static Semantics

  1. The procedures Get and Put for items of the type Character, String, numeric types, and enumeration types are described in subsequent subclauses. Features of these procedures that are common to most of these types are described in this subclause. The Get and Put procedures for items of type Character and String deal with individual character values; the Get and Put procedures for numeric and enumeration types treat the items as lexical elements.
  2. All procedures Get and Put have forms with a file parameter, written first. Where this parameter is omitted, the appropriate (input or output) current default file is understood to be specified. Each procedure Get operates on a file of mode In_File. Each procedure Put operates on a file of mode Out_File or Append_File.
  3. All procedures Get and Put maintain the current column, line, and page numbers of the specified file: the effect of each of these procedures upon these numbers is the result of the effects of individual transfers of characters and of individual output or skipping of terminators. Each transfer of a character adds one to the current column number. Each output of a line terminator sets the current column number to one and adds one to the current line number. Each output of a page terminator sets the current column and line numbers to one and adds one to the current page number. For input, each skipping of a line terminator sets the current column number to one and adds one to the current line number; each skipping of a page terminator sets the current column and line numbers to one and adds one to the current page number. Similar considerations apply to the procedures Get_Line, Put_Line, and Set_Col.
  4. Several Get and Put procedures, for numeric and enumeration types, have format parameters which specify field lengths; these parameters are of the nonnegative subtype Field of the type Integer.
  5. Input-output of enumeration values uses the syntax of the corresponding lexical elements. Any Get procedure for an enumeration type begins by skipping any leading blanks, or line or page terminators. Get procedures for numeric or enumeration types start by skipping leading blanks, where a blank is defined as a space or a horizontal tabulation character. Next, characters are input only so long as the sequence input is an initial sequence of an identifier or of a character literal (in particular, input ceases when a line terminator is encountered). The character or line terminator that causes input to cease remains available for subsequent input.
  6. For a numeric type, the Get procedures have a format parameter called Width. If the value given for this parameter is zero, the Get procedure proceeds in the same manner as for enumeration types, but using the syntax of numeric literals instead of that of enumeration literals. If a nonzero value is given, then exactly Width characters are input, or the characters up to a line terminator, whichever comes first; any skipped leading blanks are included in the count. The syntax used for numeric literals is an extended syntax that allows a leading sign (but no intervening blanks, or line or page terminators) and that also allows (for real types) an integer literal as well as forms that have digits only before the point or only after the point.
  7. Any Put procedure, for an item of a numeric or an enumeration type, outputs the value of the item as a numeric literal, identifier, or character literal, as appropriate. This is preceded by leading spaces if required by the format parameters Width or Fore (as described in later subclauses), and then a minus sign for a negative value; for an enumeration type, the spaces follow instead of leading. The format given for a Put procedure is overridden if it is insufficiently wide, by using the minimum needed width.
  8. Two further cases arise for Put procedures for numeric and enumeration types, if the line length of the specified output file is bounded (that is, if it does not have the conventional value zero). If the number of characters to be output does not exceed the maximum line length, but is such that they cannot fit on the current line, starting from the current column, then (in effect) New_Line is called (with a spacing of one) before output of the item. Otherwise, if the number of characters exceeds the maximum line length, then the exception Layout_Error is propagated and nothing is output.
  9. The exception Status_Error is propagated by any of the procedures Get, Get_Line, Put, and Put_Line if the file to be used is not open. The exception Mode_Error is propagated by the procedures Get and Get_Line if the mode of the file to be used is not In_File; and by the procedures Put and Put_Line, if the mode is not Out_File or Append_File.
  10. The exception End_Error is propagated by a Get procedure if an attempt is made to skip a file terminator. The exception Data_Error is propagated by a Get procedure if the sequence finally input is not a lexical element corresponding to the type, in particular if no characters were input; for this test, leading blanks are ignored; for an item of a numeric type, when a sign is input, this rule applies to the succeeding numeric literal. The exception Layout_Error is propagated by a Put procedure that outputs to a parameter of type String, if the length of the actual string is insufficient for the output of the item.

    Examples

  11. In the examples, here and in section Input-Output for Integer Types, and section Input-Output for Real Types, the string quotes and the lower case letter b are not transferred: they are shown only to reveal the layout and spaces. 
  12. N : Integer;
   ...
Get(N);

  13. -- Characters at input  Sequence input  Value of N

-- bb-12535b            -12535          -12535
-- bb12_535e1b           12_535e1        125350
-- bb12_535e;            12_535e         (none) Data_Error raised
  14. Example of overridden width parameter: 
  15. Put(Item => -23, Width => 2);  --  "-23"

Input-Output of Characters and Strings

Static Semantics

  1. For an item of type Character the following procedures are provided: 
  2. procedure Get(File : in File_Type; Item : out Character);
procedure Get(Item : out Character);
    1. After skipping any line terminators and any page terminators, reads the next character from the specified input file and returns the value of this character in the out parameter Item.
    2. The exception End_Error is propagated if an attempt is made to skip a file terminator. 
  1. procedure Put(File : in File_Type; Item : in Character);
procedure Put(Item : in Character);
    1. If the line length of the specified output file is bounded (that is, does not have the conventional value zero), and the current column number exceeds it, has the effect of calling New_Line with a spacing of one. Then, or otherwise, outputs the given character to the file. 
  1. procedure Look_Ahead (File        : in  File_Type;
                      Item        : out Character;
                      End_Of_Line : out Boolean);

procedure Look_Ahead (Item        : out Character;
                      End_Of_Line : out Boolean);
    1. Mode_Error is propagated if the mode of the file is not In_File. Sets End_Of_Line to True if at end of line, including if at end of page or at end of file; in each of these cases the value of Item is not specified. Otherwise End_Of_Line is set to False and Item is set to the the next character (without consuming it) from the file. 
  1. procedure Get_Immediate(File : in  File_Type;
                        Item : out Character);

procedure Get_Immediate(Item : out Character);
    1. Reads the next character, either control or graphic, from the specified File or the default input file. Mode_Error is propagated if the mode of the file is not In_File. End_Error is propagated if at the end of the file. The current column, line and page numbers for the file are not affected. 
  1. procedure Get_Immediate(File      : in  File_Type;
                        Item      : out Character;
                        Available : out Boolean);

procedure Get_Immediate(Item      : out Character;
                        Available : out Boolean);
    1. If a character, either control or graphic, is available from the specified File or the default input file, then the character is read; Available is True and Item contains the value of this character. If a character is not available, then Available is False and the value of Item is not specified. Mode_Error is propagated if the mode of the file is not In_File. End_Error is propagated if at the end of the file. The current column, line and page numbers for the file are not affected.
  1. For an item of type String the following procedures are provided: 
  2. procedure Get(File : in File_Type; Item : out String);
procedure Get(Item : out String);
    1. Determines the length of the given string and attempts that number of Get operations for successive characters of the string (in particular, no operation is performed if the string is null). 
  1. procedure Put(File : in File_Type; Item : in String);
procedure Put(Item : in String);
    1. Determines the length of the given string and attempts that number of Put operations for successive characters of the string (in particular, no operation is performed if the string is null). 
  1. procedure Get_Line(File : in     File_Type;
                   Item :    out String;
                   Last :    out Natural);

procedure Get_Line(Item : out String; Last : out Natural);
    1. Reads successive characters from the specified input file and assigns them to successive characters of the specified string. Reading stops if the end of the string is met. Reading also stops if the end of the line is met before meeting the end of the string; in this case Skip_Line is (in effect) called with a spacing of 1. The values of characters not assigned are not specified.
    2. If characters are read, returns in Last the index value such that Item(Last) is the last character assigned (the index of the first character assigned is Item'First). If no characters are read, returns in Last an index value that is one less than Item'First. The exception End_Error is propagated if an attempt is made to skip a file terminator. 
  1. procedure Put_Line(File : in File_Type; Item : in String);
procedure Put_Line(Item : in String);
    1. Calls the procedure Put for the given string, and then the procedure New_Line with a spacing of one.

Implementation Advice

  1. The Get_Immediate procedures should be implemented with unbuffered input. For a device such as a keyboard, input should be "available" if a key has already been typed, whereas for a disk file, input should always be available except at end of file. For a file associated with a keyboard-like device, any line-editing features of the underlying operating system should be disabled during the execution of Get_Immediate. NOTES
  2. (26) Get_Immediate can be used to read a single key from the keyboard "immediately"; that is, without waiting for an end of line. In a call of Get_Immediate without the parameter Available, the caller will wait until a character is available.
  3. (27) In a literal string parameter of Put, the enclosing string bracket characters are not output. Each doubled string bracket character in the enclosed string is output as a single string bracket character, as a consequence of the rule for string literals, see section String Literals.
  4. (28) A string read by Get or written by Put can extend over several lines. An implementation is allowed to assume that certain external files do not contain page terminators, in which case Get_Line and Skip_Line can return as soon as a line terminator is read.

Input-Output for Integer Types

Static Semantics

  1. The following procedures are defined in the generic packages Integer_IO and Modular_IO, which have to be instantiated for the appropriate signed integer or modular type respectively (indicated by Num in the specifications).
  2. Values are output as decimal or based literals, without low line characters or exponent, and, for Integer_IO, preceded by a minus sign if negative. The format (which includes any leading spaces and minus sign) can be specified by an optional field width parameter. Values of widths of fields in output formats are of the nonnegative integer subtype Field. Values of bases are of the integer subtype Number_Base. 
  3. subtype Number_Base is Integer range 2 .. 16;
  4. The default field width and base to be used by output procedures are defined by the following variables that are declared in the generic packages Integer_IO and Modular_IO: 
  5. Default_Width : Field := Num'Width;
Default_Base  : Number_Base := 10;
  6. The following procedures are provided: 
  7. procedure Get(File  : in     File_Type;
              Item  :    out Num;
              Width : in     Field := 0);

procedure Get(Item : out Num; Width : in Field := 0);
    1. If the value of the parameter Width is zero, skips any leading blanks, line terminators, or page terminators, then reads a plus sign if present or (for a signed type only) a minus sign if present, then reads the longest possible sequence of characters matching the syntax of a numeric literal without a point. If a nonzero value of Width is supplied, then exactly Width characters are input, or the characters (possibly none) up to a line terminator, whichever comes first; any skipped leading blanks are included in the count.
    2. Returns, in the parameter Item, the value of type Num that corresponds to the sequence input.
    3. 10 The exception Data_Error is propagated if the sequence of characters read does not form a legal integer literal or if the value obtained is not of the subtype Num (for Integer_IO) or is not in the base range of Num (for Modular_IO). 
  1. procedure Put(File  : in File_Type;
              Item  : in Num;
              Width : in Field := Default_Width;
              Base  : in Number_Base := Default_Base);

procedure Put(Item  : in Num;
              Width : in Field := Default_Width;
              Base  : in Number_Base := Default_Base);
    1. Outputs the value of the parameter Item as an integer literal, with no low lines, no exponent, and no leading zeros (but a single zero for the value zero), and a preceding minus sign for a negative value.
    2. If the resulting sequence of characters to be output has fewer than Width characters, then leading spaces are first output to make up the difference.
    3. Uses the syntax for decimal literal if the parameter Base has the value ten (either explicitly or through Default_Base); otherwise, uses the syntax for based literal, with any letters in upper case. 
  1. procedure Get(From : in     String;
              Item :    out Num;
              Last :    out Positive);
    1. Reads an integer value from the beginning of the given string, following the same rules as the Get procedure that reads an integer value from a file, but treating the end of the string as a file terminator. Returns, in the parameter Item, the value of type Num that corresponds to the sequence input. Returns in Last the index value such that From(Last) is the last character read.
    2. The exception Data_Error is propagated if the sequence input does not have the required syntax or if the value obtained is not of the subtype Num. 
  1. procedure Put(To   :    out String;
              Item : in     Num;
              Base : in     Number_Base := Default_Base);
    1. Outputs the value of the parameter Item to the given string, following the same rule as for output to a file, using the length of the given string as the value for Width.
  1. Integer_Text_IO is a library package that is a nongeneric equivalent to Text_IO.Integer_IO for the predefined type Integer: 
  2. with Ada.Text_IO;
package Ada.Integer_Text_IO is new Ada.Text_IO.Integer_IO(Integer);
  3. For each predefined signed integer type, a nongeneric equivalent to Text_IO.Integer_IO is provided, with names such as Ada.Long_Integer_Text_IO.

    Implementation Permissions

  4. The nongeneric equivalent packages may, but need not, be actual instantiations of the generic package for the appropriate predefined type. NOTES
  5. (29) For Modular_IO, execution of Get propagates Data_Error if the sequence of characters read forms an integer literal outside the range 0..Num'Last.

    Examples 

  1. package Int_IO is new Integer_IO(Small_Int); use Int_IO;
-- default format used at instantiation,
-- Default_Width = 4, Default_Base = 10

  2. Put(126);                            -- "b126"
Put(-126, 7);                        -- "bbb-126"
Put(126, Width => 13, Base => 2);    -- "bbb2#1111110#"

Input-Output for Real Types

Static Semantics

  1. The following procedures are defined in the generic packages Float_IO, Fixed_IO, and Decimal_IO, which have to be instantiated for the appropriate floating point, ordinary fixed point, or decimal fixed point type respectively (indicated by Num in the specifications).
  2. Values are output as decimal literals without low line characters. The format of each value output consists of a Fore field, a decimal point, an Aft field, and (if a nonzero Exp parameter is supplied) the letter E and an Exp field. The two possible formats thus correspond to: 
  3. Fore  .  Aft
  4. and to: 
  5. Fore  .  Aft  E  Exp
  6. without any spaces between these fields. The Fore field may include leading spaces, and a minus sign for negative values. The Aft field includes only decimal digits (possibly with trailing zeros). The Exp field includes the sign (plus or minus) and the exponent (possibly with leading zeros).
  7. For floating point types, the default lengths of these fields are defined by the following variables that are declared in the generic package Float_IO: 
  8. Default_Fore : Field := 2;
Default_Aft  : Field := Num'Digits-1;
Default_Exp  : Field := 3;
  9. For ordinary or decimal fixed point types, the default lengths of these fields are defined by the following variables that are declared in the generic packages Fixed_IO and Decimal_IO, respectively: 
  10. Default_Fore : Field := Num'Fore;
Default_Aft  : Field := Num'Aft;
Default_Exp  : Field := 0;
  11. The following procedures are provided: 
  12. procedure Get(File  : in     File_Type;
              Item  :    out Num;
              Width : in     Field := 0);

procedure Get(Item : out Num; Width : in Field := 0);
    1. If the value of the parameter Width is zero, skips any leading blanks, line terminators, or page terminators, then reads the longest possible sequence of characters matching the syntax of any of the following (see section Numeric Literals):
      1. [+|-]numeric_literal
      2. [+|-]numeral.[exponent]
      3. [+|-].numeral[exponent]
      4. [+|-]base#based_numeral.#[exponent]
      5. [+|-]base#.based_numeral#[exponent]
    1. If a nonzero value of Width is supplied, then exactly Width characters are input, or the characters (possibly none) up to a line terminator, whichever comes first; any skipped leading blanks are included in the count.
    2. Returns in the parameter Item the value of type Num that corresponds to the sequence input, preserving the sign (positive if none has been specified) of a zero value if Num is a floating point type and Num'Signed_Zeros is True.
    3. The exception Data_Error is propagated if the sequence input does not have the required syntax or if the value obtained is not of the subtype Num. 
  1. procedure Put(File : in File_Type;
              Item : in Num;
              Fore : in Field := Default_Fore;
              Aft  : in Field := Default_Aft;
              Exp  : in Field := Default_Exp);

procedure Put(Item : in Num;
              Fore : in Field := Default_Fore;
              Aft  : in Field := Default_Aft;
              Exp  : in Field := Default_Exp);
    1. Outputs the value of the parameter Item as a decimal literal with the format defined by Fore, Aft and Exp. If the value is negative, or if Num is a floating point type where Num'Signed_Zeros is True and the value is a negatively signed zero, then a minus sign is included in the integer part. If Exp has the value zero, then the integer part to be output has as many digits as are needed to represent the integer part of the value of Item, overriding Fore if necessary, or consists of the digit zero if the value of Item has no integer part.
    2. If Exp has a value greater than zero, then the integer part to be output has a single digit, which is nonzero except for the value 0.0 of Item.
    3. In both cases, however, if the integer part to be output has fewer than Fore characters, including any minus sign, then leading spaces are first output to make up the difference. The number of digits of the fractional part is given by Aft, or is one if Aft equals zero. The value is rounded; a value of exactly one half in the last place is rounded away from zero.
    4. If Exp has the value zero, there is no exponent part. If Exp has a value greater than zero, then the exponent part to be output has as many digits as are needed to represent the exponent part of the value of Item (for which a single digit integer part is used), and includes an initial sign (plus or minus). If the exponent part to be output has fewer than Exp characters, including the sign, then leading zeros precede the digits, to make up the difference. For the value 0.0 of Item, the exponent has the value zero. 
  1. procedure Get(From : in String; Item : out Num; Last : out Positive);
    1. Reads a real value from the beginning of the given string, following the same rule as the Get procedure that reads a real value from a file, but treating the end of the string as a file terminator. Returns, in the parameter Item, the value of type Num that corresponds to the sequence input. Returns in Last the index value such that From(Last) is the last character read.
    2. The exception Data_Error is propagated if the sequence input does not have the required syntax, or if the value obtained is not of the subtype Num. 
  1. procedure Put(To   : out String;
              Item : in Num;
              Aft  : in Field := Default_Aft;
              Exp  : in Field := Default_Exp);
    1. Outputs the value of the parameter Item to the given string, following the same rule as for output to a file, using a value for Fore such that the sequence of characters output exactly fills the string, including any leading spaces.
  1. Float_Text_IO is a library package that is a nongeneric equivalent to Text_IO.Float_IO for the predefined type Float: 
  2. with Ada.Text_IO;
package Ada.Float_Text_IO is new Ada.Text_IO.Float_IO(Float);
  3. For each predefined floating point type, a nongeneric equivalent to Text_IO.Float_IO is provided, with names such as Ada.Long_Float_Text_IO.

    Implementation Permissions

  4. An implementation may extend Get and Put for floating point types to support special values such as infinities and NaNs.
  5. The implementation of Put need not produce an output value with greater accuracy than is supported for the base subtype. The additional accuracy, if any, of the value produced by Put when the number of requested digits in the integer and fractional parts exceeds the required accuracy is implementation defined.
  6. The nongeneric equivalent packages may, but need not, be actual instantiations of the generic package for the appropriate predefined type. NOTES
  7. (30) For an item with a positive value, if output to a string exactly fills the string without leading spaces, then output of the corresponding negative value will propagate Layout_Error.
  8. (31) The rules for the Value attribute, see section Scalar Types, and the rules for Get are based on the same set of formats.

    Examples 

  1. package Real_IO is new Float_IO(Real); use Real_IO;
-- default format used at instantiation, Default_Exp = 3

  2. X : Real := -123.4567;  --  digits 8   (see section Floating Point Types)

  3. Put(X);  -- default format "-1.2345670E+02"
Put(X, Fore => 5, Aft => 3, Exp => 2);  -- "bbb-1.235E+2"
Put(X, 5, 3, 0);  -- "b-123.457"

Input-Output for Enumeration Types

Static Semantics

  1. The following procedures are defined in the generic package Enumeration_IO, which has to be instantiated for the appropriate enumeration type (indicated by Enum in the specification).
  2. Values are output using either upper or lower case letters for identifiers. This is specified by the parameter Set, which is of the enumeration type Type_Set. 
  3. type Type_Set is (Lower_Case, Upper_Case);
  4. The format (which includes any trailing spaces) can be specified by an optional field width parameter. The default field width and letter case are defined by the following variables that are declared in the generic package Enumeration_IO: 
  5. Default_Width   : Field := 0;
Default_Setting : Type_Set := Upper_Case;
  6. The following procedures are provided: 
  7. procedure Get(File : in File_Type; Item : out Enum);
procedure Get(Item : out Enum);
    1. After skipping any leading blanks, line terminators, or page terminators, reads an identifier according to the syntax of this lexical element (lower and upper case being considered equivalent), or a character literal according to the syntax of this lexical element (including the apostrophes). Returns, in the parameter Item, the value of type Enum that corresponds to the sequence input.
    2. The exception Data_Error is propagated if the sequence input does not have the required syntax, or if the identifier or character literal does not correspond to a value of the subtype Enum. 
  1. procedure Put(File  : in File_Type;
              Item  : in Enum;
              Width : in Field := Default_Width;
              Set   : in Type_Set := Default_Setting);

procedure Put(Item  : in Enum;
              Width : in Field := Default_Width;
              Set   : in Type_Set := Default_Setting);
    1. Outputs the value of the parameter Item as an enumeration literal (either an identifier or a character literal). The optional parameter Set indicates whether lower case or upper case is used for identifiers; it has no effect for character literals. If the sequence of characters produced has fewer than Width characters, then trailing spaces are finally output to make up the difference. If Enum is a character type, the sequence of characters produced is as for Enum'Image(Item), as modified by the Width and Set parameters. 
  1. procedure Get(From : in     String;
              Item :    out Enum;
              Last :    out Positive);
    1. Reads an enumeration value from the beginning of the given string, following the same rule as the Get procedure that reads an enumeration value from a file, but treating the end of the string as a file terminator. Returns, in the parameter Item, the value of type Enum that corresponds to the sequence input. Returns in Last the index value such that From(Last) is the last character read.
    2. The exception Data_Error is propagated if the sequence input does not have the required syntax, or if the identifier or character literal does not correspond to a value of the subtype Enum. 
  1. procedure Put(To   : out String;
              Item : in Enum;
              Set  : in Type_Set := Default_Setting);
    1. Outputs the value of the parameter Item to the given string, following the same rule as for output to a file, using the length of the given string as the value for Width.
  1. Although the specification of the generic package Enumeration_IO would allow instantiation for an float type, this is not the intended purpose of this generic package, and the effect of such instantiations is not defined by the language. NOTES
  2. (32) There is a difference between Put defined for characters, and for enumeration values. Thus 
  3. Ada.Text_IO.Put('A');  --  outputs the character A

  4. package Char_IO is new Ada.Text_IO.Enumeration_IO(Character);
Char_IO.Put('A');  -- outputs the character 'A', between apostrophes
  5. (33) The type Boolean is an enumeration type, hence Enumeration_IO can be instantiated for this type.

Wide Text Input-Output

  1. The package Wide_Text_IO provides facilities for input and output in human-readable form. Each file is read or written sequentially, as a sequence of wide characters grouped into lines, and as a sequence of lines grouped into pages.

    Static Semantics

  2. The specification of package Wide_Text_IO is the same as that for Text_IO, except that in each Get, Look_Ahead, Get_Immediate, Get_Line, Put, and Put_Line procedure, any occurrence of Character is replaced by Wide_Character, and any occurrence of String is replaced by Wide_String.
  3. Nongeneric equivalents of Wide_Text_IO.Integer_IO and Wide_Text_IO.Float_IO are provided (as for Text_IO) for each predefined numeric type, with names such as Ada.Integer_Wide_Text_IO, Ada.Long_Integer_Wide_Text_IO, Ada.Float_Wide_Text_IO, Ada.Long_Float_Wide_Text_IO.

Stream Input-Output

  1. The packages Streams.Stream_IO, Text_IO.Text_Streams, and Wide_Text_IO.Text_Streams provide stream-oriented operations on files.

The Package Streams.Stream_IO

  1. The subprograms in the child package Streams.Stream_IO provide control over stream files. Access to a stream file is either sequential, via a call on Read or Write to transfer an array of stream elements, or positional (if supported by the implementation for the given file), by specifying a relative index for an element. Since a stream file can be converted to a Stream_Access value, calling stream-oriented attribute subprograms of different element types with the same Stream_Access value provides heterogeneous input-output. See section Streams for a general discussion of streams.

    Static Semantics

  2. The library package Streams.Stream_IO has the following declaration: 
  3. with Ada.IO_Exceptions;
package Ada.Streams.Stream_IO is

  4.     type Stream_Access is access all Root_Stream_Type'Class;

  5.     type File_Type is limited private;

  6.     type File_Mode is (In_File, Out_File, Append_File);

  7.     type    Count          is range 0 .. implementation-defined;
    subtype Positive_Count is Count range 1 .. Count'Last;
      -- Index into file, in stream elements.

  8.     procedure Create (File : in out File_Type;
                      Mode : in File_Mode := Out_File;
                      Name : in String    := "";
                      Form : in String    := "");

  9.     procedure Open (File : in out File_Type;
                    Mode : in File_Mode;
                    Name : in String;
                    Form : in String := "");

  10.     procedure Close  (File : in out File_Type);
    procedure Delete (File : in out File_Type);
    procedure Reset  (File : in out File_Type; Mode : in File_Mode);
    procedure Reset  (File : in out File_Type);

  11.     function Mode (File : in File_Type) return File_Mode;
    function Name (File : in File_Type) return String;
    function Form (File : in File_Type) return String;

  12.     function Is_Open     (File : in File_Type) return Boolean;
    function End_Of_File (File : in File_Type) return Boolean;

  13.     function Stream (File : in File_Type) return Stream_Access;
    -- Return stream access for use with T'Input and T'Output

  1.     -- Read array of stream elements from file
    procedure Read (File : in  File_Type;
                    Item : out Stream_Element_Array;
                    Last : out Stream_Element_Offset;
                    From : in  Positive_Count);

  2.     procedure Read (File : in  File_Type;
                    Item : out Stream_Element_Array;
                    Last : out Stream_Element_Offset);

  1.     -- Write array of stream elements into file
    procedure Write (File : in File_Type;
                     Item : in Stream_Element_Array;
                     To   : in Positive_Count);

  2.     procedure Write (File : in File_Type;
                     Item : in Stream_Element_Array);

  1.     -- Operations on position within file

  2.     procedure Set_Index(File : in File_Type;
                        To   : in Positive_Count);

  3.     function Index(File : in File_Type) return Positive_Count;
    function Size (File : in File_Type) return Count;

  4.     procedure Set_Mode(File : in out File_Type;
                       Mode : in     File_Mode);

  5.     procedure Flush(File : in out File_Type);

  6.     -- exceptions
    Status_Error : exception renames IO_Exceptions.Status_Error;
    Mode_Error   : exception renames IO_Exceptions.Mode_Error;
    Name_Error   : exception renames IO_Exceptions.Name_Error;
    Use_Error    : exception renames IO_Exceptions.Use_Error;
    Device_Error : exception renames IO_Exceptions.Device_Error;
    End_Error    : exception renames IO_Exceptions.End_Error;
    Data_Error   : exception renames IO_Exceptions.Data_Error;

  7. private
   ... -- not specified by the language
end Ada.Streams.Stream_IO;
  8. The subprograms Create, Open, Close, Delete, Reset, Mode, Name, Form, Is_Open, and End_of_File have the same effect as the corresponding subprograms in Sequential_IO, see section File Management.
  9. The Stream function returns a Stream_Access result from a File_Type object, thus allowing the stream-oriented attributes Read, Write, Input, and Output to be used on the same file for multiple types.
  10. The procedures Read and Write are equivalent to the corresponding operations in the package Streams. Read propagates Mode_Error if the mode of File is not In_File. Write propagates Mode_Error if the mode of File is not Out_File or Append_File. The Read procedure with a Positive_Count parameter starts reading at the specified index. The Write procedure with a Positive_Count parameter starts writing at the specified index.
  11. The Index function returns the current file index, as a count (in stream elements) from the beginning of the file. The position of the first element in the file is 1.
  12. The Set_Index procedure sets the current index to the specified value.
  13. If positioning is not supported for the given file, then a call of Index or Set_Index propagates Use_Error. Similarly, a call of Read or Write with a Positive_Count parameter propagates Use_Error.
  14. The Size function returns the current size of the file, in stream elements.
  15. The Set_Mode procedure changes the mode of the file. If the new mode is Append_File, the file is positioned to its end; otherwise, the position in the file is unchanged.
  16. The Flush procedure synchronizes the external file with the internal file (by flushing any internal buffers) without closing the file or changing the position. Mode_Error is propagated if the mode of the file is In_File.

The Package Text_IO.Text_Streams

  1. The package Text_IO.Text_Streams provides a function for treating a text file as a stream.

    Static Semantics

  2. The library package Text_IO.Text_Streams has the following declaration: 
  3. with Ada.Streams;
package Ada.Text_IO.Text_Streams is
   type Stream_Access is access all Streams.Root_Stream_Type'Class;

  4.    function Stream (File : in File_Type) return Stream_Access;
end Ada.Text_IO.Text_Streams;
  5. The Stream function has the same effect as the corresponding function in Streams.Stream_IO. NOTES
  6. (34) The ability to obtain a stream for a text file allows Current_Input, Current_Output, and Current_Error to be processed with the functionality of streams, including the mixing of text and binary input-output, and the mixing of binary input-output for different types.
  7. (35) Performing operations on the stream associated with a text file does not affect the column, line, or page counts.

The Package Wide_Text_IO.Text_Streams

  1. The package Wide_Text_IO.Text_Streams provides a function for treating a wide text file as a stream.

    Static Semantics

  2. The library package Wide_Text_IO.Text_Streams has the following declaration: 
  3. with Ada.Streams;
package Ada.Wide_Text_IO.Text_Streams is
   type Stream_Access is access all Streams.Root_Stream_Type'Class;

  4.    function Stream (File : in File_Type) return Stream_Access;
end Ada.Wide_Text_IO.Text_Streams;
  5. The Stream function has the same effect as the corresponding function in Streams.Stream_IO.

Exceptions in Input-Output

  1. The package IO_Exceptions defines the exceptions needed by the predefined input-output packages.

    Static Semantics

  2. The library package IO_Exceptions has the following declaration: 
  3. package Ada.IO_Exceptions is
   pragma Pure(IO_Exceptions);

  4.    Status_Error : exception;
   Mode_Error   : exception;
   Name_Error   : exception;
   Use_Error    : exception;
   Device_Error : exception;
   End_Error    : exception;
   Data_Error   : exception;
   Layout_Error : exception;

  5. end Ada.IO_Exceptions;
  6. If more than one error condition exists, the corresponding exception that appears earliest in the following list is the one that is propagated.
  7. The exception Status_Error is propagated by an attempt to operate upon a file that is not open, and by an attempt to open a file that is already open.
  8. The exception Mode_Error is propagated by an attempt to read from, or test for the end of, a file whose current mode is Out_File or Append_File, and also by an attempt to write to a file whose current mode is In_File. In the case of Text_IO, the exception Mode_Error is also propagated by specifying a file whose current mode is Out_File or Append_File in a call of Set_Input, Skip_Line, End_Of_Line, Skip_Page, or End_Of_Page; and by specifying a file whose current mode is In_File in a call of Set_Output, Set_Line_Length, Set_Page_Length, Line_Length, Page_Length, New_Line, or New_Page.
  9. The exception Name_Error is propagated by a call of Create or Open if the string given for the parameter Name does not allow the identification of an external file. For example, this exception is propagated if the string is improper, or, alternatively, if either none or more than one external file corresponds to the string.
  10. The exception Use_Error is propagated if an operation is attempted that is not possible for reasons that depend on characteristics of the external file. For example, this exception is propagated by the procedure Create, among other circumstances, if the given mode is Out_File but the form specifies an input only device, if the parameter Form specifies invalid access rights, or if an external file with the given name already exists and overwriting is not allowed.
  11. The exception Device_Error is propagated if an input-output operation cannot be completed because of a malfunction of the underlying system.
  12. The exception End_Error is propagated by an attempt to skip (read past) the end of a file.
  13. The exception Data_Error can be propagated by the procedure Read (or by the Read attribute) if the element read cannot be interpreted as a value of the required subtype. This exception is also propagated by a procedure Get (defined in the package Text_IO) if the input character sequence fails to satisfy the required syntax, or if the value input does not belong to the range of the required subtype.
  14. The exception Layout_Error is propagated (in text input-output) by Col, Line, or Page if the value returned exceeds Count'Last. The exception Layout_Error is also propagated on output by an attempt to set column or line numbers in excess of specified maximum line or page lengths, respectively (excluding the unbounded cases). It is also propagated by an attempt to Put too many characters to a string.

    Documentation Requirements

  15. The implementation shall document the conditions under which Name_Error, Use_Error and Device_Error are propagated.

    Implementation Permissions

  16. If the associated check is too complex, an implementation need not propagate Data_Error as part of a procedure Read (or the Read attribute) if the value read cannot be interpreted as a value of the required subtype.

    Erroneous Execution

  17. If the element read by the procedure Read (or by the Read attribute) cannot be interpreted as a value of the required subtype, but this is not detected and Data_Error is not propagated, then the resulting value can be abnormal, and subsequent references to the value can lead to erroneous execution, as explained in section Data Validity.

File Sharing

Dynamic Semantics

  1. It is not specified by the language whether the same external file can be associated with more than one file object. If such sharing is supported by the implementation, the following effects are defined:
    1. Operations on one text file object do not affect the column, line, and page numbers of any other file object.
    2. Standard_Input and Standard_Output are associated with distinct external files, so operations on one of these files cannot affect operations on the other file. In particular, reading from Standard_Input does not affect the current page, line, and column numbers for Standard_Output, nor does writing to Standard_Output affect the current page, line, and column numbers for Standard_Input.
    3. For direct and stream files, the current index is a property of each file object; an operation on one file object does not affect the current index of any other file object.
    4. For direct and stream files, the current size of the file is a property of the external file.
    All other effects are identical.

The Package Command_Line

  1. The package Command_Line allows a program to obtain the values of its arguments and to set the exit status code to be returned on normal termination.

    Static Semantics

  2. The library package Ada.Command_Line has the following declaration: 
  3. package Ada.Command_Line is
  pragma Preelaborate(Command_Line);

  4.   function Argument_Count return Natural;

  5.   function Argument (Number : in Positive) return String;

  6.   function Command_Name return String;

  7.   type Exit_Status is implementation-defined integer type;

  8.   Success : constant Exit_Status;
  Failure : constant Exit_Status;

  9.   procedure Set_Exit_Status (Code : in Exit_Status);

  10. private
  ... -- not specified by the language
end Ada.Command_Line;

  11. function Argument_Count return Natural;
    1. If the external execution environment supports passing arguments to a program, then Argument_Count returns the number of arguments passed to the program invoking the function. Otherwise it returns 0. The meaning of "number of arguments" is implementation defined. 
  1. function Argument (Number : in Positive) return String;
    1. If the external execution environment supports passing arguments to a program, then Argument returns an implementation-defined value corresponding to the argument at relative position Number. If Number is outside the range 1..Argument_Count, then Constraint_Error is propagated. 
  1. function Command_Name return String;
    1. If the external execution environment supports passing arguments to a program, then Command_Name returns an implementation-defined value corresponding to the name of the command invoking the program; otherwise Command_Name returns the null string.
    2. The type Exit_Status represents the range of exit status values supported by the external execution environment. The constants Success and Failure correspond to success and failure, respectively. 
  1. procedure Set_Exit_Status (Code : in Exit_Status);
    1. If the external execution environment supports returning an exit status from a program, then Set_Exit_Status sets Code as the status. Normal termination of a program returns as the exit status the value most recently set by Set_Exit_Status, or, if no such value has been set, then the value Success. If a program terminates abnormally, the status set by Set_Exit_Status is ignored, and an implementation-defined exit status value is set.
    2. If the external execution environment does not support returning an exit value from a program, then Set_Exit_Status does nothing.

Implementation Permissions

  1. An alternative declaration is allowed for package Command_Line if different functionality is appropriate for the external execution environment. NOTES
  2. (36) Argument_Count, Argument, and Command_Name correspond to the C language's argc, argv[n] (for n>0) and argv[0], respectively.

Interface to Other Languages (normative)

  1. This Annex describes features for writing mixed-language programs. General interface support is presented first; then specific support for C, COBOL, and Fortran is defined, in terms of language interface packages for each of these languages.

Interfacing Pragmas

  1. A pragma Import is used to import an entity defined in a foreign language into an Ada program, thus allowing a foreign-language subprogram to be called from Ada, or a foreign-language variable to be accessed from Ada. In contrast, a pragma Export is used to export an Ada entity to a foreign language, thus allowing an Ada subprogram to be called from a foreign language, or an Ada object to be accessed from a foreign language. The pragmas Import and Export are intended primarily for objects and subprograms, although implementations are allowed to support other entities.
  2. A pragma Convention is used to specify that an Ada entity should use the conventions of another language. It is intended primarily for types and "callback" subprograms. For example, "pragma Convention(Fortran, Matrix);" implies that Matrix should be represented according to the conventions of the supported Fortran implementation, namely column-major order.
  3. A pragma Linker_Options is used to specify the system linker parameters needed when a given compilation unit is included in a partition.

    Syntax

  4. An interfacing pragma is a representation pragma that is one of the pragmas Import, Export, or Convention. Their forms, together with that of the related pragma Linker_Options, are as follows: 
  5. pragma Import
  ([Convention =>] convention_identifier,
   [Entity =>] local_name [,
   [External_Name =>] string_expression] [,
   [Link_Name =>] string_expression]);

  6. pragma Export
  ([Convention =>] convention_identifier,
   [Entity =>] local_name [,
   [External_Name =>] string_expression] [,
   [Link_Name =>] string_expression]);

  7. pragma Convention
  ([Convention =>] convention_identifier,
  [Entity =>] local_name);

  8. pragma Linker_Options(string_expression);
    1. A pragma Linker_Options is allowed only at the place of a declarative_item.

Name Resolution Rules

  1. The expected type for a string_expression in an interfacing pragma or in pragma Linker_Options is String.

    Legality Rules

  2. The convention_identifier of an interfacing pragma shall be the name of a convention. The convention names are implementation defined, except for certain language-defined ones, such as Ada and Intrinsic, as explained in section Conformance Rules. Additional convention names generally represent the calling conventions of foreign languages, language implementations, or specific run-time models. The convention of a callable entity is its calling convention.
  3. If L is a convention_identifier for a language, then a type T is said to be compatible with convention L, (alternatively, is said to be an L-compatible type) if any of the following conditions are met:
    1. T is declared in a language interface package corresponding to L and is defined to be L-compatible, see section Interfacing with C, section The Package Interfaces.C.Strings, section The Generic Package Interfaces.C.Pointers, section Interfacing with COBOL and section Interfacing with Fortran
    2. Convention L has been specified for T in a pragma Convention, and T is eligible for convention L; that is:
      1. T is an array type with either an unconstrained or statically-constrained first subtype, and its component type is L-compatible,
      2. T is a record type that has no discriminants and that only has components with statically-constrained subtypes, and each component type is L-compatible,
      3. T is an access-to-object type, and its designated type is L-compatible,
      4. T is an access-to-subprogram type, and its designated profile's parameter and result types are all L-compatible.
    1. T is derived from an L-compatible type,
    2. The implementation permits T as an L-compatible type.
  1. If pragma Convention applies to a type, then the type shall either be compatible with or eligible for the convention specified in the pragma.
  2. A pragma Import shall be the completion of a declaration. Notwithstanding any rule to the contrary, a pragma Import may serve as the completion of any kind of (explicit) declaration if supported by an implementation for that kind of declaration. If a completion is a pragma Import, then it shall appear in the same declarative_part, package_specification, task_definition or protected_definition as the declaration. For a library unit, it shall appear in the same compilation, before any subsequent compilation_units other than pragmas. If the local_name denotes more than one entity, then the pragma Import is the completion of all of them.
  3. An entity specified as the Entity argument to a pragma Import (or pragma Export) is said to be imported (respectively, exported).
  4. The declaration of an imported object shall not include an explicit initialization expression. Default initializations are not performed.
  5. The type of an imported or exported object shall be compatible with the convention specified in the corresponding pragma.
  6. For an imported or exported subprogram, the result and parameter types shall each be compatible with the convention specified in the corresponding pragma.
  7. The external name and link name string_expressions of a pragma Import or Export, and the string_expression of a pragma Linker_Options, shall be static.

    Static Semantics

  8. Import, Export, and Convention pragmas are representation pragmas that specify the convention aspect of representation. In addition, Import and Export pragmas specify the imported and exported aspects of representation, respectively.
  9. An interfacing pragma is a program unit pragma when applied to a program unit, see section Pragmas and Program Units.
  10. An interfacing pragma defines the convention of the entity denoted by the local_name. The convention represents the calling convention or representation convention of the entity. For an access-to-subprogram type, it represents the calling convention of designated subprograms. In addition:
    1. A pragma Import specifies that the entity is defined externally (that is, outside the Ada program).
    2. A pragma Export specifies that the entity is used externally.
    3. A pragma Import or Export optionally specifies an entity's external name, link name, or both.
  1. An external name is a string value for the name used by a foreign language program either for an entity that an Ada program imports, or for referring to an entity that an Ada program exports.
  2. A link name is a string value for the name of an exported or imported entity, based on the conventions of the foreign language's compiler in interfacing with the system's linker tool.
  3. The meaning of link names is implementation defined. If neither a link name nor the Address attribute of an imported or exported entity is specified, then a link name is chosen in an implementation-defined manner, based on the external name if one is specified.
  4. Pragma Linker_Options has the effect of passing its string argument as a parameter to the system linker (if one exists), if the immediately enclosing compilation unit is included in the partition being linked. The interpretation of the string argument, and the way in which the string arguments from multiple Linker_Options pragmas are combined, is implementation defined.

    Dynamic Semantics

  5. Notwithstanding what this International Standard says elsewhere, the elaboration of a declaration denoted by the local_name of a pragma Import does not create the entity. Such an elaboration has no other effect than to allow the defining name to denote the external entity.

    Implementation Advice

  6. If an implementation supports pragma Export to a given language, then it should also allow the main subprogram to be written in that language. It should support some mechanism for invoking the elaboration of the Ada library units included in the system, and for invoking the finalization of the environment task. On typical systems, the recommended mechanism is to provide two subprograms whose link names are "adainit" and "adafinal". Adainit should contain the elaboration code for library units. Adafinal should contain the finalization code. These subprograms should have no effect the second and subsequent time they are called.
  7. Automatic elaboration of preelaborated packages should be provided when pragma Export is supported.
  8. For each supported convention L other than Intrinsic, an implementation should support Import and Export pragmas for objects of L-compatible types and for subprograms, and pragma Convention for L-eligible types and for subprograms, presuming the other language has corresponding features. Pragma Convention need not be supported for scalar types. NOTES
  9. (1) Implementations may place restrictions on interfacing pragmas; for example, requiring each exported entity to be declared at the library level.
  10. (2) A pragma Import specifies the conventions for accessing external entities. It is possible that the actual entity is written in assembly language, but reflects the conventions of a particular language. For example, pragma Import(Ada, ...) can be used to interface to an assembly language routine that obeys the Ada compiler's calling conventions.
  11. (3) To obtain "call-back" to an Ada subprogram from a foreign language environment, pragma Convention should be specified both for the access-to-subprogram type and the specific subprogram(s) to which 'Access is applied.
  12. (4) It is illegal to specify more than one of Import, Export, or Convention for a given entity.
  13. (5) The local_name in an interfacing pragma can denote more than one entity in the case of overloading. Such a pragma applies to all of the denoted entities.
  14. (6) Also section Machine Code Insertions.
  15. (7) If both External_Name and Link_Name are specified for an Import or Export pragma, then the External_Name is ignored.
  16. (8) An interfacing pragma might result in an effect that violates Ada semantics.

    Examples

  17. Example of interfacing pragmas: 
  18. package Fortran_Library is
  function Sqrt (X : Float) return Float;
  function Exp  (X : Float) return Float;
private
  pragma Import(Fortran, Sqrt);
  pragma Import(Fortran, Exp);
end Fortran_Library;

The Package Interfaces

  1. Package Interfaces is the parent of several library packages that declare types and other entities useful for interfacing to foreign languages. It also contains some implementation-defined types that are useful across more than one language (in particular for interfacing to assembly language).

    Static Semantics

  2. The library package Interfaces has the following skeletal declaration: 
  3. package Interfaces is
   pragma Pure(Interfaces);

  4.    type Integer_n is range -2**(n-1) .. 2**(n-1) - 1;
   -- 2's complement

  5.    type Unsigned_n is mod 2**n;

  6.    function Shift_Left  (Value  : Unsigned_n;
                         Amount : Natural) return Unsigned_n;
   function Shift_Right (Value  : Unsigned_n;
                         Amount : Natural) return Unsigned_n;
   function Shift_Right_Arithmetic (Value  : Unsigned_n;
                                    Amount : Natural)
     return Unsigned_n;
   function Rotate_Left  (Value  : Unsigned_n;
                          Amount : Natural) return Unsigned_n;
   function Rotate_Right (Value  : Unsigned_n;
                          Amount : Natural) return Unsigned_n;
   ...
end Interfaces;

    Implementation Requirements

  7. An implementation shall provide the following declarations in the visible part of package Interfaces:
    1. Signed and modular integer types of n bits, if supported by the target architecture, for each n that is at least the size of a storage element and that is a factor of the word size. The names of these types are of the form Integer_n for the signed types, and Unsigned_n for the modular types;
    2. For each such modular type in Interfaces, shifting and rotating subprograms as specified in the declaration of Interfaces above. These subprograms are Intrinsic. They operate on a bit-by-bit basis, using the binary representation of the value of the operands to yield a binary representation for the result. The Amount parameter gives the number of bits by which to shift or rotate. For shifting, zero bits are shifted in, except in the case of Shift_Right_Arithmetic, where one bits are shifted in if Value is at least half the modulus.
    3. Floating point types corresponding to each floating point format fully supported by the hardware.

Implementation Permissions

  1. An implementation may provide implementation-defined library units that are children of Interfaces, and may add declarations to the visible part of Interfaces in addition to the ones defined above.
  2. Implementation Advice
  3. For each implementation-defined convention identifier, there should be a child package of package Interfaces with the corresponding name. This package should contain any declarations that would be useful for interfacing to the language (implementation) represented by the convention. Any declarations useful for interfacing to any language on the given hardware architecture should be provided directly in Interfaces.
  4. An implementation supporting an interface to C, COBOL, or Fortran should provide the corresponding package or packages described in the following clauses.

Interfacing with C

  1. The facilities relevant to interfacing with the C language are the package Interfaces.C and its children; and support for the Import, Export, and Convention pragmas with convention_identifier C.
  2. The package Interfaces.C contains the basic types, constants and subprograms that allow an Ada program to pass scalars and strings to C functions.

    Static Semantics

  3. The library package Interfaces.C has the following declaration: 
  4. package Interfaces.C is
   pragma Pure(C);

  5.    -- Declarations based on C's <limits.h>

  6.    CHAR_BIT  : constant := implementation-defined; -- typically 8
   SCHAR_MIN : constant := implementation-defined; -- typically -128
   SCHAR_MAX : constant := implementation-defined; -- typically 127
   UCHAR_MAX : constant := implementation-defined; -- typically 255

  7.    -- Signed and Unsigned Integers
   type int   is range implementation-defined;
   type short is range implementation-defined;
   type long  is range implementation-defined;

  8.    type signed_char is range SCHAR_MIN .. SCHAR_MAX;
   for signed_char'Size use CHAR_BIT;

  9.    type unsigned       is mod implementation-defined;
   type unsigned_short is mod implementation-defined;
   type unsigned_long  is mod implementation-defined;

  10.    type unsigned_char is mod (UCHAR_MAX+1);
   for unsigned_char'Size use CHAR_BIT;

  11.    subtype plain_char is implementation-defined;

  12.    type ptrdiff_t is range implementation-defined;

  13.    type size_t is mod implementation-defined;

  14.    -- Floating Point

  15.    type C_float     is digits implementation-defined;

  16.    type double      is digits implementation-defined;

  17.    type long_double is digits implementation-defined;

  18.    -- Characters and Strings

  19.    type char is <implementation-defined character type>;

  20.    nul : constant char := char'First;

  21.    function To_C   (Item : in Character) return char;

  22.    function To_Ada (Item : in char) return Character;

  23.    type char_array is array (size_t range <>) of aliased char;
   pragma Pack(char_array);
   for char_array'Component_Size use CHAR_BIT;

  24.    function Is_Nul_Terminated (Item : in char_array) return Boolean;

  25.    function To_C   (Item       : in String;
                    Append_Nul : in Boolean := True)
      return char_array;

  26.    function To_Ada (Item     : in char_array;
                    Trim_Nul : in Boolean := True)
      return String;

  27.    procedure To_C (Item       : in String;
                   Target     : out char_array;
                   Count      : out size_t;
                   Append_Nul : in Boolean := True);

  28.    procedure To_Ada (Item     : in char_array;
                     Target   : out String;
                     Count    : out Natural;
                     Trim_Nul : in Boolean := True);

  29.    -- Wide Character and Wide String

  30.    type wchar_t is implementation-defined;

  31.    wide_nul : constant wchar_t := wchar_t'First;

  32.    function To_C   (Item : in Wide_Character) return wchar_t;
   function To_Ada (Item : in wchar_t       ) return Wide_Character;

  33.    type wchar_array is array (size_t range <>) of aliased wchar_t;

  34.    pragma Pack(wchar_array);

  35.    function Is_Nul_Terminated (Item : in wchar_array)
     return Boolean;

  36.    function To_C   (Item       : in Wide_String;
                    Append_Nul : in Boolean := True)
      return wchar_array;

  37.    function To_Ada (Item     : in wchar_array;
                    Trim_Nul : in Boolean := True)
      return Wide_String;

  38.    procedure To_C (Item       : in  Wide_String;
                   Target     : out wchar_array;
                   Count      : out size_t;
                   Append_Nul : in  Boolean := True);

  39.    procedure To_Ada (Item     : in  wchar_array;
                     Target   : out Wide_String;
                     Count    : out Natural;
                     Trim_Nul : in  Boolean := True);

  40.    Terminator_Error : exception;

  41. end Interfaces.C;
  42. Each of the types declared in Interfaces.C is C-compatible.
  43. The types int, short, long, unsigned, ptrdiff_t, size_t, double, char, and wchar_t correspond respectively to the C types having the same names. The types signed_char, unsigned_short, unsigned_long, unsigned_char, C_float, and long_double correspond respectively to the C types signed char, unsigned short, unsigned long, unsigned char, float, and long double.
  44. The type of the subtype plain_char is either signed_char or unsigned_char, depending on the C implementation. 
  45. function To_C   (Item : in Character) return char;
function To_Ada (Item : in char     ) return Character;
    1. The functions To_C and To_Ada map between the Ada type Character and the C type char. 
  1. function Is_Nul_Terminated (Item : in char_array) return Boolean;
    1. The result of Is_Nul_Terminated is True if Item contains nul, and is False otherwise. 
  1. function To_C (Item       : in String;
               Append_Nul : in Boolean := True)
  return char_array;

function To_Ada (Item     : in char_array;
                 Trim_Nul : in Boolean := True)
  return String;
    1. The result of To_C is a char_array value of length Item'Length (if Append_Nul is False) or Item'Length+1 (if Append_Nul is True). The lower bound is 0. For each component Item(I), the corresponding component in the result is To_C applied to Item(I). The value nul is appended if Append_Nul is True.
    2. The result of To_Ada is a String whose length is Item'Length (if Trim_Nul is False) or the length of the slice of Item preceding the first nul (if Trim_Nul is True). The lower bound of the result is 1. If Trim_Nul is False, then for each component Item(I) the corresponding component in the result is To_Ada applied to Item(I). If Trim_Nul is True, then for each component Item(I) before the first nul the corresponding component in the result is To_Ada applied to Item(I). The function propagates Terminator_Error if Trim_Nul is True and Item does not contain nul. 
  1. procedure To_C (Item       : in String;
                Target     : out char_array;
                Count      : out size_t;
                Append_Nul : in Boolean := True);

procedure To_Ada (Item     : in char_array;
                  Target   : out String;
                  Count    : out Natural;
                  Trim_Nul : in Boolean := True);
    1. For procedure To_C, each element of Item is converted (via the To_C function) to a char, which is assigned to the corresponding element of Target. If Append_Nul is True, nul is then assigned to the next element of Target. In either case, Count is set to the number of Target elements assigned. If Target is not long enough, Constraint_Error is propagated.
    2. For procedure To_Ada, each element of Item (if Trim_Nul is False) or each element of Item preceding the first nul (if Trim_Nul is True) is converted (via the To_Ada function) to a Character, which is assigned to the corresponding element of Target. Count is set to the number of Target elements assigned. If Target is not long enough, Constraint_Error is propagated. If Trim_Nul is True and Item does not contain nul, then Terminator_Error is propagated. 
  1. function Is_Nul_Terminated (Item : in wchar_array) return Boolean;
    1. The result of Is_Nul_Terminated is True if Item contains wide_nul, and is False otherwise. 
  1. function To_C   (Item : in Wide_Character) return wchar_t;
function To_Ada (Item : in wchar_t       ) return Wide_Character;
    1. To_C and To_Ada provide the mappings between the Ada and C wide character types. 
  1. function To_C   (Item       : in Wide_String;
                 Append_Nul : in Boolean := True)
   return wchar_array;

function To_Ada (Item     : in wchar_array;
                 Trim_Nul : in Boolean := True)
   return Wide_String;

procedure To_C (Item       : in Wide_String;
                Target     : out wchar_array;
                Count      : out size_t;
                Append_Nul : in Boolean := True);

procedure To_Ada (Item     : in wchar_array;
                  Target   : out Wide_String;
                  Count    : out Natural;
                  Trim_Nul : in Boolean := True);
    1. The To_C and To_Ada subprograms that convert between Wide_String and wchar_array have analogous effects to the To_C and To_Ada subprograms that convert between String and char_array, except that wide_nul is used instead of nul.

Implementation Requirements

  1. An implementation shall support pragma Convention with a C convention_identifier for a C-eligible type, see section Interfacing Pragmas.

    Implementation Permissions

  2. An implementation may provide additional declarations in the C interface packages.

    Implementation Advice

  3. An implementation should support the following interface correspondences between Ada and C.
    1. An Ada procedure corresponds to a void-returning C function.
    2. An Ada function corresponds to a non-void C function.
    3. An Ada in scalar parameter is passed as a scalar argument to a C function.
    4. An Ada in parameter of an access-to-object type with designated type T is passed as a t* argument to a C function, where t is the C type corresponding to the Ada type T.
    5. An Ada access T parameter, or an Ada out or in out parameter of an elementary type T, is passed as a t* argument to a C function, where t is the C type corresponding to the Ada type T. In the case of an elementary out or in out parameter, a pointer to a temporary copy is used to preserve by-copy semantics.
    6. An Ada parameter of a record type T, of any mode, is passed as a t* argument to a C function, where t is the C struct corresponding to the Ada type T.
    7. An Ada parameter of an array type with component type T, of any mode, is passed as a t* argument to a C function, where t is the C type corresponding to the Ada type T.
    8. An Ada parameter of an access-to-subprogram type is passed as a pointer to a C function whose prototype corresponds to the designated subprogram's specification.
    NOTES
  1. (9) Values of type char_array are not implicitly terminated with nul. If a char_array is to be passed as a parameter to an imported C function requiring nul termination, it is the programmer's responsibility to obtain this effect.
  2. (10) To obtain the effect of C's sizeof(item_type), where Item_Type is the corresponding Ada type, evaluate the expression: size_t(Item_Type'Size/CHAR_BIT).
  3. (11) There is no explicit support for C's union types. Unchecked conversions can be used to obtain the effect of C unions.
  4. (12) A C function that takes a variable number of arguments can correspond to several Ada subprograms, taking various specific numbers and types of parameters.

    Examples

  5. Example of using the Interfaces.C package: 
  6. --Calling the C Library Function strcpy
with Interfaces.C;
procedure Test is
   package C renames Interfaces.C;
   use type C.char_array;
   -- Call <string.h> strcpy:
   -- C definition of strcpy:
   --    char *strcpy(char *s1, const char *s2);
   -- This function copies the string pointed to by s2
   -- (including the terminating null character) into the array
   -- pointed to by s1. If copying takes place between objects that
   -- overlap, the behavior is undefined. The strcpy function
   --  returns the value of s1.

  7.    -- Note: since the C function's return value is of no interest,
   --  the Ada interface is a procedure
   procedure Strcpy (Target : out C.char_array;
                     Source : in  C.char_array);

  8. pragma Import(C, Strcpy, "strcpy");

  9.    Chars1 :  C.char_array(1..20);
   Chars2 :  C.char_array(1..20);

  10. begin
   Chars2(1..6) := "qwert" & C.nul;

  11.    Strcpy(Chars1, Chars2);

  12. -- Now Chars1(1..6) = "qwert" & C.Nul

  13. end Test;

The Package Interfaces.C.Strings

  1. The package Interfaces.C.Strings declares types and subprograms allowing an Ada program to allocate, reference, update, and free C-style strings. In particular, the private type chars_ptr corresponds to a common use of "char *" in C programs, and an object of this type can be passed to a subprogram to which pragma Import(C,...) has been applied, and for which "char *" is the type of the argument of the C function.

    Static Semantics

  2. The library package Interfaces.C.Strings has the following declaration: 
  3. package Interfaces.C.Strings is
   pragma Preelaborate(Strings);

  4.    type char_array_access is access all char_array;

  5.    type chars_ptr is private;

  6.    type chars_ptr_array is array (size_t range <>) of chars_ptr;

  7.    Null_Ptr : constant chars_ptr;

  8.    function To_Chars_Ptr (Item      : in char_array_access;
                          Nul_Check : in Boolean := False)
      return chars_ptr;

  9.    function New_Char_Array (Chars : in char_array) return chars_ptr;

  10.    function New_String (Str : in String) return chars_ptr;

  11.    procedure Free (Item : in out chars_ptr);

  12.    Dereference_Error : exception;

  13.    function Value (Item : in chars_ptr) return char_array;

  14.    function Value (Item : in chars_ptr; Length : in size_t)
      return char_array;

  15.    function Value (Item : in chars_ptr) return String;

  16.    function Value (Item : in chars_ptr; Length : in size_t)
      return String;

  17.    function Strlen (Item : in chars_ptr) return size_t;

  18.    procedure Update (Item   : in chars_ptr;
                     Offset : in size_t;
                     Chars  : in char_array;
                     Check  : in Boolean := True);

  19.    procedure Update (Item   : in chars_ptr;
                     Offset : in size_t;
                     Str    : in String;
                     Check  : in Boolean := True);

  20.    Update_Error : exception;

  21. private
   ... -- not specified by the language
end Interfaces.C.Strings;
  22. The type chars_ptr is C-compatible and corresponds to the use of C's "char *" for a pointer to the first char in a char array terminated by nul. When an object of type chars_ptr is declared, its value is by default set to Null_Ptr, unless the object is imported, see section Interfacing Pragmas. 
  23. function To_Chars_Ptr (Item      : in char_array_access;
                       Nul_Check : in Boolean := False)
   return chars_ptr;
    1. If Item is null, then To_Chars_Ptr returns Null_Ptr. Otherwise, if Nul_Check is True and Item.all does not contain nul, then the function propagates Terminator_Error; if Nul_Check is True and Item.all does contain nul, To_Chars_Ptr performs a pointer conversion with no allocation of memory. 
  1. function New_Char_Array (Chars   : in char_array) return chars_ptr;
    1. This function returns a pointer to an allocated object initialized to Chars(Chars'First .. Index) & nul, where
    2. Index = Chars'Last if Chars does not contain nul, or
    3. Index is the smallest size_t value I such that Chars(I+1) = nul.
    Storage_Error is propagated if the allocation fails. 
  1. function New_String (Str : in String) return chars_ptr;
    1. This function is equivalent to New_Char_Array(To_C(Str)). 
  1. procedure Free (Item : in out chars_ptr);
    1. If Item is Null_Ptr, then Free has no effect. Otherwise, Free releases the storage occupied by Value(Item), and resets Item to Null_Ptr. 
  1. function Value (Item : in chars_ptr) return char_array;
    1. If Item = Null_Ptr then Value propagates Dereference_Error. Otherwise Value returns the prefix of the array of chars pointed to by Item, up to and including the first nul. The lower bound of the result is 0. If Item does not point to a nul-terminated string, then execution of Value is erroneous. 
  1. function Value (Item : in chars_ptr; Length : in size_t)
   return char_array;
    1. If Item = Null_Ptr then Value(Item) propagates Dereference_Error. Otherwise Value returns the shorter of two arrays: the first Length chars pointed to by Item, and Value(Item). The lower bound of the result is 0. 
  1. function Value (Item : in chars_ptr) return String;
    1. Equivalent to To_Ada(Value(Item), Trim_Nul=>True). 
  1. function Value (Item : in chars_ptr; Length : in size_t)
   return String;
    1. Equivalent to To_Ada(Value(Item, Length), Trim_Nul=>True). 
  1. function Strlen (Item : in chars_ptr) return size_t;
    1. Returns Val'Length-1 where Val = Value(Item); propagates Dereference_Error if Item = Null_Ptr. 
  1. procedure Update (Item   : in chars_ptr;
                  Offset : in size_t;
                  Chars  : in char_array;
                  Check  : Boolean := True);
    1. This procedure updates the value pointed to by Item, starting at position Offset, using Chars as the data to be copied into the array. Overwriting the nul terminator, and skipping with the Offset past the nul terminator, are both prevented if Check is True, as follows:
      1. Let N = Strlen(Item). If Check is True, then:
        1. If Offset+Chars'Length>N, propagate Update_Error.
        2. Otherwise, overwrite the data in the array pointed to by Item, starting at the char at position Offset, with the data in Chars.
      1. If Check is False, then processing is as above, but with no check that Offset+Chars'Length>N. 
  1. procedure Update (Item   : in chars_ptr;
                  Offset : in size_t;
                  Str    : in String;
                  Check  : in Boolean := True);
    1. Equivalent to Update(Item, Offset, To_C(Str), Check).

Erroneous Execution

  1. Execution of any of the following is erroneous if the Item parameter is not null_ptr and Item does not point to a nul-terminated array of chars.
    1. a Value function not taking a Length parameter,
    2. the Free procedure,
    3. the Strlen function.
  1. Execution of Free(X) is also erroneous if the chars_ptr X was not returned by New_Char_Array or New_String.
  2. Reading or updating a freed char_array is erroneous.
  3. Execution of Update is erroneous if Check is False and a call with Check equal to True would have propagated Update_Error. NOTES
  4. (13) New_Char_Array and New_String might be implemented either through the allocation function from the C environment ("malloc") or through Ada dynamic memory allocation ("new"). The key points are
    1. the returned value (a chars_ptr) is represented as a C "char *" so that it may be passed to C functions;
    2. the allocated object should be freed by the programmer via a call of Free, not by a called C function.

The Generic Package Interfaces.C.Pointers

  1. The generic package Interfaces.C.Pointers allows the Ada programmer to perform C-style operations on pointers. It includes an access type Pointer, Value functions that dereference a Pointer and deliver the designated array, several pointer arithmetic operations, and "copy" procedures that copy the contents of a source pointer into the array designated by a destination pointer. As in C, it treats an object Ptr of type Pointer as a pointer to the first element of an array, so that for example, adding 1 to Ptr yields a pointer to the second element of the array.
  2. The generic allows two styles of usage: one in which the array is terminated by a special terminator element; and another in which the programmer needs to keep track of the length.

    Static Semantics

  3. The generic library package Interfaces.C.Pointers has the following declaration: 
  4. generic
   type Index is (<>);
   type Element is private;
   type Element_Array is array (Index range <>) of aliased Element;
   Default_Terminator : Element;
package Interfaces.C.Pointers is
   pragma Preelaborate(Pointers);

  5.    type Pointer is access all Element;

  6.    function Value(Ref        : in Pointer;
                  Terminator : in Element := Default_Terminator)
      return Element_Array;

  7.    function Value(Ref    : in Pointer;
                  Length : in ptrdiff_t)
      return Element_Array;

  8.    Pointer_Error : exception;

  9.    -- C-style Pointer arithmetic

  10.    function "+" (Left  : in Pointer;
                 Right : in ptrdiff_t) return Pointer;
   function "+" (Left  : in ptrdiff_t;
                 Right : in Pointer)   return Pointer;
   function "-" (Left  : in Pointer;
                 Right : in ptrdiff_t) return Pointer;
   function "-" (Left  : in Pointer;
                 Right : in Pointer)   return ptrdiff_t;

  11.    procedure Increment (Ref : in out Pointer);
   procedure Decrement (Ref : in out Pointer);

  12.    pragma Convention (Intrinsic, "+");
   pragma Convention (Intrinsic, "-");
   pragma Convention (Intrinsic, Increment);
   pragma Convention (Intrinsic, Decrement);

  13.    function Virtual_Length
     (Ref        : in Pointer;
      Terminator : in Element := Default_Terminator)
     return ptrdiff_t;

  14.    procedure Copy_Terminated_Array
     (Source     : in Pointer;
      Target     : in Pointer;
      Limit      : in ptrdiff_t := ptrdiff_t'Last;
      Terminator : in Element :=  Default_Terminator);

  15.    procedure Copy_Array (Source  : in Pointer;
                         Target  : in Pointer;
                         Length  : in ptrdiff_t);

  16. end Interfaces.C.Pointers;
  17. The type Pointer is C-compatible and corresponds to one use of C's "Element *". An object of type Pointer is interpreted as a pointer to the initial Element in an Element_Array. Two styles are supported:
    1. Explicit termination of an array value with Default_Terminator (a special terminator value);
    2. Programmer-managed length, with Default_Terminator treated simply as a data element. 
  1. function Value(Ref        : in Pointer;
               Terminator : in Element := Default_Terminator)
  return Element_Array;
    1. This function returns an Element_Array whose value is the array pointed to by Ref, up to and including the first Terminator; the lower bound of the array is Index'First. Interfaces.C.Strings.Dereference_Error is propagated if Ref is null. 
  1. function Value(Ref    : in Pointer;
               Length : in ptrdiff_t)
   return Element_Array;
    1. This function returns an Element_Array comprising the first Length elements pointed to by Ref. The exception Interfaces.C.Strings.Dereference_Error is propagated if Ref is null.
  1. The "+" and "-" functions perform arithmetic on Pointer values, based on the Size of the array elements. In each of these functions, Pointer_Error is propagated if a Pointer parameter is null. 
  2. procedure Increment (Ref : in out Pointer);
    1. Equivalent to Ref := Ref+1. 
  1. procedure Decrement (Ref : in out Pointer);
    1. Equivalent to Ref := Ref-1. 
  1. function Virtual_Length
  (Ref        : in Pointer;
   Terminator : in Element := Default_Terminator)
   return ptrdiff_t;
    1. Returns the number of Elements, up to the one just before the first Terminator, in Value(Ref, Terminator). 
  1. procedure Copy_Terminated_Array
  (Source     : in Pointer;
   Target     : in Pointer;
   Limit      : in ptrdiff_t := ptrdiff_t'Last;
   Terminator : in Element := Default_Terminator);
    1. This procedure copies Value(Source, Terminator) into the array pointed to by Target; it stops either after Terminator has been copied, or the number of elements copied is Limit, whichever occurs first. Dereference_Error is propagated if either Source or Target is null. 
  1. procedure Copy_Array (Source  : in Pointer;
                      Target  : in Pointer;
                      Length  : in ptrdiff_t);
    1. This procedure copies the first Length elements from the array pointed to by Source, into the array pointed to by Target. Dereference_Error is propagated if either Source or Target is null.

Erroneous Execution

  1. It is erroneous to dereference a Pointer that does not designate an aliased Element.
  2. Execution of Value(Ref, Terminator) is erroneous if Ref does not designate an aliased Element in an Element_Array terminated by Terminator.
  3. Execution of Value(Ref, Length) is erroneous if Ref does not designate an aliased Element in an Element_Array containing at least Length Elements between the designated Element and the end of the array, inclusive.
  4. Execution of Virtual_Length(Ref, Terminator) is erroneous if Ref does not designate an aliased Element in an Element_Array terminated by Terminator.
  5. Execution of Copy_Terminated_Array(Source, Target, Limit, Terminator) is erroneous in either of the following situations:
    1. Execution of both Value(Source,Terminator) and Value(Source,Limit) are erroneous, or
    2. Copying writes past the end of the array containing the Element designated by Target.
  1. Execution of Copy_Array(Source, Target, Length) is erroneous if either Value(Source, Length) is erroneous, or copying writes past the end of the array containing the Element designated by Target. NOTES
  2. (14) To compose a Pointer from an Element_Array, use 'Access on the first element. For example (assuming appropriate instantiations): 
  3. Some_Array   : Element_Array(0..5) ;
Some_Pointer : Pointer := Some_Array(0)'Access;

    Examples

  4. Example of Interfaces.C.Pointers: 
  5. with Interfaces.C.Pointers;
with Interfaces.C.Strings;
procedure Test_Pointers is
   package C renames Interfaces.C;
   package Char_Ptrs is
      new C.Pointers (Index              => C.size_t,
                      Element            => C.char,
                      Element_Array      => C.char_array,
                      Default_Terminator => C.nul);

  6.    use type Char_Ptrs.Pointer;
   subtype Char_Star is Char_Ptrs.Pointer;

  7.    procedure Strcpy (Target_Ptr, Source_Ptr : Char_Star) is
      Target_Temp_Ptr : Char_Star := Target_Ptr;
      Source_Temp_Ptr : Char_Star := Source_Ptr;
      Element : C.char;
   begin
      if Target_Temp_Ptr = null or Source_Temp_Ptr = null then
         raise C.Strings.Dereference_Error;
      end if;

  8.       loop
         Element             := Source_Temp_Ptr.all;
         Target_Temp_Ptr.all := Element;
         exit when Element = C.nul;
         Char_Ptrs.Increment(Target_Temp_Ptr);
         Char_Ptrs.Increment(Source_Temp_Ptr);
      end loop;
   end Strcpy;
begin
   ...
end Test_Pointers;

Interfacing with COBOL

  1. The facilities relevant to interfacing with the COBOL language are the package Interfaces.COBOL and support for the Import, Export and Convention pragmas with convention_identifier COBOL.
  2. The COBOL interface package supplies several sets of facilities:
    1. A set of types corresponding to the native COBOL types of the supported COBOL implementation (so-called "internal COBOL representations"), allowing Ada data to be passed as parameters to COBOL programs
    2. A set of types and constants reflecting external data representations such as might be found in files or databases, allowing COBOL-generated data to be read by an Ada program, and Ada-generated data to be read by COBOL programs
    3. A generic package for converting between an Ada decimal type value and either an internal or external COBOL representation

Static Semantics

  1. The library package Interfaces.COBOL has the following declaration: 
  2. package Interfaces.COBOL is
   pragma Preelaborate(COBOL);

  3.    -- Types and operations for internal data representations

  4.    type Floating      is digits implementation-defined;
   type Long_Floating is digits implementation-defined;

  5.    type Binary      is range implementation-defined;
   type Long_Binary is range implementation-defined;

  6.    Max_Digits_Binary      : constant := implementation-defined;
   Max_Digits_Long_Binary : constant := implementation-defined;

  7.    type Decimal_Element  is mod implementation-defined;
   type Packed_Decimal is
     array (Positive range <>) of Decimal_Element;
   pragma Pack(Packed_Decimal);

  8.    type COBOL_Character is implementation-defined character type;

  9.    Ada_To_COBOL : array (Character) of COBOL_Character
     := implementation-defined;

  10.    COBOL_To_Ada : array (COBOL_Character) of Character
     := implementation-defined;

  11.    type Alphanumeric is
     array (Positive range <>) of COBOL_Character;
   pragma Pack(Alphanumeric);

  12.    function To_COBOL (Item : in String) return Alphanumeric;
   function To_Ada   (Item : in Alphanumeric) return String;

  13.    procedure To_COBOL (Item       : in String;
                       Target     : out Alphanumeric;
                       Last       : out Natural);

  14.    procedure To_Ada (Item     : in Alphanumeric;
                     Target   : out String;
                     Last     : out Natural);

  15.    type Numeric is array (Positive range <>) of COBOL_Character;
   pragma Pack(Numeric);

  16.    -- Formats for COBOL data representations

  17.    type Display_Format is private;

  18.    Unsigned             : constant Display_Format;
   Leading_Separate     : constant Display_Format;
   Trailing_Separate    : constant Display_Format;
   Leading_Nonseparate  : constant Display_Format;
   Trailing_Nonseparate : constant Display_Format;

  19.    type Binary_Format is private;

  20.    High_Order_First  : constant Binary_Format;
   Low_Order_First   : constant Binary_Format;
   Native_Binary     : constant Binary_Format;

  21.    type Packed_Format is private;

  22.    Packed_Unsigned   : constant Packed_Format;
   Packed_Signed     : constant Packed_Format;

  23.    -- Types for external representation of COBOL binary data

  24.    type Byte is mod 2**COBOL_Character'Size;
   type Byte_Array is array (Positive range <>) of Byte;
   pragma Pack (Byte_Array);

  25.    Conversion_Error : exception;

  26.    generic
      type Num is delta <> digits <>;
   package Decimal_Conversions is

  27.       -- Display Formats: data values are represented as Numeric

  28.       function Valid (Item   : in Numeric;
                      Format : in Display_Format) return Boolean;

  29.       function Length (Format : in Display_Format) return Natural;

  30.       function To_Decimal (Item   : in Numeric;
                           Format : in Display_Format) return Num;

  31.       function To_Display (Item   : in Num;
                           Format : in Display_Format)
        return Numeric;

  32.       -- Packed Formats:
      -- data values are represented as Packed_Decimal

  33.       function Valid (Item   : in Packed_Decimal;
                      Format : in Packed_Format) return Boolean;

  34.       function Length (Format : in Packed_Format) return Natural;

  35.       function To_Decimal (Item   : in Packed_Decimal;
                           Format : in Packed_Format) return Num;

  36.       function To_Packed (Item   : in Num;
                          Format : in Packed_Format)
        return Packed_Decimal;

  37.       -- Binary Formats:
      -- external data values are represented as Byte_Array

  38.       function Valid (Item   : in Byte_Array;
                      Format : in Binary_Format) return Boolean;

  39.       function Length (Format : in Binary_Format) return Natural;
      function To_Decimal (Item   : in Byte_Array;
                           Format : in Binary_Format) return Num;

  40.       function To_Binary (Item   : in Num;
                        Format : in Binary_Format)
        return Byte_Array;

  41.       -- Internal Binary formats:
      -- data values are of type Binary or Long_Binary

  42.       function To_Decimal (Item : in Binary)      return Num;
      function To_Decimal (Item : in Long_Binary) return Num;

  43.       function To_Binary      (Item : in Num)  return Binary;
      function To_Long_Binary (Item : in Num)  return Long_Binary;

  44.    end Decimal_Conversions;

  45. private
   ... -- not specified by the language
end Interfaces.COBOL;
  46. Each of the types in Interfaces.COBOL is COBOL-compatible.
  47. The types Floating and Long_Floating correspond to the native types in COBOL for data items with computational usage implemented by floating point. The types Binary and Long_Binary correspond to the native types in COBOL for data items with binary usage, or with computational usage implemented by binary.
  48. Max_Digits_Binary is the largest number of decimal digits in a numeric value that is represented as Binary. Max_Digits_Long_Binary is the largest number of decimal digits in a numeric value that is represented as Long_Binary.
  49. The type Packed_Decimal corresponds to COBOL's packed-decimal usage.
  50. The type COBOL_Character defines the run-time character set used in the COBOL implementation. Ada_To_COBOL and COBOL_To_Ada are the mappings between the Ada and COBOL run-time character sets.
  51. Type Alphanumeric corresponds to COBOL's alphanumeric data category.
  52. Each of the functions To_COBOL and To_Ada converts its parameter based on the mappings Ada_To_COBOL and COBOL_To_Ada, respectively. The length of the result for each is the length of the parameter, and the lower bound of the result is 1. Each component of the result is obtained by applying the relevant mapping to the corresponding component of the parameter.
  53. Each of the procedures To_COBOL and To_Ada copies converted elements from Item to Target, using the appropriate mapping (Ada_To_COBOL or COBOL_To_Ada, respectively). The index in Target of the last element assigned is returned in Last (0 if Item is a null array). If Item'Length exceeds Target'Length, Constraint_Error is propagated.
  54. Type Numeric corresponds to COBOL's numeric data category with display usage.
  55. The types Display_Format, Binary_Format, and Packed_Format are used in conversions between Ada decimal type values and COBOL internal or external data representations. The value of the constant Native_Binary is either High_Order_First or Low_Order_First, depending on the implementation. 
  56. function Valid (Item   : in Numeric;
                Format : in Display_Format) return Boolean;
    1. The function Valid checks that the Item parameter has a value consistent with the value of Format. If the value of Format is other than Unsigned, Leading_Separate, and Trailing_Separate, the effect is implementation defined. If Format does have one of these values, the following rules apply:
      1. Format=Unsigned: if Item comprises zero or more leading space characters followed by one or more decimal digit characters then Valid returns True, else it returns False.
      2. Format=Leading_Separate: if Item comprises zero or more leading space characters, followed by a single occurrence of the plus or minus sign character, and then one or more decimal digit characters, then Valid returns True, else it returns False.
      3. Format=Trailing_Separate: if Item comprises zero or more leading space characters, followed by one or more decimal digit characters and finally a plus or minus sign character, then Valid returns True, else it returns False. 
  1. function Length (Format : in Display_Format) return Natural;
    1. The Length function returns the minimal length of a Numeric value sufficient to hold any value of type Num when represented as Format. 
  1. function To_Decimal (Item   : in Numeric;
                     Format : in Display_Format) return Num;
    1. Produces a value of type Num corresponding to Item as represented by Format. The number of digits after the assumed radix point in Item is Num'Scale. Conversion_Error is propagated if the value represented by Item is outside the range of Num. 
  1. function To_Display (Item   : in Num;
                     Format : in Display_Format) return Numeric;
    1. This function returns the Numeric value for Item, represented in accordance with Format. Conversion_Error is propagated if Num is negative and Format is Unsigned. 
  1. function Valid (Item   : in Packed_Decimal;
                Format : in Packed_Format) return Boolean;
    1. This function returns True if Item has a value consistent with Format, and False otherwise. The rules for the formation of Packed_Decimal values are implementation defined. 
  1. function Length (Format : in Packed_Format) return Natural;
    1. This function returns the minimal length of a Packed_Decimal value sufficient to hold any value of type Num when represented as Format. 
  1. function To_Decimal (Item   : in Packed_Decimal;
                     Format : in Packed_Format) return Num;
    1. Produces a value of type Num corresponding to Item as represented by Format. Num'Scale is the number of digits after the assumed radix point in Item. Conversion_Error is propagated if the value represented by Item is outside the range of Num. 
  1. function To_Packed (Item   : in Num;
                    Format : in Packed_Format)
  return Packed_Decimal;
    1. This function returns the Packed_Decimal value for Item, represented in accordance with Format. Conversion_Error is propagated if Num is negative and Format is Packed_Unsigned. 
  1. function Valid (Item   : in Byte_Array;
                Format : in Binary_Format) return Boolean;
    1. This function returns True if Item has a value consistent with Format, and False otherwise. 
  1. function Length (Format : in Binary_Format) return Natural;
    1. This function returns the minimal length of a Byte_Array value sufficient to hold any value of type Num when represented as Format. 
  1. function To_Decimal (Item   : in Byte_Array;
                     Format : in Binary_Format) return Num;
    1. Produces a value of type Num corresponding to Item as represented by Format. Num'Scale is the number of digits after the assumed radix point in Item. Conversion_Error is propagated if the value represented by Item is outside the range of Num. 
  1. function To_Binary (Item   : in Num;
                    Format : in Binary_Format) return Byte_Array;
    1. This function returns the Byte_Array value for Item, represented in accordance with Format. 
  1. function To_Decimal (Item : in Binary)      return Num;

function To_Decimal (Item : in Long_Binary) return Num;
    1. These functions convert from COBOL binary format to a corresponding value of the decimal type Num. Conversion_Error is propagated if Item is too large for Num. 
  1. function To_Binary      (Item : in Num)  return Binary;

function To_Long_Binary (Item : in Num)  return Long_Binary;
    1. These functions convert from Ada decimal to COBOL binary format. Conversion_Error is propagated if the value of Item is too large to be represented in the result type.

Implementation Requirements

  1. An implementation shall support pragma Convention with a COBOL convention_identifier for a COBOL-eligible type, see section Interfacing Pragmas.

    Implementation Permissions

  2. An implementation may provide additional constants of the private types Display_Format, Binary_Format, or Packed_Format.
  3. An implementation may provide further floating point and integer types in Interfaces.COBOL to match additional native COBOL types, and may also supply corresponding conversion functions in the generic package Decimal_Conversions.

    Implementation Advice

  4. An Ada implementation should support the following interface correspondences between Ada and COBOL.
    1. An Ada access T parameter is passed as a "BY REFERENCE" data item of the COBOL type corresponding to T.
    2. An Ada in scalar parameter is passed as a "BY CONTENT" data item of the corresponding COBOL type.
    3. Any other Ada parameter is passed as a "BY REFERENCE" data item of the COBOL type corresponding to the Ada parameter type; for scalars, a local copy is used if necessary to ensure by-copy semantics.
    NOTES
  1. (15) An implementation is not required to support pragma Convention for access types, nor is it required to support pragma Import, Export or Convention for functions.
  2. (16) If an Ada subprogram is exported to COBOL, then a call from COBOL call may specify either "BY CONTENT" or "BY REFERENCE".

    Examples

  3. Examples of Interfaces.COBOL: 
  4. with Interfaces.COBOL;
procedure Test_Call is

  5.    -- Calling a foreign COBOL program
   -- Assume that a COBOL program PROG has the following declaration
   --  in its LINKAGE section:
   --  01 Parameter-Area
   --     05 NAME   PIC X(20).
   --     05 SSN    PIC X(9).
   --     05 SALARY PIC 99999V99 USAGE COMP.
   -- The effect of PROG is to update SALARY based on some algorithm

  6.    package COBOL renames Interfaces.COBOL;

  7.    type Salary_Type is delta 0.01 digits 7;

  8.    type COBOL_Record is
      record
         Name   : COBOL.Numeric(1..20);
         SSN    : COBOL.Numeric(1..9);
         Salary : COBOL.Binary;  -- Assume Binary = 32 bits
      end record;
   pragma Convention (COBOL, COBOL_Record);

  9.    procedure Prog (Item : in out COBOL_Record);
   pragma Import (COBOL, Prog, "PROG");

  10.    package Salary_Conversions is
      new COBOL.Decimal_Conversions(Salary_Type);

  11.    Some_Salary : Salary_Type := 12_345.67;
   Some_Record : COBOL_Record :=
      (Name   => "Johnson, John       ",
       SSN    => "111223333",
       Salary => Salary_Conversions.To_Binary(Some_Salary));

  12. begin
   Prog (Some_Record);
   ...
end Test_Call;

  13. with Interfaces.COBOL;
with COBOL_Sequential_IO;
-- Assumed to be supplied by implementation
procedure Test_External_Formats is

  14.    -- Using data created by a COBOL program
   -- Assume that a COBOL program has created a sequential file with
   --  the following record structure, and that we need to
   --  process the records in an Ada program
   --  01 EMPLOYEE-RECORD
   --     05 NAME    PIC X(20).
   --     05 SSN     PIC X(9).
   --     05 SALARY  PIC 99999V99 USAGE COMP.
   --     05 ADJUST  PIC S999V999 SIGN LEADING SEPARATE.
   -- The COMP data is binary (32 bits), high-order byte first

  15.    package COBOL renames Interfaces.COBOL;

  16.    type Salary_Type      is delta 0.01  digits 7;
   type Adjustments_Type is delta 0.001 digits 6;

  17.    type COBOL_Employee_Record_Type is  -- External representation
      record
         Name    : COBOL.Alphanumeric(1..20);
         SSN     : COBOL.Alphanumeric(1..9);
         Salary  : COBOL.Byte_Array(1..4);
         Adjust  : COBOL.Numeric(1..7);  -- Sign and 6 digits
      end record;
   pragma Convention (COBOL, COBOL_Employee_Record_Type);

  18.    package COBOL_Employee_IO is
      new COBOL_Sequential_IO(COBOL_Employee_Record_Type);
   use COBOL_Employee_IO;

  19.    COBOL_File : File_Type;

  20.    type Ada_Employee_Record_Type is  -- Internal representation
      record
         Name    : String(1..20);
         SSN     : String(1..9);
         Salary  : Salary_Type;
         Adjust  : Adjustments_Type;
      end record;

  21.    COBOL_Record : COBOL_Employee_Record_Type;
   Ada_Record   : Ada_Employee_Record_Type;

  22.    package Salary_Conversions is
      new COBOL.Decimal_Conversions(Salary_Type);
   use Salary_Conversions;

  23.    package Adjustments_Conversions is
      new COBOL.Decimal_Conversions(Adjustments_Type);
   use Adjustments_Conversions;

  24. begin
   Open (COBOL_File, Name => "Some_File");

  25.    loop
     Read (COBOL_File, COBOL_Record);

  26.      Ada_Record.Name := To_Ada(COBOL_Record.Name);
     Ada_Record.SSN  := To_Ada(COBOL_Record.SSN);
     Ada_Record.Salary :=
        To_Decimal(COBOL_Record.Salary, COBOL.High_Order_First);
     Ada_Record.Adjust :=
        To_Decimal(COBOL_Record.Adjust, COBOL.Leading_Separate);
     ... -- Process Ada_Record
   end loop;
exception
   when End_Error => ...
end Test_External_Formats;

Interfacing with Fortran

  1. The facilities relevant to interfacing with the Fortran language are the package Interfaces.Fortran and support for the Import, Export and Convention pragmas with convention_identifier Fortran.
  2. The package Interfaces.Fortran defines Ada types whose representations are identical to the default representations of the Fortran intrinsic types Integer, Real, Double Precision, Complex, Logical, and Character in a supported Fortran implementation. These Ada types can therefore be used to pass objects between Ada and Fortran programs.

    Static Semantics

  3. The library package Interfaces.Fortran has the following declaration: 
  4. with Ada.Numerics.Generic_Complex_Types;  --  see section Complex Types.
pragma Elaborate_All(Ada.Numerics.Generic_Complex_Types);
package Interfaces.Fortran is
   pragma Pure(Fortran);

  5.    type Fortran_Integer is range implementation-defined;

  6.    type Real             is digits implementation-defined;
   type Double_Precision is digits implementation-defined;

  7.    type Logical is new Boolean;

  8.    package Single_Precision_Complex_Types is
      new Ada.Numerics.Generic_Complex_Types (Real);

  9.    type Complex is new Single_Precision_Complex_Types.Complex;

  10.    subtype Imaginary is Single_Precision_Complex_Types.Imaginary;
   i : Imaginary renames Single_Precision_Complex_Types.i;
   j : Imaginary renames Single_Precision_Complex_Types.j;

  11.    type Character_Set is implementation-defined character type;

  12.    type Fortran_Character is
     array (Positive range <>) of Character_Set;
   pragma Pack (Fortran_Character);

  13.    function To_Fortran (Item : in Character) return Character_Set;
   function To_Ada (Item : in Character_Set) return Character;

  14.    function To_Fortran (Item : in String) return Fortran_Character;
   function To_Ada     (Item : in Fortran_Character) return String;

  15.    procedure To_Fortran (Item       : in String;
                         Target     : out Fortran_Character;
                         Last       : out Natural);

  16.    procedure To_Ada (Item     : in Fortran_Character;
                     Target   : out String;
                     Last     : out Natural);

  17. end Interfaces.Fortran;
  18. The types Fortran_Integer, Real, Double_Precision, Logical, Complex, and Fortran_Character are Fortran-compatible.
  19. The To_Fortran and To_Ada functions map between the Ada type Character and the Fortran type Character_Set, and also between the Ada type String and the Fortran type Fortran_Character. The To_Fortran and To_Ada procedures have analogous effects to the string conversion subprograms found in Interfaces.COBOL.

    Implementation Requirements

  20. An implementation shall support pragma Convention with a Fortran convention_identifier for a Fortran-eligible type, see section Interfacing Pragmas.

    Implementation Permissions

  21. An implementation may add additional declarations to the Fortran interface packages. For example, the Fortran interface package for an implementation of Fortran 77 (ANSI X3.9-1978) that defines types like Integer*n, Real*n, Logical*n, and Complex*n may contain the declarations of types named Integer_Star_n, Real_Star_n, Logical_Star_n, and Complex_Star_n. (This convention should not apply to Character*n, for which the Ada analog is the constrained array subtype Fortran_Character (1..n).) Similarly, the Fortran interface package for an implementation of Fortran 90 that provides multiple kinds of intrinsic types, e.g. Integer (Kind=n), Real (Kind=n), Logical (Kind=n), Complex (Kind=n), and Character (Kind=n), may contain the declarations of types with the recommended names Integer_Kind_n, Real_Kind_n, Logical_Kind_n, Complex_Kind_n, and Character_Kind_n.

    Implementation Advice

  22. An Ada implementation should support the following interface correspondences between Ada and Fortran:
    1. An Ada procedure corresponds to a Fortran subroutine.
    2. An Ada function corresponds to a Fortran function.
    3. An Ada parameter of an elementary, array, or record type T is passed as a T(F) argument to a Fortran procedure, where T(F) is the Fortran type corresponding to the Ada type T, and where the INTENT attribute of the corresponding dummy argument matches the Ada formal parameter mode; the Fortran implementation's parameter passing conventions are used. For elementary types, a local copy is used if necessary to ensure by-copy semantics.
    4. An Ada parameter of an access-to-subprogram type is passed as a reference to a Fortran procedure whose interface corresponds to the designated subprogram's specification.
    NOTES
  1. (17) An object of a Fortran-compatible record type, declared in a library package or subprogram, can correspond to a Fortran common block; the type also corresponds to a Fortran "derived type".

    Examples

  2. Example of Interfaces.Fortran: 
  3. with Interfaces.Fortran;
use Interfaces.Fortran;
procedure Ada_Application is

  4.    type Fortran_Matrix is array
     (Integer range <>,
      Integer range <>) of Double_Precision;
   pragma Convention (Fortran, Fortran_Matrix);
   -- stored in Fortran's column-major order
   procedure Invert
     (Rank : in Fortran_Integer;
      X    : in out Fortran_Matrix);
   pragma Import (Fortran, Invert);
   -- a Fortran subroutine

  5.    Rank      : constant Fortran_Integer := 100;
   My_Matrix : Fortran_Matrix (1 .. Rank, 1 .. Rank);

  6. begin

  7.    ...
   My_Matrix := ...;
   ...
   Invert (Rank, My_Matrix);
   ...

  8. end Ada_Application;

Systems Programming (normative)

  1. The Systems Programming Annex specifies additional capabilities provided for low-level programming. These capabilities are also required in many real-time, embedded, distributed, and information systems.

Access to Machine Operations

  1. This clause specifies rules regarding access to machine instructions from within an Ada program.

    Implementation Requirements

  2. The implementation shall support machine code insertions, see section Machine Code Insertions, or intrinsic subprograms, see section Conformance Rules, (or both). Implementation-defined attributes shall be provided to allow the use of Ada entities as operands.

    Implementation Advice

  3. The machine code or intrinsics support should allow access to all operations normally available to assembly language programmers for the target environment, including privileged instructions, if any.
  4. The interfacing pragmas (see section Interface to Other Languages (normative)) should support interface to assembler; the default assembler should be associated with the convention identifier Assembler.
  5. If an entity is exported to assembly language, then the implementation should allocate it at an addressable location, and should ensure that it is retained by the linking process, even if not otherwise referenced from the Ada code. The implementation should assume that any call to a machine code or assembler subprogram is allowed to read or update every object that is specified as exported.

    Documentation Requirements

  6. The implementation shall document the overhead associated with calling machine-code or intrinsic subprograms, as compared to a fully-inlined call, and to a regular out-of-line call.
  7. The implementation shall document the types of the package System.Machine_Code usable for machine code insertions, and the attributes to be used in machine code insertions for references to Ada entities.
  8. The implementation shall document the subprogram calling conventions associated with the convention identifiers available for use with the interfacing pragmas (Ada and Assembler, at a minimum), including register saving, exception propagation, parameter passing, and function value returning.
  9. For exported and imported subprograms, the implementation shall document the mapping between the Link_Name string, if specified, or the Ada designator, if not, and the external link name used for such a subprogram.

    Implementation Advice

  10. The implementation should ensure that little or no overhead is associated with calling intrinsic and machine-code subprograms.
  11. It is recommended that intrinsic subprograms be provided for convenient access to any machine operations that provide special capabilities or efficiency and that are not otherwise available through the language constructs. Examples of such instructions include:
    1. Atomic read-modify-write operations -- e.g., test and set, compare and swap, decrement and test, enqueue/dequeue.
    2. Standard numeric functions -- e.g., sin, log.
    3. String manipulation operations -- e.g., translate and test.
    4. Vector operations -- e.g., compare vector against thresholds.
    5. Direct operations on I/O ports.

Required Representation Support

  1. This clause specifies minimal requirements on the implementation's support for representation items and related features.

    Implementation Requirements

  2. The implementation shall support at least the functionality defined by the recommended levels of support in section Representation Issues.

Interrupt Support

  1. This clause specifies the language-defined model for hardware interrupts in addition to mechanisms for handling interrupts.

    Dynamic Semantics

  2. An interrupt represents a class of events that are detected by the hardware or the system software. Interrupts are said to occur. An occurrence of an interrupt is separable into generation and delivery. Generation of an interrupt is the event in the underlying hardware or system that makes the interrupt available to the program. Delivery is the action that invokes part of the program as response to the interrupt occurrence. Between generation and delivery, the interrupt occurrence (or interrupt) is pending. Some or all interrupts may be blocked. When an interrupt is blocked, all occurrences of that interrupt are prevented from being delivered. Certain interrupts are reserved. The set of reserved interrupts is implementation defined. A reserved interrupt is either an interrupt for which user-defined handlers are not supported, or one which already has an attached handler by some other implementation-defined means. Program units can be connected to non-reserved interrupts. While connected, the program unit is said to be attached to that interrupt. The execution of that program unit, the interrupt handler, is invoked upon delivery of the interrupt occurrence.
  3. While a handler is attached to an interrupt, it is called once for each delivered occurrence of that interrupt. While the handler executes, the corresponding interrupt is blocked.
  4. While an interrupt is blocked, all occurrences of that interrupt are prevented from being delivered. Whether such occurrences remain pending or are lost is implementation defined.
  5. Each interrupt has a default treatment which determines the system's response to an occurrence of that interrupt when no user-defined handler is attached. The set of possible default treatments is implementation defined, as is the method (if one exists) for configuring the default treatments for interrupts.
  6. An interrupt is delivered to the handler (or default treatment) that is in effect for that interrupt at the time of delivery.
  7. An exception propagated from a handler that is invoked by an interrupt has no effect.
  8. If the Ceiling_Locking policy, see section Priority Ceiling Locking, is in effect, the interrupt handler executes with the active priority that is the ceiling priority of the corresponding protected object.

    Implementation Requirements

  9. The implementation shall provide a mechanism to determine the minimum stack space that is needed for each interrupt handler and to reserve that space for the execution of the handler. This space should accommodate nested invocations of the handler where the system permits this.
  10. If the hardware or the underlying system holds pending interrupt occurrences, the implementation shall provide for later delivery of these occurrences to the program.
  11. If the Ceiling_Locking policy is not in effect, the implementation shall provide means for the application to specify whether interrupts are to be blocked during protected actions.

    Documentation Requirements

  12. The implementation shall document the following items:
    1. For each interrupt, which interrupts are blocked from delivery when a handler attached to that interrupt executes (either as a result of an interrupt delivery or of an ordinary call on a procedure of the corresponding protected object).
    2. Any interrupts that cannot be blocked, and the effect of attaching handlers to such interrupts, if this is permitted.
    3. Which run-time stack an interrupt handler uses when it executes as a result of an interrupt delivery; if this is configurable, what is the mechanism to do so; how to specify how much space to reserve on that stack.
    4. Any implementation- or hardware-specific activity that happens before a user-defined interrupt handler gets control (e.g., reading device registers, acknowledging devices).
    5. Any timing or other limitations imposed on the execution of interrupt handlers.
    6. The state (blocked/unblocked) of the non-reserved interrupts when the program starts; if some interrupts are unblocked, what is the mechanism a program can use to protect itself before it can attach the corresponding handlers.
    7. Whether the interrupted task is allowed to resume execution before the interrupt handler returns.
    8. The treatment of interrupt occurrences that are generated while the interrupt is blocked; i.e., whether one or more occurrences are held for later delivery, or all are lost.
    9. Whether predefined or implementation-defined exceptions are raised as a result of the occurrence of any interrupt, and the mapping between the machine interrupts (or traps) and the predefined exceptions.
    10. On a multi-processor, the rules governing the delivery of an interrupt to a particular processor.

Implementation Permissions

  1. If the underlying system or hardware does not allow interrupts to be blocked, then no blocking is required as part of the execution of subprograms of a protected object whose one of its subprograms is an interrupt handler.
  2. In a multi-processor with more than one interrupt subsystem, it is implementation defined whether (and how) interrupt sources from separate subsystems share the same Interrupt_ID type, see section The Package Interrupts. In particular, the meaning of a blocked or pending interrupt may then be applicable to one processor only.
  3. Implementations are allowed to impose timing or other limitations on the execution of interrupt handlers.
  4. Other forms of handlers are allowed to be supported, in which case, the rules of this subclause should be adhered to.
  5. The active priority of the execution of an interrupt handler is allowed to vary from one occurrence of the same interrupt to another.

    Implementation Advice

  6. If the Ceiling_Locking policy is not in effect, the implementation should provide means for the application to specify which interrupts are to be blocked during protected actions, if the underlying system allows for a finer-grain control of interrupt blocking. NOTES
  7. (1) The default treatment for an interrupt can be to keep the interrupt pending or to deliver it to an implementation-defined handler. Examples of actions that an implementation-defined handler is allowed to perform include aborting the partition, ignoring (i.e., discarding occurrences of) the interrupt, or queuing one or more occurrences of the interrupt for possible later delivery when a user-defined handler is attached to that interrupt.
  8. (2) It is a bounded error to call Task_Identification.Current_Task (see section The Package Task_Identification) from an interrupt handler.
  9. (3) The rule that an exception propagated from an interrupt handler has no effect is modeled after the rule about exceptions propagated out of task bodies.

Protected Procedure Handlers

Syntax

  1. The form of a pragma Interrupt_Handler is as follows: 
  2. pragma Interrupt_Handler(handler_name);
  3. The form of a pragma Attach_Handler is as follows: 
  4. pragma Attach_Handler(handler_name, expression);

    Name Resolution Rules

  5. For the Interrupt_Handler and Attach_Handler pragmas, the handler_name shall resolve to denote a protected procedure with a parameterless profile.
  6. For the Attach_Handler pragma, the expected type for the expression is Interrupts.Interrupt_ID, see section The Package Interrupts.

    Legality Rules

  7. The Attach_Handler pragma is only allowed immediately within the protected_definition where the corresponding subprogram is declared. The corresponding protected_type_declaration or single_protected_declaration shall be a library level declaration.
  8. The Interrupt_Handler pragma is only allowed immediately within a protected_definition. The corresponding protected_type_declaration shall be a library level declaration. In addition, any object_declaration of such a type shall be a library level declaration.

    Dynamic Semantics

  9. If the pragma Interrupt_Handler appears in a protected_definition, then the corresponding procedure can be attached dynamically, as a handler, to interrupts, see section The Package Interrupts. Such procedures are allowed to be attached to multiple interrupts.
  10. The expression in the Attach_Handler pragma as evaluated at object creation time specifies an interrupt. As part of the initialization of that object, if the Attach_Handler pragma is specified, the handler procedure is attached to the specified interrupt. A check is made that the corresponding interrupt is not reserved. Program_Error is raised if the check fails, and the existing treatment for the interrupt is not affected.
  11. If the Ceiling_Locking policy, see section Priority Ceiling Locking is in effect then upon the initialization of a protected object that either an Attach_Handler or Interrupt_Handler pragma applies to one of its procedures, a check is made that the ceiling priority defined in the protected_definition is in the range of System.Interrupt_Priority. If the check fails, Program_Error is raised.
  12. When a protected object is finalized, for any of its procedures that are attached to interrupts, the handler is detached. If the handler was attached by a procedure in the Interrupts package or if no user handler was previously attached to the interrupt, the default treatment is restored. Otherwise, that is, if an Attach_Handler pragma was used, the previous handler is restored.
  13. When a handler is attached to an interrupt, the interrupt is blocked (subject to the Implementation Permission in section Interrupt Support, during the execution of every protected action on the protected object containing the handler.

    Erroneous Execution

  14. If the Ceiling_Locking policy, see section Priority Ceiling Locking, is in effect and an interrupt is delivered to a handler, and the interrupt hardware priority is higher than the ceiling priority of the corresponding protected object, the execution of the program is erroneous.

    Metrics

  15. The following metric shall be documented by the implementation:
    1. The worst case overhead for an interrupt handler that is a parameterless protected procedure, in clock cycles. This is the execution time not directly attributable to the handler procedure or the interrupted execution. It is estimated as C - (A+B), where A is how long it takes to complete a given sequence of instructions without any interrupt, B is how long it takes to complete a normal call to a given protected procedure, and C is how long it takes to complete the same sequence of instructions when it is interrupted by one execution of the same procedure called via an interrupt.

Implementation Permissions

  1. When the pragmas Attach_Handler or Interrupt_Handler apply to a protected procedure, the implementation is allowed to impose implementation-defined restrictions on the corresponding protected_type_declaration and protected_body.
  2. An implementation may use a different mechanism for invoking a protected procedure in response to a hardware interrupt than is used for a call to that protected procedure from a task.
  3. Notwithstanding what this subclause says elsewhere, the Attach_Handler and Interrupt_Handler pragmas are allowed to be used for other, implementation defined, forms of interrupt handlers.

    Implementation Advice

  4. Whenever possible, the implementation should allow interrupt handlers to be called directly by the hardware.
  5. Whenever practical, the implementation should detect violations of any implementation-defined restrictions before run time. NOTES
  6. (4) The Attach_Handler pragma can provide static attachment of handlers to interrupts if the implementation supports preelaboration of protected objects (see section Preelaboration Requirements).
  7. (5) The ceiling priority of a protected object that one of its procedures is attached to an interrupt should be at least as high as the highest processor priority at which that interrupt will ever be delivered.
  8. (6) Protected procedures can also be attached dynamically to interrupts via operations declared in the predefined package Interrupts.
  9. (7) An example of a possible implementation-defined restriction is disallowing the use of the standard storage pools within the body of a protected procedure that is an interrupt handler.

The Package Interrupts

Static Semantics

  1. The following language-defined packages exist: 
  2. with System;
package Ada.Interrupts is
   type Interrupt_ID is implementation-defined;
   type Parameterless_Handler is
      access protected procedure;

  1.    function Is_Reserved (Interrupt : Interrupt_ID)
      return Boolean;

  2.    function Is_Attached (Interrupt : Interrupt_ID)
      return Boolean;

  3.    function Current_Handler (Interrupt : Interrupt_ID)
      return Parameterless_Handler;

  4.    procedure Attach_Handler
      (New_Handler : in Parameterless_Handler;
       Interrupt   : in Interrupt_ID);

  5.    procedure Exchange_Handler
      (Old_Handler : out Parameterless_Handler;
       New_Handler : in Parameterless_Handler;
       Interrupt   : in Interrupt_ID);

  6.    procedure Detach_Handler
      (Interrupt : in Interrupt_ID);

  7.    function Reference(Interrupt : Interrupt_ID)
      return System.Address;

  8. private
   ... -- not specified by the language
end Ada.Interrupts;

  9. package Ada.Interrupts.Names is
   implementation-defined : constant Interrupt_ID :=
     implementation-defined;
      . . .
   implementation-defined : constant Interrupt_ID :=
     implementation-defined;
end Ada.Interrupts.Names;

    Dynamic Semantics

  10. The Interrupt_ID type is an implementation-defined discrete type used to identify interrupts.
  11. The Is_Reserved function returns True if and only if the specified interrupt is reserved.
  12. The Is_Attached function returns True if and only if a user-specified interrupt handler is attached to the interrupt.
  13. The Current_Handler function returns a value that represents the attached handler of the interrupt. If no user-defined handler is attached to the interrupt, Current_Handler returns a value that designates the default treatment; calling Attach_Handler or Exchange_Handler with this value restores the default treatment.
  14. The Attach_Handler procedure attaches the specified handler to the interrupt, overriding any existing treatment (including a user handler) in effect for that interrupt. If New_Handler is null, the default treatment is restored. If New_Handler designates a protected procedure to which the pragma Interrupt_Handler does not apply, Program_Error is raised. In this case, the operation does not modify the existing interrupt treatment.
  15. The Exchange_Handler procedure operates in the same manner as Attach_Handler with the addition that the value returned in Old_Handler designates the previous treatment for the specified interrupt.
  16. The Detach_Handler procedure restores the default treatment for the specified interrupt.
  17. For all operations defined in this package that take a parameter of type Interrupt_ID, with the exception of Is_Reserved and Reference, a check is made that the specified interrupt is not reserved. Program_Error is raised if this check fails.
  18. If, by using the Attach_Handler, Detach_Handler, or Exchange_Handler procedures, an attempt is made to detach a handler that was attached statically (using the pragma Attach_Handler), the handler is not detached and Program_Error is raised.
  19. The Reference function returns a value of type System.Address that can be used to attach a task entry, via an address clause, see section Interrupt Entries, to theinterrupt specified by Interrupt. This function raises Program_Error if attaching task entries to interrupts (or to this particular interrupt) is not supported.

    Implementation Requirements

  20. At no time during attachment or exchange of handlers shall the current handler of the corresponding interrupt be undefined.

    Documentation Requirements

  21. If the Ceiling_Locking policy, see section Priority Ceiling Locking, is in effect the implementation shall document the default ceiling priority assigned to a protected object that contains either the Attach_Handler or Interrupt_Handler pragmas, but not the Interrupt_Priority pragma. This default need not be the same for all interrupts.

    Implementation Advice

  22. If implementation-defined forms of interrupt handler procedures are supported, such as protected procedures with parameters, then for each such form of a handler, a type analogous to Parameterless_Handler should be specified in a child package of Interrupts, with the same operations as in the predefined package Interrupts. NOTES
  23. (8) The package Interrupts.Names contains implementation-defined names (and constant values) for the interrupts that are supported by the implementation.

    Examples

  24. Example of interrupt handlers: 
  25. Device_Priority : constant
  array (1..5) of System.Interrupt_Priority := ( ... );
protected type Device_Interface
  (Int_ID : Ada.Interrupts.Interrupt_ID) is
  procedure Handler;
  pragma Attach_Handler(Handler, Int_ID);
  ...
  pragma Interrupt_Priority(Device_Priority(Int_ID));
end Device_Interface;
  ...
Device_1_Driver : Device_Interface(1);
  ...
Device_5_Driver : Device_Interface(5);
  ...

Preelaboration Requirements

  1. This clause specifies additional implementation and documentation requirements for the Preelaborate pragma, see section Elaboration Control.

    Implementation Requirements

  2. The implementation shall not incur any run-time overhead for the elaboration checks of subprograms and protected_bodies declared in preelaborated library units.
  3. The implementation shall not execute any memory write operations after load time for the elaboration of constant objects declared immediately within the declarative region of a preelaborated library package, so long as the subtype and initial expression (or default initial expressions if initialized by default) of the object_declaration satisfy the following restrictions. The meaning of load time is implementation defined.
    1. Any subtype_mark denotes a statically constrained subtype, with statically constrained subcomponents, if any;
    2. any constraint is a static constraint;
    3. any allocator is for an access-to-constant type;
    4. any uses of predefined operators appear only within static expressions;
    5. any primaries that are names, other than attribute_references for the Access or Address attributes, appear only within static expressions;
    6. any name that is not part of a static expression is an expanded name or direct_name that statically denotes some entity;
    7. any discrete_choice of an array_aggregate is static;
    8. no language-defined check associated with the elaboration of the object_declaration can fail.

Documentation Requirements

  1. The implementation shall document any circumstances under which the elaboration of a preelaborated package causes code to be executed at run time.
  2. The implementation shall document whether the method used for initialization of preelaborated variables allows a partition to be restarted without reloading.

    Implementation Advice

  3. It is recommended that preelaborated packages be implemented in such a way that there should be little or no code executed at run time for the elaboration of entities not already covered by the Implementation Requirements.

Pragma Discard_Names

  1. A pragma Discard_Names may be used to request a reduction in storage used for the names of certain entities.

    Syntax

  2. The form of a pragma Discard_Names is as follows: 
  3. pragma Discard_Names[([On => ] local_name)];
    1. A pragma Discard_Names is allowed only immediately within a declarative_part, immediately within a package_specification, or as a configuration pragma.

Legality Rules

  1. The local_name (if present) shall denote a non-derived enumeration first subtype, a tagged first subtype, or an exception. The pragma applies to the type or exception. Without a local_name, the pragma applies to all such entities declared after the pragma, within the same declarative region. Alternatively, the pragma can be used as a configuration pragma. If the pragma applies to a type, then it applies also to all descendants of the type.

    Static Semantics

  2. If a local_name is given, then a pragma Discard_Names is a representation pragma.
  3. If the pragma applies to an enumeration type, then the semantics of the Wide_Image and Wide_Value attributes are implementation defined for that type; the semantics of Image and Value are still defined in terms of Wide_Image and Wide_Value. In addition, the semantics of Text_IO.Enumeration_IO are implementation defined. If the pragma applies to a tagged type, then the semantics of the Tags.Expanded_Name function are implementation defined for that type. If the pragma applies to an exception, then the semantics of the Exceptions.Exception_Name function are implementation defined for that exception.

    Implementation Advice

  4. If the pragma applies to an entity, then the implementation should reduce the amount of storage used for storing names associated with that entity.

Shared Variable Control

  1. This clause specifies representation pragmas that control the use of shared variables.

    Syntax

  2. The form for pragmas Atomic, Volatile, Atomic_Components, and Volatile_Components is as follows: 
  3. pragma Atomic(local_name);

  4. pragma Volatile(local_name);

  5. pragma Atomic_Components(array_local_name);

  6. pragma Volatile_Components(array_local_name);
  7. An atomic type is one to which a pragma Atomic applies. An atomic object (including a component) is one to which a pragma Atomic applies, or a component of an array to which a pragma Atomic_Components applies, or any object of an atomic type.
  8. A volatile type is one to which a pragma Volatile applies. A volatile object (including a component) is one to which a pragma Volatile applies, or a component of an array to which a pragma Volatile_Components applies, or any object of a volatile type. In addition, every atomic type or object is also defined to be volatile. Finally, if an object is volatile, then so are all of its subcomponents (the same does not apply to atomic).

    Name Resolution Rules

  9. The local_name in an Atomic or Volatile pragma shall resolve to denote either an object_declaration, a non-inherited component_declaration, or a full_type_declaration. The array_local_name in an Atomic_Components or Volatile_Components pragma shall resolve to denote the declaration of an array type or an array object of an anonymous type.

    Legality Rules

  10. It is illegal to apply either an Atomic or Atomic_Components pragma to an object or type if the implementation cannot support the indivisible reads and updates required by the pragma (see below).
  11. It is illegal to specify the Size attribute of an atomic object, the Component_Size attribute for an array type with atomic components, or the layout attributes of an atomic component, in a way that prevents the implementation from performing the required indivisible reads and updates.
  12. If an atomic object is passed as a parameter, then the type of the formal parameter shall either be atomic or allow pass by copy (that is, not be a nonatomic by-reference type). If an atomic object is used as an actual for a generic formal object of mode in out, then the type of the generic formal object shall be atomic. If the prefix of an attribute_reference for an Access attribute denotes an atomic object (including a component), then the designated type of the resulting access type shall be atomic. If an atomic type is used as an actual for a generic formal derived type, then the ancestor of the formal type shall be atomic or allow pass by copy. Corresponding rules apply to volatile objects and types.
  13. If a pragma Volatile, Volatile_Components, Atomic, or Atomic_Components applies to a stand-alone constant object, then a pragma Import shall also apply to it.

    Static Semantics

  14. These pragmas are representation pragmas, see section Representation Items.

    Dynamic Semantics

  15. For an atomic object (including an atomic component) all reads and updates of the object as a whole are indivisible.
  16. For a volatile object all reads and updates of the object as a whole are performed directly to memory.
  17. Two actions are sequential, see section Shared Variables, if each is the read or update of the same atomic object.
  18. If a type is atomic or volatile and it is not a by-copy type, then the type is defined to be a by-reference type. If any subcomponent of a type is atomic or volatile, then the type is defined to be a by-reference type.
  19. If an actual parameter is atomic or volatile, and the corresponding formal parameter is not, then the parameter is passed by copy.

    Implementation Requirements

  20. The external effect of a program, see section Conformity of an Implementation with the Standard, is defined to include each read and update of a volatile or atomic object. The implementation shall not generate any memory reads or updates of atomic or volatile objects other than those specified by the program.
  21. If a pragma Pack applies to a type any of whose subcomponents are atomic, the implementation shall not pack the atomic subcomponents more tightly than that for which it can support indivisible reads and updates. NOTES
  22. (9) An imported volatile or atomic constant behaves as a constant (i.e. read-only) with respect to other parts of the Ada program, but can still be modified by an "external source."

Task Identification and Attributes

  1. This clause describes operations and attributes that can be used to obtain the identity of a task. In addition, a package that associates user-defined information with a task is defined.

The Package Task_Identification

Static Semantics

  1. The following language-defined library package exists: 
  2. package Ada.Task_Identification is
   type Task_ID is private;
   Null_Task_ID : constant Task_ID;
   function  "=" (Left, Right : Task_ID) return Boolean;

  3.    function  Image        (T : Task_ID) return String;
   function  Current_Task return Task_ID;
   procedure Abort_Task   (T : in out Task_ID);

  4.    function  Is_Terminated(T : Task_ID) return Boolean;
   function  Is_Callable  (T : Task_ID) return Boolean;
private
   ... -- not specified by the language
end Ada.Task_Identification;

    Dynamic Semantics

  5. A value of the type Task_ID identifies an existent task. The constant Null_Task_ID does not identify any task. Each object of the type Task_ID is default initialized to the value of Null_Task_ID.
  6. The function "=" returns True if and only if Left and Right identify the same task or both have the value Null_Task_ID.
  7. The function Image returns an implementation-defined string that identifies T. If T equals Null_Task_ID, Image returns an empty string.
  8. The function Current_Task returns a value that identifies the calling task.
  9. The effect of Abort_Task is the same as the abort_statement for the task identified by T. In addition, if T identifies the environment task, the entire partition is aborted, see section Partitions.
  10. The functions Is_Terminated and Is_Callable return the value of the corresponding attribute of the task identified by T.
  11. For a prefix T that is of a task type (after any implicit dereference), the following attribute is defined:
  12. T'Identity 
  13. Yields a value of the type Task_ID that identifies the task
denoted by T.
  14. For a prefix E that denotes an entry_declaration, the following attribute is defined:
  15. E'Caller 
    Yields a value of the type Task_ID that identifies the task
whose call is now being serviced. Use of this attribute is
allowed only inside an entry_body or accept_statement
corresponding to the entry_declaration denoted by E.
  16. Program_Error is raised if a value of Null_Task_ID is passed as a parameter to Abort_Task, Is_Terminated, and Is_Callable.
  17. Abort_Task is a potentially blocking operation, see section Protected Subprograms and Protected Actions.

    Bounded (Run-Time) Errors

  18. It is a bounded error to call the Current_Task function from an entry body or an interrupt handler. Program_Error is raised, or an implementation-defined value of the type Task_ID is returned.

    Erroneous Execution

  19. If a value of Task_ID is passed as a parameter to any of the operations declared in this package (or any language-defined child of this package), and the corresponding task object no longer exists, the execution of the program is erroneous.

    Documentation Requirements

  20. The implementation shall document the effect of calling Current_Task from an entry body or interrupt handler. NOTES
  21. (10) This package is intended for use in writing user-defined task scheduling packages and constructing server tasks. Current_Task can be used in conjunction with other operations requiring a task as an argument such as Set_Priority, see section Dynamic Priorities.
  22. (11) The function Current_Task and the attribute Caller can return a Task_ID value that identifies the environment task.

The Package Task_Attributes

Static Semantics

  1. The following language-defined generic library package exists: 
  2. with Ada.Task_Identification; use Ada.Task_Identification;
generic
   type Attribute is private;
   Initial_Value : in Attribute;
package Ada.Task_Attributes is

  3.    type Attribute_Handle is access all Attribute;

  4.    function Value(T : Task_ID := Current_Task)
     return Attribute;

  5.    function Reference(T : Task_ID := Current_Task)
     return Attribute_Handle;

  6.    procedure Set_Value(Val : in Attribute;
                       T   : in Task_ID := Current_Task);
   procedure Reinitialize(T : in Task_ID := Current_Task);

  7. end Ada.Task_Attributes;

    Dynamic Semantics

  8. When an instance of Task_Attributes is elaborated in a given active partition, an object of the actual type corresponding to the formal type Attribute is implicitly created for each task (of that partition) that exists and is not yet terminated. This object acts as a user-defined attribute of the task. A task created previously in the partition and not yet terminated has this attribute from that point on. Each task subsequently created in the partition will have this attribute when created. In all these cases, the initial value of the given attribute is Initial_Value.
  9. The Value operation returns the value of the corresponding attribute of T.
  10. The Reference operation returns an access value that designates the corresponding attribute of T.
  11. The Set_Value operation performs any finalization on the old value of the attribute of T and assigns Val to that attribute, see section Assignment Statements, and section User-Defined Assignment and Finalization.
  12. The effect of the Reinitialize operation is the same as Set_Value where the Val parameter is replaced with Initial_Value.
  13. For all the operations declared in this package, Tasking_Error is raised if the task identified by T is terminated. Program_Error is raised if the value of T is Null_Task_ID.

    Erroneous Execution

  14. It is erroneous to dereference the access value returned by a given call on Reference after a subsequent call on Reinitialize for the same task attribute, or after the associated task terminates.
  15. If a value of Task_ID is passed as a parameter to any of the operations declared in this package and the corresponding task object no longer exists, the execution of the program is erroneous.

    Implementation Requirements

  16. The implementation shall perform each of the above operations for a given attribute of a given task atomically with respect to any other of the above operations for the same attribute of the same task.
  17. When a task terminates, the implementation shall finalize all attributes of the task, and reclaim any other storage associated with the attributes.

    Documentation Requirements

  18. The implementation shall document the limit on the number of attributes per task, if any, and the limit on the total storage for attribute values per task, if such a limit exists.
  19. In addition, if these limits can be configured, the implementation shall document how to configure them.

    Metrics

  20. The implementation shall document the following metrics: A task calling the following subprograms shall execute in a sufficiently high priority as to not be preempted during the measurement period. This period shall start just before issuing the call and end just after the call completes. If the attributes of task T are accessed by the measurement tests, no other task shall access attributes of that task during the measurement period. For all measurements described here, the Attribute type shall be a scalar whose size is equal to the size of the predefined integer size. For each measurement, two cases shall be documented: one where the accessed attributes are of the calling task (that is, the default value for the T parameter is used), and the other, where T identifies another, non-terminated, task.
  21. The following calls (to subprograms in the Task_Attributes package) shall be measured:
    1. a call to Value, where the return value is Initial_Value;
    2. a call to Value, where the return value is not equal to Initial_Value;
    3. a call to Reference, where the return value designates a value equal to Initial_Value;
    4. a call to Reference, where the return value designates a value not equal to Initial_Value;
    5. a call to Set_Value where the Val parameter is not equal to Initial_Value and the old attribute value is equal to Initial_Value.
    6. a call to Set_Value where the Val parameter is not equal to Initial_Value and the old attribute value is not equal to Initial_Value.

Implementation Permissions

  1. An implementation need not actually create the object corresponding to a task attribute until its value is set to something other than that of Initial_Value, or until Reference is called for the task attribute. Similarly, when the value of the attribute is to be reinitialized to that of Initial_Value, the object may instead be finalized and its storage reclaimed, to be recreated when needed later. While the object does not exist, the function Value may simply return Initial_Value, rather than implicitly creating the object.
  2. An implementation is allowed to place restrictions on the maximum number of attributes a task may have, the maximum size of each attribute, and the total storage size allocated for all the attributes of a task.

    Implementation Advice

  3. Some implementations are targeted to domains in which memory use at run time must be completely deterministic. For such implementations, it is recommended that the storage for task attributes will be pre-allocated statically and not from the heap. This can be accomplished by either placing restrictions on the number and the size of the task's attributes, or by using the pre-allocated storage for the first N attribute objects, and the heap for the others. In the latter case, N should be documented. NOTES
  4. (12) An attribute always exists (after instantiation), and has the initial value. It need not occupy memory until the first operation that potentially changes the attribute value. The same holds true after Reinitialize.
  5. (13) The result of the Reference function should be used with care; it is always safe to use that result in the task body whose attribute is being accessed. However, when the result is being used by another task, the programmer must make sure that the task whose attribute is being accessed is not yet terminated. Failing to do so could make the program execution erroneous.
  6. (14) As specified in section The Package Task_Identification, if the parameter T (in a call on a subprogram of an instance of this package) identifies a nonexistent task, the execution of the program is erroneous.

Real-Time Systems (normative)

  1. This Annex specifies additional characteristics of Ada implementations intended for real-time systems software. To conform to this Annex, an implementation shall also conform to the Systems Programming Annex.

    Metrics

  2. The metrics are documentation requirements; an implementation shall document the values of the language-defined metrics for at least one configuration of hardware or an underlying system supported by the implementation, and shall document the details of that configuration.
  3. The metrics do not necessarily yield a simple number. For some, a range is more suitable, for others a formula dependent on some parameter is appropriate, and for others, it may be more suitable to break the metric into several cases. Unless specified otherwise, the metrics in this annex are expressed in processor clock cycles. For metrics that require documentation of an upper bound, if there is no upper bound, the implementation shall report that the metric is unbounded. NOTES
  4. (1) The specification of the metrics makes a distinction between upper bounds and simple execution times. Where something is just specified as "the execution time of" a piece of code, this leaves one the freedom to choose a nonpathological case. This kind of metric is of the form "there exists a program such that the value of the metric is V". Conversely, the meaning of upper bounds is "there is no program such that the value of the metric is greater than V". This kind of metric can only be partially tested, by finding the value of V for one or more test programs.
  5. (2) The metrics do not cover the whole language; they are limited to features that are specified in section Systems Programming (normative), and in this Annex. The metrics are intended to provide guidance to potential users as to whether a particular implementation of such a feature is going to be adequate for a particular real-time application. As such, the metrics are aimed at known implementation choices that can result in significant performance differences.
  6. (3) The purpose of the metrics is not necessarily to provide fine-grained quantitative results or to serve as a comparison between different implementations on the same or different platforms. Instead, their goal is rather qualitative; to define a standard set of approximate values that can be measured and used to estimate the general suitability of an implementation, or to evaluate the comparative utility of certain features of an implementation for a particular real-time application.

Task Priorities

  1. This clause specifies the priority model for real-time systems. In addition, the methods for specifying priorities are defined.

    Syntax

  2. The form of a pragma Priority is as follows: 
  3. pragma Priority(expression);
  4. The form of a pragma Interrupt_Priority is as follows: 
  5. pragma Interrupt_Priority[(expression)];

    Name Resolution Rules

  6. The expected type for the expression in a Priority or Interrupt_Priority pragma is Integer.

    Legality Rules

  7. A Priority pragma is allowed only immediately within a task_definition, a protected_definition, or the declarative_part of a subprogram_body. An Interrupt_Priority pragma is allowed only immediately within a task_ definition or a protected_definition. At most one such pragma shall appear within a given construct.
  8. For a Priority pragma that appears in the declarative_part of a subprogram_body, the expression shall be static, and its value shall be in the range of System.Priority.

    Static Semantics

  9. The following declarations exist in package System: 
  10. subtype Any_Priority is Integer range implementation-defined;
subtype Priority is Any_Priority range
  Any_Priority'First .. implementation-defined;
subtype Interrupt_Priority is Any_Priority range
  Priority'Last+1 .. Any_Priority'Last;

  11. Default_Priority : constant Priority
  := (Priority'First + Priority'Last)/2;
  12. The full range of priority values supported by an implementation is specified by the subtype Any_Priority. The subrange of priority values that are high enough to require the blocking of one or more interrupts is specified by the subtype Interrupt_Priority. The subrange of priority values below System.Interrupt_Priority'First is specified by the subtype System.Priority.
  13. The priority specified by a Priority or Interrupt_Priority pragma is the value of the expression in the pragma, if any. If there is no expression in an Interrupt_Priority pragma, the priority value is Interrupt_Priority'Last.

    Dynamic Semantics

  14. A Priority pragma has no effect if it occurs in the declarative_part of the subprogram_body of a subprogram other than the main subprogram.
  15. A task priority is an integer value that indicates a degree of urgency and is the basis for resolving competing demands of tasks for resources. Unless otherwise specified, whenever tasks compete for processors or other implementation-defined resources, the resources are allocated to the task with the highest priority value. The base priority of a task is the priority with which it was created, or to which it was later set by Dynamic_Priorities.Set_Priority, see section Dynamic Priorities. At all times, a task also has an active priority, which generally reflects its base priority as well as any priority it inherits from other sources. Priority inheritance is the process by which the priority of a task or other entity (e.g. a protected object, see section Priority Ceiling Locking) is used in the evaluation of another task's active priority.
  16. The effect of specifying such a pragma in a protected_definition is discussed in section Priority Ceiling Locking.
  17. The expression in a Priority or Interrupt_Priority pragma that appears in a task_definition is evaluated for each task object, see section Task Units and Task Objects. For a Priority pragma, the value of the expression is converted to the subtype Priority; for an Interrupt_Priority pragma, this value is converted to the subtype Any_Priority. The priority value is then associated with the task object whose task_definition contains the pragma.
  18. Likewise, the priority value is associated with the environment task if the pragma appears in the declarative_part of the main subprogram.
  19. The initial value of a task's base priority is specified by default or by means of a Priority or Interrupt_Priority pragma. After a task is created, its base priority can be changed only by a call to Dynamic_Priorities.Set_Priority, see section Dynamic Priorities. The initial base priority of a task in the absence of a pragma is the base priority of the task that creates it at the time of creation, see section Task Units and Task Objects. If a pragma Priority does not apply to the main subprogram, the initial base priority of the environment task is System.Default_Priority. The task's active priority is used when the task competes for processors. Similarly, the task's active priority is used to determine the task's position in any queue when Priority_Queuing is specified, see section Entry Queuing Policies.
  20. At any time, the active priority of a task is the maximum of all the priorities the task is inheriting at that instant. For a task that is not held, see section Asynchronous Task Control, its base priority is always a source of priority inheritance. Other sources of priority inheritance are specified under the following conditions:
    1. During activation, a task being activated inherits the active priority of the its activator, see section Task Execution - Task Activation.
    2. During rendezvous, the task accepting the entry call inherits the active priority of the caller, see section Entry Calls.
    3. During a protected action on a protected object, a task inherits the ceiling priority of the protected object, see section Intertask Communication, and section Priority Ceiling Locking.
  1. In all of these cases, the priority ceases to be inherited as soon as the condition calling for the inheritance no longer exists.

    Implementation Requirements

  2. The range of System.Interrupt_Priority shall include at least one value.
  3. The range of System.Priority shall include at least 30 values. NOTES
  4. (4) The priority expression can include references to discriminants of the enclosing type.
  5. (5) It is a consequence of the active priority rules that at the point when a task stops inheriting a priority from another source, its active priority is re-evaluated. This is in addition to other instances described in this Annex for such re-evaluation.
  6. (6) An implementation may provide a non-standard mode in which tasks inherit priorities under conditions other than those specified above.

Priority Scheduling

  1. This clause describes the rules that determine which task is selected for execution when more than one task is ready, see section Task Execution - Task Activation. The rules have two parts: the task dispatching model, see section The Task Dispatching Model, and a specific task dispatching policy, see section The Standard Task Dispatching Policy.

The Task Dispatching Model

  1. The task dispatching model specifies preemptive scheduling, based on conceptual priority-ordered ready queues.

    Dynamic Semantics

  2. A task runs (that is, it becomes a running task) only when it is ready (see section Task Execution - Task Activation) and the execution resources required by that task are available. Processors are allocated to tasks based on each task's active priority.
  3. It is implementation defined whether, on a multiprocessor, a task that is waiting for access to a protected object keeps its processor busy.
  4. Task dispatching is the process by which one ready task is selected for execution on a processor. This selection is done at certain points during the execution of a task called task dispatching points. A task reaches a task dispatching point whenever it becomes blocked, and whenever it becomes ready. In addition, the completion of an accept_statement, see section Entries and Accept Statements, and task termination are task dispatching points for the executing task. Other task dispatching points are defined throughout this Annex.
  5. Task dispatching policies are specified in terms of conceptual ready queues, task states, and task preemption. A ready queue is an ordered list of ready tasks. The first position in a queue is called the head of the queue, and the last position is called the tail of the queue. A task is ready if it is in a ready queue, or if it is running. Each processor has one ready queue for each priority value. At any instant, each ready queue of a processor contains exactly the set of tasks of that priority that are ready for execution on that processor, but are not running on any processor; that is, those tasks that are ready, are not running on any processor, and can be executed using that processor and other available resources. A task can be on the ready queues of more than one processor.
  6. Each processor also has one running task, which is the task currently being executed by that processor. Whenever a task running on a processor reaches a task dispatching point, one task is selected to run on that processor. The task selected is the one at the head of the highest priority nonempty ready queue; this task is then removed from all ready queues to which it belongs.
  7. A preemptible resource is a resource that while allocated to one task can be allocated (temporarily) to another instead. Processors are preemptible resources. Access to a protected object, see section Protected Subprograms and Protected Actions, is a nonpreemptible resource. When a higher-priority task is dispatched to the processor, and the previously running task is placed on the appropriate ready queue, the latter task is said to be preempted.
  8. A new running task is also selected whenever there is a nonempty ready queue with a higher priority than the priority of the running task, or when the task dispatching policy requires a running task to go back to a ready queue. These are also task dispatching points.

    Implementation Permissions

  9. An implementation is allowed to define additional resources as execution resources, and to define the corresponding allocation policies for them. Such resources may have an implementation defined effect on task dispatching, see section The Standard Task Dispatching Policy.
  10. An implementation may place implementation-defined restrictions on tasks whose active priority is in the Interrupt_Priority range. NOTES
  11. (7) Section section Tasks and Synchronization specifies under which circumstances a task becomes ready. The ready state is affected by the rules for task activation and termination, delay statements, and entry calls. When a task is not ready, it is said to be blocked.
  12. (8) An example of a possible implementation-defined execution resource is a page of physical memory, which needs to be loaded with a particular page of virtual memory before a task can continue execution.
  13. (9) The ready queues are purely conceptual; there is no requirement that such lists physically exist in an implementation.
  14. (10) While a task is running, it is not on any ready queue. Any time the task that is running on a processor is added to a ready queue, a new running task is selected for that processor.
  15. (11) In a multiprocessor system, a task can be on the ready queues of more than one processor. At the extreme, if several processors share the same set of ready tasks, the contents of their ready queues is identical, and so they can be viewed as sharing one ready queue, and can be implemented that way. Thus, the dispatching model covers multiprocessors where dispatching is implemented using a single ready queue, as well as those with separate dispatching domains.
  16. (12) The priority of a task is determined by rules specified in this subclause, and under section Task Priorities, section Priority Ceiling Locking, and section Dynamic Priorities.

The Standard Task Dispatching Policy

Syntax

  1. The form of a pragma Task_Dispatching_Policy is as follows: 
  2. pragma Task_Dispatching_Policy(policy_identifier );

    Legality Rules

  3. The policy_identifier shall either be FIFO_Within_Priorities or an implementation-defined identifier.

    Post-Compilation Rules

  4. A Task_Dispatching_Policy pragma is a configuration pragma.
  5. If the FIFO_Within_Priorities policy is specified for a partition, then the Ceiling_Locking policy, see section Priority Ceiling Locking shall also be specified for the partition.

    Dynamic Semantics

  6. A task dispatching policy specifies the details of task dispatching that are not covered by the basic task dispatching model. These rules govern when tasks are inserted into and deleted from the ready queues, and whether a task is inserted at the head or the tail of the queue for its active priority. The task dispatching policy is specified by a Task_Dispatching_Policy configuration pragma. If no such pragma appears in any of the program units comprising a partition, the task dispatching policy for that partition is unspecified.
  7. The language defines only one task dispatching policy, FIFO_Within_Priorities; when this policy is in effect, modifications to the ready queues occur only as follows:
    1. When a blocked task becomes ready, it is added at the tail of the ready queue for its active priority.
    2. When the active priority of a ready task that is not running changes, or the setting of its base priority takes effect, the task is removed from the ready queue for its old active priority and is added at the tail of the ready queue for its new active priority, except in the case where the active priority is lowered due to the loss of inherited priority, in which case the task is added at the head of the ready queue for its new active priority.
    3. When the setting of the base priority of a running task takes effect, the task is added to the tail of the ready queue for its active priority.
    4. When a task executes a delay_statement that does not result in blocking, it is added to the tail of the ready queue for its active priority.
  1. Each of the events specified above is a task dispatching point (see section The Task Dispatching Model).
  2. In addition, when a task is preempted, it is added at the head of the ready queue for its active priority.

    Documentation Requirements

  3. Priority inversion is the duration for which a task remains at the head of the highest priority ready queue while the processor executes a lower priority task. The implementation shall document:
    1. The maximum priority inversion a user task can experience due to activity of the implementation (on behalf of lower priority tasks), and
    2. whether execution of a task can be preempted by the implementation processing of delay expirations for lower priority tasks, and if so, for how long.

Implementation Permissions

  1. Implementations are allowed to define other task dispatching policies, but need not support more than one such policy per partition.
  2. For optimization purposes, an implementation may alter the points at which task dispatching occurs, in an implementation defined manner. However, a delay_statement always corresponds to at least one task dispatching point. NOTES
  3. (13) If the active priority of a running task is lowered due to loss of inherited priority (as it is on completion of a protected operation) and there is a ready task of the same active priority that is not running, the running task continues to run (provided that there is no higher priority task).
  4. (14) The setting of a task's base priority as a result of a call to Set_Priority does not always take effect immediately when Set_Priority is called. The effect of setting the task's base priority is deferred while the affected task performs a protected action.
  5. (15) Setting the base priority of a ready task causes the task to move to the end of the queue for its active priority, regardless of whether the active priority of the task actually changes.

Priority Ceiling Locking

  1. This clause specifies the interactions between priority task scheduling and protected object ceilings. This interaction is based on the concept of the ceiling priority of a protected object.

    Syntax

  2. The form of a pragma Locking_Policy is as follows: 
  3. pragma Locking_Policy(policy_identifier);

    Legality Rules

  4. The policy_identifier shall either be Ceiling_Locking or an implementation-defined identifier.

    Post-Compilation Rules

  5. A Locking_Policy pragma is a configuration pragma.

    Dynamic Semantics

  6. A locking policy specifies the details of protected object locking. These rules specify whether or not protected objects have priorities, and the relationships between these priorities and task priorities. In addition, the policy specifies the state of a task when it executes a protected action, and how its active priority is affected by the locking. The locking policy is specified by a Locking_Policy pragma. For implementation-defined locking policies, the effect of a Priority or Interrupt_Priority pragma on a protected object is implementation defined. If no Locking_Policy pragma appears in any of the program units comprising a partition, the locking policy for that partition, as well as the effect of specifying either a Priority or Interrupt_Priority pragma for a protected object, are implementation defined.
  7. There is one predefined locking policy, Ceiling_Locking; this policy is defined as follows:
    1. Every protected object has a ceiling priority, which is determined by either a Priority or Interrupt_Priority pragma as defined in D.1. The ceiling priority of a protected object (or ceiling, for short) is an upper bound on the active priority a task can have when it calls protected operations of that protected object.
    2. The expression of a Priority or Interrupt_Priority pragma is evaluated as part of the creation of the corresponding protected object and converted to the subtype System.Any_Priority or System.Interrupt_Priority, respectively. The value of the expression is the ceiling priority of the corresponding protected object.
    3. If an Interrupt_Handler or Attach_Handler pragma, see section Protected Procedure Handlers, appears in a protected_definition without an Interrupt_Priority pragma, the ceiling priority of protected objects of that type is implementation defined, but in the range of the subtype System.Interrupt_Priority.
    4. If no pragma Priority, Interrupt_Priority, Interrupt_Handler, or Attach_Handler is specified in the protected_definition, then the ceiling priority of the corresponding protected object is System.Priority'Last.
    5. While a task executes a protected action, it inherits the ceiling priority of the corresponding protected object.
    6. When a task calls a protected operation, a check is made that its active priority is not higher than the ceiling of the corresponding protected object; Program_Error is raised if this check fails.

Implementation Permissions

  1. The implementation is allowed to round all ceilings in a certain subrange of System.Priority or System.Interrupt_Priority up to the top of that subrange, uniformly.
  2. Implementations are allowed to define other locking policies, but need not support more than one such policy per partition.
  3. Since implementations are allowed to place restrictions on code that runs at an interrupt-level active priority, see section Protected Procedure Handlers, and section The Task Dispatching Model, the implementation may implement a language feature in terms of a protected object with an implementation-defined ceiling, but the ceiling shall be no less than Priority'Last.

    Implementation Advice

  4. The implementation should use names that end with "_Locking" for implementation-defined locking policies. NOTES
  5. (16) While a task executes in a protected action, it can be preempted only by tasks whose active priorities are higher than the ceiling priority of the protected object.
  6. (17) If a protected object has a ceiling priority in the range of Interrupt_Priority, certain interrupts are blocked while protected actions of that object execute. In the extreme, if the ceiling is Interrupt_Priority'Last, all blockable interrupts are blocked during that time.
  7. (18) The ceiling priority of a protected object has to be in the Interrupt_Priority range if one of its procedures is to be used as an interrupt handler, see section Interrupt Support.
  8. (19) When specifying the ceiling of a protected object, one should choose a value that is at least as high as the highest active priority at which tasks can be executing when they call protected operations of that object. In determining this value the following factors, which can affect active priority, should be considered: the effect of Set_Priority, nested protected operations, entry calls, task activation, and other implementation-defined factors.
  9. (20) Attaching a protected procedure whose ceiling is below the interrupt hardware priority to an interrupt causes the execution of the program to be erroneous, see section Protected Procedure Handlers.
  10. (21) On a single processor implementation, the ceiling priority rules guarantee that there is no possibility of deadlock involving only protected subprograms (excluding the case where a protected operation calls another protected operation on the same protected object).

Entry Queuing Policies

  1. This clause specifies a mechanism for a user to choose an entry queuing policy. It also defines one such policy. Other policies are implementation defined.

    Syntax

  2. The form of a pragma Queuing_Policy is as follows: 
  3. pragma Queuing_Policy(policy_identifier);

    Legality Rules

  4. The policy_identifier shall be either FIFO_Queuing, Priority_Queuing or an implementation-defined identifier.

    Post-Compilation Rules

  5. A Queuing_Policy pragma is a configuration pragma.

    Dynamic Semantics

  6. A queuing policy governs the order in which tasks are queued for entry service, and the order in which different entry queues are considered for service. The queuing policy is specified by a Queuing_Policy pragma.
  7. Two queuing policies, FIFO_Queuing and Priority_Queuing, are language defined. If no Queuing_Policy pragma appears in any of the program units comprising the partition, the queuing policy for that partition is FIFO_Queuing. The rules for this policy are specified in section Entry Calls, and section Selective Accept.
  8. The Priority_Queuing policy is defined as follows:
    1. The calls to an entry (including a member of an entry family) are queued in an order consistent with the priorities of the calls. The priority of an entry call is initialized from the active priority of the calling task at the time the call is made, but can change later. Within the same priority, the order is consistent with the calling (or requeuing, or priority setting) time (that is, a FIFO order).
    2. After a call is first queued, changes to the active priority of a task do not affect the priority of the call, unless the base priority of the task is set.
    3. When the base priority of a task is set, see section Dynamic Priorities, if the task is blocked on an entry call, and the call is queued, the priority of the call is updated to the new active priority of the calling task. This causes the call to be removed from and then reinserted in the queue at the new active priority.
    4. When more than one condition of an entry_barrier of a protected object becomes True, and more than one of the respective queues is nonempty, the call with the highest priority is selected. If more than one such call has the same priority, the call that is queued on the entry whose declaration is first in textual order in the protected_definition is selected. For members of the same entry family, the one with the lower family index is selected.
    5. If the expiration time of two or more open delay_alternatives is the same and no other accept_alternatives are open, the sequence_of_statements of the delay_alternative that is first in textual order in the selective_accept is executed.
    6. When more than one alternative of a selective_accept is open and has queued calls, an alternative whose queue has the highest-priority call at its head is selected. If two or more open alternatives have equal-priority queued calls, then a call on the entry in the accept_alternative that is first in textual order in the selective_accept is selected.

Implementation Permissions

  1. Implementations are allowed to define other queuing policies, but need not support more than one such policy per partition.

    Implementation Advice

  2. The implementation should use names that end with "_Queuing" for implementation-defined queuing policies.

Dynamic Priorities

  1. This clause specifies how the base priority of a task can be modified or queried at run time.

    Static Semantics

  2. The following language-defined library package exists: 
  3. with System;
with Ada.Task_Identification; --  see section The Package Task_Identification.
package Ada.Dynamic_Priorities is

  4.    procedure Set_Priority
     (Priority : in System.Any_Priority;
      T        : in Ada.Task_Identification.Task_ID :=
        Ada.Task_Identification.Current_Task);

  5.    function Get_Priority
     (T : Ada.Task_Identification.Task_ID :=
       Ada.Task_Identification.Current_Task)
     return System.Any_Priority;

  6. end Ada.Dynamic_Priorities;

    Dynamic Semantics

  7. The procedure Set_Priority sets the base priority of the specified task to the specified Priority value. Set_Priority has no effect if the task is terminated.
  8. The function Get_Priority returns T's current base priority. Tasking_Error is raised if the task is terminated.
  9. Program_Error is raised by Set_Priority and Get_Priority if T is equal to Null_Task_ID.
  10. Setting the task's base priority to the new value takes place as soon as is practical but not while the task is performing a protected action. This setting occurs no later then the next abort completion point of the task T, see section Abort of a Task - Abort of a Sequence of Statements.

    Bounded (Run-Time) Errors

  11. If a task is blocked on a protected entry call, and the call is queued, it is a bounded error to raise its base priority above the ceiling priority of the corresponding protected object. When an entry call is cancelled, it is a bounded error if the priority of the calling task is higher than the ceiling priority of the corresponding protected object. In either of these cases, either Program_Error is raised in the task that called the entry, or its priority is temporarily lowered, or both, or neither.

    Erroneous Execution

  12. If any subprogram in this package is called with a parameter T that specifies a task object that no longer exists, the execution of the program is erroneous.

    Metrics

  13. The implementation shall document the following metric:
    1. The execution time of a call to Set_Priority, for the nonpreempting case, in processor clock cycles. This is measured for a call that modifies the priority of a ready task that is not running (which cannot be the calling one), where the new base priority of the affected task is lower than the active priority of the calling task, and the affected task is not on any entry queue and is not executing a protected operation.
    NOTES
  1. (22) Setting a task's base priority affects task dispatching. First, it can change the task's active priority. Second, under the standard task dispatching policy it always causes the task to move to the tail of the ready queue corresponding to its active priority, even if the new base priority is unchanged.
  2. (23) Under the priority queuing policy, setting a task's base priority has an effect on a queued entry call if the task is blocked waiting for the call. That is, setting the base priority of a task causes the priority of a queued entry call from that task to be updated and the call to be removed and then reinserted in the entry queue at the new priority, see section Entry Queuing Policies, unless the call originated from the triggering_statement of an asynchronous_select.
  3. (24) The effect of two or more Set_Priority calls executed in parallel on the same task is defined as executing these calls in some serial order.
  4. (25) The rule for when Tasking_Error is raised for Set_Priority or Get_Priority is different from the rule for when Tasking_Error is raised on an entry call, see section Entry Calls. In particular, setting or querying the priority of a completed or an abnormal task is allowed, so long as the task is not yet terminated.
  5. (26) Changing the priorities of a set of tasks can be performed by a series of calls to Set_Priority for each task separately. For this to work reliably, it should be done within a protected operation that has high enough ceiling priority to guarantee that the operation completes without being preempted by any of the affected tasks.

Preemptive Abort

  1. This clause specifies requirements on the immediacy with which an aborted construct is completed.

    Dynamic Semantics

  2. On a system with a single processor, an aborted construct is completed immediately at the first point that is outside the execution of an abort-deferred operation.

    Documentation Requirements

  3. On a multiprocessor, the implementation shall document any conditions that cause the completion of an aborted construct to be delayed later than what is specified for a single processor.

    Metrics

  4. The implementation shall document the following metrics:
    1. The execution time, in processor clock cycles, that it takes for an abort_statement to cause the completion of the aborted task. This is measured in a situation where a task T2 preempts task T1 and aborts T1. T1 does not have any finalization code. T2 shall verify that T1 has terminated, by means of the Terminated attribute.
    2. On a multiprocessor, an upper bound in seconds, on the time that the completion of an aborted task can be delayed beyond the point that it is required for a single processor.
    3. An upper bound on the execution time of an asynchronous_select, in processor clock cycles. This is measured between a point immediately before a task T1 executes a protected operation Pr.Set that makes the condition of an entry_barrier Pr.Wait true, and the point where task T2 resumes execution immediately after an entry call to Pr.Wait in an asynchronous_select. T1 preempts T2 while T2 is executing the abortable part, and then blocks itself so that T2 can execute. The execution time of T1 is measured separately, and subtracted.
    4. An upper bound on the execution time of an asynchronous_select, in the case that no asynchronous transfer of control takes place. This is measured between a point immediately before a task executes the asynchronous_select with a nonnull abortable part, and the point where the task continues execution immediately after it. The execution time of the abortable part is subtracted.

Implementation Advice

  1. Even though the abort_statement is included in the list of potentially blocking operations, see section Protected Subprograms and Protected Actions, it is recommended that this statement be implemented in a way that never requires the task executing the abort_statement to block.
  2. On a multi-processor, the delay associated with aborting a task on another processor should be bounded; the implementation should use periodic polling, if necessary, to achieve this. NOTES
  3. (27) Abortion does not change the active or base priority of the aborted task.
  4. (28) Abortion cannot be more immediate than is allowed by the rules for deferral of abortion during finalization and in protected actions.

Tasking Restrictions

  1. This clause defines restrictions that can be used with a pragma Restrictions, see section Pragma Restrictions, to facilitate the construction of highly efficient tasking run-time systems.

    Static Semantics

  2. The following restriction_identifiers are language defined:
  3. No_Task_Hierarchy 
    All (nonenvironment) tasks depend directly on the environment
task of the partition.
  4. No_Nested_Finalization 
    Objects with controlled parts and access types that designate
such objects shall be declared only at library level.
  5. No_Abort_Statements 
    There are no abort_statements, and there are no calls on
Task_Identification.Abort_Task.
  6. No_Terminate_Alternatives 
    There are no selective_accepts with terminate_alternatives.
  7. No_Task_Allocators 
    There are no allocators for task types or types containing
task subcomponents.
  8. No_Implicit_Heap_Allocations 
    There are no operations that implicitly require heap storage
allocation to be performed by the implementation. The
operations that implicitly require heap storage allocation
are implementation defined.
  9. No_Dynamic_Priorities 
    There are no semantic dependences on the package
Dynamic_Priorities.
  10. No_Asynchronous_Control 
    There are no semantic dependences on the package
Asynchronous_Task_Control.
  11. The following restriction_parameter_identifiers are language defined:
  12. Max_Select_Alternatives 
    Specifies the maximum number of alternatives in a
selective_accept.
  13. Max_Task_Entries 
    Specifies the maximum number of entries per task. The bounds
of every entry family of a task unit shall be static, or
shall be defined by a discriminant of a subtype whose
corresponding bound is static. A value of zero indicates
that no rendezvous are possible.
  14. Max_Protected_Entries 
    Specifies the maximum number of entries per protected type.
The bounds of every entry family of a protected unit shall be
static, or shall be defined by a discriminant of a subtype
whose corresponding bound is static.

    Dynamic Semantics

  15. If the following restrictions are violated, the behavior is implementation defined. If an implementation chooses to detect such a violation, Storage_Error should be raised.
  16. The following restriction_parameter_identifiers are language defined:
  17. Max_Storage_At_Blocking 
    Specifies the maximum portion (in storage elements) of a
task's Storage_Size that can be retained by a blocked task.
  18. Max_Asynchronous_Select_Nesting 
    Specifies the maximum dynamic nesting level of
asynchronous_selects. A value of zero prevents the use of any
asynchronous_select.
  19. Max_Tasks 
    Specifies the maximum number of task creations that may be
executed over the lifetime of a partition, not counting the
creation of the environment task.
  20. It is implementation defined whether the use of pragma Restrictions results in a reduction in executable program size, storage requirements, or execution time. If possible, the implementation should provide quantitative descriptions of such effects for each restriction.

    Implementation Advice

  21. When feasible, the implementation should take advantage of the specified restrictions to produce a more efficient implementation. NOTES
  22. (29) The above Storage_Checks can be suppressed with pragma Suppress.

Monotonic Time

  1. This clause specifies a high-resolution, monotonic clock package.

    Static Semantics

  2. The following language-defined library package exists: 
  3. package Ada.Real_Time is

  4.   type Time is private;
  Time_First : constant Time;
  Time_Last : constant Time;
  Time_Unit : constant := implementation-defined-real-number;

  1.   type Time_Span is private;
  Time_Span_First : constant Time_Span;
  Time_Span_Last : constant Time_Span;
  Time_Span_Zero : constant Time_Span;
  Time_Span_Unit : constant Time_Span;

  2.   Tick : constant Time_Span;
  function Clock return Time;

  3.   function "+" (Left : Time; Right : Time_Span) return Time;
  function "+" (Left : Time_Span; Right : Time) return Time;
  function "-" (Left : Time; Right : Time_Span) return Time;
  function "-" (Left : Time; Right : Time) return Time_Span;

  4.   function "<" (Left, Right : Time) return Boolean;
  function "<="(Left, Right : Time) return Boolean;
  function ">" (Left, Right : Time) return Boolean;
  function ">="(Left, Right : Time) return Boolean;

  5.   function "+" (Left, Right : Time_Span) return Time_Span;
  function "-" (Left, Right : Time_Span) return Time_Span;
  function "-" (Right : Time_Span) return Time_Span;
  function "*" (Left : Time_Span; Right : Integer) return Time_Span;
  function "*" (Left : Integer; Right : Time_Span) return Time_Span;
  function "/" (Left, Right : Time_Span) return Integer;
  function "/" (Left : Time_Span; Right : Integer) return Time_Span;

  6.   function "abs"(Right : Time_Span) return Time_Span;

  7.   function "<" (Left, Right : Time_Span) return Boolean;
  function "<="(Left, Right : Time_Span) return Boolean;
  function ">" (Left, Right : Time_Span) return Boolean;
  function ">="(Left, Right : Time_Span) return Boolean;

  8.   function To_Duration (TS : Time_Span) return Duration;
  function To_Time_Span (D : Duration) return Time_Span;

  9.   function Nanoseconds  (NS : Integer) return Time_Span;
  function Microseconds (US : Integer) return Time_Span;
  function Milliseconds (MS : Integer) return Time_Span;

  10.   type Seconds_Count is range implementation-defined;

  11.   procedure Split(T  : in     Time;
                  SC :    out Seconds_Count;
                  TS :    out Time_Span);
  function Time_Of(SC : Seconds_Count; TS : Time_Span) return Time;

  12. private
   ... -- not specified by the language
end Ada.Real_Time;
  13. In this Annex, real time is defined to be the physical time as observed in the external environment. The type Time is a time type as defined by section Delay Statements, Duration, and Time, values of this type may be used in a delay_until_statement. Values of this type represent segments of an ideal time line. The set of values of the type Time corresponds one-to-one with an implementation-defined range of mathematical integers.
  14. The Time value I represents the half-open real time interval that starts with E+I*Time_Unit and is limited by E+(I+1)*Time_Unit, where Time_Unit is an implementation-defined real number and E is an unspecified origin point, the epoch, that is the same for all values of the type Time. It is not specified by the language whether the time values are synchronized with any standard time reference. For example, E can correspond to the time of system initialization or it can correspond to the epoch of some time standard.
  15. Values of the type Time_Span represent length of real time duration. The set of values of this type corresponds one-to-one with an implementation-defined range of mathematical integers. The Time_Span value corresponding to the integer I represents the real-time duration I*Time_Unit.
  16. Time_First and Time_Last are the smallest and largest values of the Time type, respectively. Similarly, Time_Span_First and Time_Span_Last are the smallest and largest values of the Time_Span type, respectively.
  17. A value of type Seconds_Count represents an elapsed time, measured in seconds, since the epoch.

    Dynamic Semantics

  18. Time_Unit is the smallest amount of real time representable by the Time type; it is expressed in seconds. Time_Span_Unit is the difference between two successive values of the Time type. It is also the smallest positive value of type Time_Span. Time_Unit and Time_Span_Unit represent the same real time duration. A clock tick is a real time interval during which the clock value (as observed by calling the Clock function) remains constant. Tick is the average length of such intervals.
  19. The function To_Duration converts the value TS to a value of type Duration. Similarly, the function To_Time_Span converts the value D to a value of type Time_Span. For both operations, the result is rounded to the nearest exactly representable value (away from zero if exactly halfway between two exactly representable values).
  20. To_Duration(Time_Span_Zero) returns 0.0, and To_Time_Span(0.0) returns Time_Span_Zero.
  21. The functions Nanoseconds, Microseconds, and Milliseconds convert the input parameter to a value of the type Time_Span. NS, US, and MS are interpreted as a number of nanoseconds, microseconds, and milliseconds respectively. The result is rounded to the nearest exactly representable value (away from zero if exactly halfway between two exactly representable values).
  22. The effects of the operators on Time and Time_Span are as for the operators defined for integer types.
  23. The function Clock returns the amount of time since the epoch.
  24. The effects of the Split and Time_Of operations are defined as follows, treating values of type Time, Time_Span, and Seconds_Count as mathematical integers. The effect of Split(T,SC,TS) is to set SC and TS to values such that T*Time_Unit = SC*1.0 + TS*Time_Unit, and 0.0 <= TS*Time_Unit < 1.0. The value returned by Time_Of(SC,TS) is the value T such that T*Time_Unit = SC*1.0 + TS*Time_Unit.

    Implementation Requirements

  25. The range of Time values shall be sufficient to uniquely represent the range of real times from program start-up to 50 years later. Tick shall be no greater than 1 millisecond. Time_Unit shall be less than or equal to 20 microseconds.
  26. Time_Span_First shall be no greater than -3600 seconds, and Time_Span_Last shall be no less than 3600 seconds.
  27. A clock jump is the difference between two successive distinct values of the clock (as observed by calling the Clock function). There shall be no backward clock jumps.

    Documentation Requirements

  28. The implementation shall document the values of Time_First, Time_Last, Time_Span_First, Time_Span_Last, Time_Span_Unit, and Tick.
  29. The implementation shall document the properties of the underlying time base used for the clock and for type Time, such as the range of values supported and any relevant aspects of the underlying hardware or operating system facilities used.
  30. The implementation shall document whether or not there is any synchronization with external time references, and if such synchronization exists, the sources of synchronization information, the frequency of synchronization, and the synchronization method applied.
  31. The implementation shall document any aspects of the the external environment that could interfere with the clock behavior as defined in this clause.

    Metrics

  32. For the purpose of the metrics defined in this clause, real time is defined to be the International Atomic Time (TAI).
  33. The implementation shall document the following metrics: 
    1. An upper bound on the real-time duration of a clock tick. This is
a value D such that if t1 and t2 are any real times such that t1 <
t2 and Clock   = Clock   then t2 - t1 <= D.
            t1        t2
    2. An upper bound on the size of a clock jump.
    3. An upper bound on the drift rate of Clock with respect to real time. This is a real number D such that 
    4. E*(1-D) <= (Clock    - Clock ) <= E*(1+D)
                 t+E        t

provided that: Clock  + E*(1+D) <= Time_Last.
                    t

    5. where Clock  is the value of Clock at time t, and E is a real time
           t
time duration not less than 24 hours. The value of E used for this
metric shall be reported. @end format


    6. 

An upper bound on the execution time of a call to the Clock function, in
processor clock cycles.


    7. 

Upper bounds on the execution times of the operators of the types Time
and Time_Span, in processor clock cycles.

Implementation Permissions

  1. Implementations targeted to machines with word size smaller than 32 bits need not support the full range and granularity of the Time and Time_Span types.

    Implementation Advice

  2. When appropriate, implementations should provide configuration mechanisms to change the value of Tick.
  3. It is recommended that Calendar.Clock and Real_Time.Clock be implemented as transformations of the same time base.
  4. It is recommended that the "best" time base which exists in the underlying system be available to the application through Clock. "Best" may mean highest accuracy or largest range. NOTES
  5. (30) The rules in this clause do not imply that the implementation can protect the user from operator or installation errors which could result in the clock being set incorrectly.
  6. (31) Time_Unit is the granularity of the Time type. In contrast, Tick represents the granularity of Real_Time.Clock. There is no requirement that these be the same.

Delay Accuracy

  1. This clause specifies performance requirements for the delay_statement. The rules apply both to delay_relative_statement and to delay_until_statement. Similarly, they apply equally to a simple delay_statement and to one which appears in a delay_alternative.

    Dynamic Semantics

  2. The effect of the delay_statement for Real_Time.Time is defined in terms of Real_Time.Clock: 
    1. If C  is a value of Clock read before a task executes a
    1
delay_relative_statement with duration D, and C  is a value of Clock
                                               2
read after the task resumes execution following that delay_statement,
then C  - C  >= D.
      2    1
    2. If C is a value of Clock read after a task resumes execution following a delay_until_statement with Real_Time.Time value T, then C >= T.
  1. A simple delay_statement with a negative or zero value for the expiration time does not cause the calling task to be blocked; it is nevertheless a potentially blocking operation, see section Protected Subprograms and Protected Actions.
  2. When a delay_statement appears in a delay_alternative of a timed_entry_call the selection of the entry call is attempted, regardless of the specified expiration time. When a delay_statement appears in a selective_accept_alternative, and a call is queued on one of the open entries, the selection of that entry call proceeds, regardless of the value of the delay expression.

    Documentation Requirements

  3. The implementation shall document the minimum value of the delay expression of a delay_relative_statement that causes the task to actually be blocked.
  4. The implementation shall document the minimum difference between the value of the delay expression of a delay_until_statement and the value of Real_Time.Clock, that causes the task to actually be blocked.

    Metrics

  5. The implementation shall document the following metrics:
    1. An upper bound on the execution time, in processor clock cycles, of a delay_relative_statement whose requested value of the delay expression is less than or equal to zero.
    2. An upper bound on the execution time, in processor clock cycles, of a delay_until_statement whose requested value of the delay expression is less than or equal to the value of Real_Time.Clock at the time of executing the statement. Similarly, for Calendar.Clock.
    3. An upper bound on the lateness of a delay_relative_statement, for a positive value of the delay expression, in a situation where the task has sufficient priority to preempt the processor as soon as it becomes ready, and does not need to wait for any other execution resources. The upper bound is expressed as a function of the value of the delay expression. The lateness is obtained by subtracting the value of the delay expression from the actual duration. The actual duration is measured from a point immediately before a task executes the delay_statement to a point immediately after the task resumes execution following this statement.
    4. An upper bound on the lateness of a delay_until_statement, in a situation where the value of the requested expiration time is after the time the task begins executing the statement, the task has sufficient priority to preempt the processor as soon as it becomes ready, and it does not need to wait for any other execution resources. The upper bound is expressed as a function of the difference between the requested expiration time and the clock value at the time the statement begins execution. The lateness of a delay_until_statement is obtained by subtracting the requested expiration time from the real time that the task resumes execution following this statement.
    NOTES
  1. (32) The execution time of a delay_statement that does not cause the task to be blocked (e.g. "delay 0.0;" ) is of interest in situations where delays are used to achieve voluntary round-robin task dispatching among equal-priority tasks.

Synchronous Task Control

  1. This clause describes a language-defined private semaphore (suspension object), which can be used for two-stage suspend operations and as a simple building block for implementing higher-level queues.

    Static Semantics

  2. The following language-defined package exists: 
  3. package Ada.Synchronous_Task_Control is

  4.   type Suspension_Object is limited private;
  procedure Set_True(S : in out Suspension_Object);
  procedure Set_False(S : in out Suspension_Object);
  function Current_State(S : Suspension_Object) return Boolean;
  procedure Suspend_Until_True(S : in out Suspension_Object);
private
     ... -- not specified by the language
end Ada.Synchronous_Task_Control;
  5. The type Suspension_Object is a by-reference type.

    Dynamic Semantics

  6. An object of the type Suspension_Object has two visible states: true and false. Upon initialization, its value is set to false.
  7. The operations Set_True and Set_False are atomic with respect to each other and with respect to Suspend_Until_True; they set the state to true and false respectively.
  8. Current_State returns the current state of the object.
  9. The procedure Suspend_Until_True blocks the calling task until the state of the object S is true; at that point the task becomes ready and the state of the object becomes false.
  10. Program_Error is raised upon calling Suspend_Until_True if another task is already waiting on that suspension object. Suspend_Until_True is a potentially blocking operation, see section Protected Subprograms and Protected Actions.

    Implementation Requirements

  11. The implementation is required to allow the calling of Set_False and Set_True during any protected action, even one that has its ceiling priority in the Interrupt_Priority range.

Asynchronous Task Control

  1. This clause introduces a language-defined package to do asynchronous suspend/resume on tasks. It uses a conceptual held priority value to represent the task's held state.

    Static Semantics

  2. The following language-defined library package exists: 
  3. with Ada.Task_Identification;
package Ada.Asynchronous_Task_Control is
  procedure Hold(T : in Ada.Task_Identification.Task_ID);
  procedure Continue(T : in Ada.Task_Identification.Task_ID);
  function Is_Held(T : Ada.Task_Identification.Task_ID)
   return Boolean;
end Ada.Asynchronous_Task_Control;

    Dynamic Semantics

  4. After the Hold operation has been applied to a task, the task becomes held. For each processor there is a conceptual idle task, which is always ready. The base priority of the idle task is below System.Any_Priority'First. The held priority is a constant of the type integer whose value is below the base priority of the idle task.
  5. The Hold operation sets the state of T to held. For a held task: the task's own base priority does not constitute an inheritance source (see section Task Priorities) and the value of the held priority is defined to be such a source instead.
  6. The Continue operation resets the state of T to not-held; T's active priority is then reevaluated as described in D.1. This time, T's base priority is taken into account.
  7. The Is_Held function returns True if and only if T is in the held state.
  8. As part of these operations, a check is made that the task identified by T is not terminated. Tasking_Error is raised if the check fails. Program_Error is raised if the value of T is Null_Task_ID.

    Erroneous Execution

  9. If any operation in this package is called with a parameter T that specifies a task object that no longer exists, the execution of the program is erroneous.

    Implementation Permissions

  10. An implementation need not support Asynchronous_Task_Control if it is infeasible to support it in the target environment. NOTES
  11. (33) It is a consequence of the priority rules that held tasks cannot be dispatched on any processor in a partition (unless they are inheriting priorities) since their priorities are defined to be below the priority of any idle task.
  12. (34) The effect of calling Get_Priority and Set_Priority on a Held task is the same as on any other task.
  13. (35) Calling Hold on a held task or Continue on a non-held task has no effect.
  14. (36) The rules affecting queuing are derived from the above rules, in addition to the normal priority rules:
    1. When a held task is on the ready queue, its priority is so low as to never reach the top of the queue as long as there are other tasks on that queue.
    2. If a task is executing in a protected action, inside a rendezvous, or is inheriting priorities from other sources (e.g. when activated), it continues to execute until it is no longer executing the corresponding construct.
    3. If a task becomes held while waiting (as a caller) for a rendezvous to complete, the active priority of the accepting task is not affected.
    4. If a task becomes held while waiting in a selective_accept, and a entry call is issued to one of the open entries, the corresponding accept body executes. When the rendezvous completes, the active priority of the accepting task is lowered to the held priority (unless it is still inheriting from other sources), and the task does not execute until another Continue.
    5. The same holds if the held task is the only task on a protected entry queue whose barrier becomes open. The corresponding entry body executes.

Other Optimizations and Determinism Rules

  1. This clause describes various requirements for improving the response and determinism in a real-time system.

    Implementation Requirements

  2. If the implementation blocks interrupts, see section Interrupt Support, not as a result of direct user action (e.g. an execution of a protected action) there shall be an upper bound on the duration of this blocking.
  3. The implementation shall recognize entry-less protected types. The overhead of acquiring the execution resource of an object of such a type, see section Protected Subprograms and Protected Actions, shall be minimized. In particular, there should not be any overhead due to evaluating entry_barrier conditions.
  4. Unchecked_Deallocation shall be supported for terminated tasks that are designated by access types, and shall have the effect of releasing all the storage associated with the task. This includes any run-time system or heap storage that has been implicitly allocated for the task by the implementation.

    Documentation Requirements

  5. The implementation shall document the upper bound on the duration of interrupt blocking caused by the implementation. If this is different for different interrupts or interrupt priority levels, it should be documented for each case.

    Metrics

  6. The implementation shall document the following metric:
    1. The overhead associated with obtaining a mutual-exclusive access to an entry-less protected object. This shall be measured in the following way:
      1. For a protected object of the form: 
      2. protected Lock is
   procedure Set;
   function Read return Boolean;
private
   Flag : Boolean := False;
end Lock;

      3. protected body Lock is
   procedure Set is
   begin
      Flag := True;
   end Set;
   function Read return Boolean
   Begin
      return Flag;
   end Read;
end Lock;
      4. The execution time, in processor clock cycles, of a call to Set. This shall be measured between the point just before issuing the call, and the point just after the call completes. The function Read shall be called later to verify that Set was indeed called (and not optimized away). The calling task shall have sufficiently high priority as to not be preempted during the measurement period. The protected object shall have sufficiently high ceiling priority to allow the task to call Set.
      5. For a multiprocessor, if supported, the metric shall be reported for the case where no contention (on the execution resource) exists from tasks executing on other processors.

Distributed Systems (normative)

  1. This Annex defines facilities for supporting the implementation of distributed systems using multiple partitions working cooperatively as part of a single Ada program.

    Post-Compilation Rules

  2. A distributed system is an interconnection of one or more processing nodes (a system resource that has both computational and storage capabilities), and zero or more storage nodes (a system resource that has only storage capabilities, with the storage addressable by one or more processing nodes).
  3. A distributed program comprises one or more partitions that execute independently (except when they communicate) in a distributed system.
  4. The process of mapping the partitions of a program to the nodes in a distributed system is called configuring the partitions of the program.

    Implementation Requirements

  5. The implementation shall provide means for explicitly assigning library units to a partition and for the configuring and execution of a program consisting of multiple partitions on a distributed system; the means are implementation defined.

    Implementation Permissions

  6. An implementation may require that the set of processing nodes of a distributed system be homogeneous. NOTES
  7. (1) The partitions comprising a program may be executed on differently configured distributed systems or on a non-distributed system without requiring recompilation. A distributed program may be partitioned differently from the same set of library units without recompilation. The resulting execution is semantically equivalent.
  8. (2) A distributed program retains the same type safety as the equivalent single partition program.

Partitions

  1. The partitions of a distributed program are classified as either active or passive.

    Post-Compilation Rules

  2. An active partition is a partition as defined in section Program Execution. A passive partition is a partition that has no thread of control of its own, whose library units are all preelaborated, and whose data and subprograms are accessible to one or more active partitions.
  3. A passive partition shall include only library_items that either are declared pure or are shared passive, see section Elaboration Control, and section Shared Passive Library Units.
  4. An active partition shall be configured on a processing node. A passive partition shall be configured either on a storage node or on a processing node.
  5. The configuration of the partitions of a program onto a distributed system shall be consistent with the possibility for data references or calls between the partitions implied by their semantic dependences. Any reference to data or call of a subprogram across partitions is called a remote access.

    Dynamic Semantics

  6. A library_item is elaborated as part of the elaboration of each partition that includes it. If a normal library unit, see section Categorization of Library Units, has state, then a separate copy of the state exists in each active partition that elaborates it. The state evolves independently in each such partition.
  7. An active partition terminates when its environment task terminates. A partition becomes inaccessible if it terminates or if it is aborted. An active partition is aborted when its environment task is aborted. In addition, if a partition fails during its elaboration, it becomes inaccessible to other partitions. Other implementation-defined events can also result in a partition becoming inaccessible.
  8. For a prefix D that denotes a library-level declaration, excepting a declaration of or within a declared-pure library unit, the following attribute is defined:
  9. D'Partition_ID 
    Denotes a value of the type universal_integer that
identifies the partition in which D was elaborated. If D
denotes the declaration of a remote call interface
library unit, see section Remote Call Interface Library Units, the given partition is the
one where the body of D was elaborated.

    Bounded (Run-Time) Errors

  10. It is a bounded error for there to be cyclic elaboration dependences between the active partitions of a single distributed program. The possible effects are deadlock during elaboration, or the raising of Program_Error in one or all of the active partitions involved.

    Implementation Permissions

  11. An implementation may allow multiple active or passive partitions to be configured on a single processing node, and multiple passive partitions to be configured on a single storage node. In these cases, the scheduling policies, treatment of priorities, and management of shared resources between these partitions are implementation defined.
  12. An implementation may allow separate copies of an active partition to be configured on different processing nodes, and to provide appropriate interactions between the copies to present a consistent state of the partition to other active partitions.
  13. In an implementation, the partitions of a distributed program need not be loaded and elaborated all at the same time; they may be loaded and elaborated one at a time over an extended period of time. An implementation may provide facilities to abort and reload a partition during the execution of a distributed program.
  14. An implementation may allow the state of some of the partitions of a distributed program to persist while other partitions of the program terminate and are later reinvoked. NOTES
  15. (3) Library units are grouped into partitions after compile time, but before run time. At compile time, only the relevant library unit properties are identified using categorization pragmas.
  16. (4) The value returned by the Partition_ID attribute can be used as a parameter to implementation-provided subprograms in order to query information about the partition.

Categorization of Library Units

  1. Library units can be categorized according to the role they play in a distributed program. Certain restrictions are associated with each category to ensure that the semantics of a distributed program remain close to the semantics for a nondistributed program.
  2. A categorization pragma is a library unit pragma, see section Pragmas and Program Units, that restricts the declarations, child units, or semantic dependences of the library unit to which it applies. A categorized library unit is a library unit to which a categorization pragma applies.
  3. The pragmas Shared_Passive, Remote_Types, and Remote_Call_Interface are categorization pragmas. In addition, for the purposes of this Annex, the pragma Pure, see section Elaboration Control is considered a categorization pragma.
  4. A library package or generic library package is called a shared passive library unit if a Shared_Passive pragma applies to it. A library package or generic library package is called a remote types library unit if a Remote_Types pragma applies to it. A library package or generic library package is called a remote call interface if a Remote_Call_Interface pragma applies to it. A normal library unit is one to which no categorization pragma applies.
  5. The various categories of library units and the associated restrictions are described in this clause and its subclauses. The categories are related hierarchically in that the library units of one category can depend semantically only on library units of that category or an earlier one, except that the body of a remote types or remote call interface library unit is unrestricted.
  6. The overall hierarchy (including declared pure) is as follows:
  7. Declared Pure 
    Can depend only on other declared pure library units;
  8. Shared Passive 
    Can depend only on other shared passive or declared pure
library units;
  9. Remote Types 
    The declaration of the library unit can depend only on other
remote types library units, or one of the above; the body of
the library unit is unrestricted;
  10. Remote Call Interface 
    The declaration of the library unit can depend only on other
remote call interfaces, or one of the above; the body of the
library unit is unrestricted;
  11. Normal 
    Unrestricted.
  12. Declared pure and shared passive library units are preelaborated. The declaration of a remote types or remote call interface library unit is required to be preelaborable.

    Implementation Requirements

  13. For a given library-level type declared in a preelaborated library unit or in the declaration of a remote types or remote call interface library unit, the implementation shall choose the same representation for the type upon each elaboration of the type's declaration for different partitions of the same program.

    Implementation Permissions

  14. Implementations are allowed to define other categorization pragmas.

Shared Passive Library Units

  1. A shared passive library unit is used for managing global data shared between active partitions. The restrictions on shared passive library units prevent the data or tasks of one active partition from being accessible to another active partition through references implicit in objects declared in the shared passive library unit.

    Syntax

  2. The form of a pragma Shared_Passive is as follows: 
  3. pragma Shared_Passive[(library_unit_name)];

    Legality Rules

  4. A shared passive library unit is a library unit to which a Shared_Passive pragma applies. The following restrictions apply to such a library unit:
    1. it shall be preelaborable, see section Elaboration Control,
    2. it shall depend semantically only upon declared pure or shared passive library units;
    3. it shall not contain a library-level declaration of an access type that designates a class-wide type, task type, or protected type with entry_declarations; if the shared passive library unit is generic, it shall not contain a declaration for such an access type unless the declaration is nested within a body other than a package_body.
  1. Notwithstanding the definition of accessibility given in section Operations of Access Types, the declaration of a library unit P1 is not accessible from within the declarative region of a shared passive library unit P2, unless the shared passive library unit P2 depends semantically on P1.

    Static Semantics

  2. A shared passive library unit is preelaborated.

    Compilation Rules

  3. A shared passive library unit shall be assigned to at most one partition within a given program.
  4. Notwithstanding the rule given in section Program Execution, a compilation unit in a given partition does not need (in the sense of section Program Execution.) the shared passive library units on which it depends semantically to be included in that same partition; they will typically reside in separate passive partitions.

Remote Types Library Units

  1. A remote types library unit supports the definition of types intended for use in communication between active partitions.

    Syntax

  2. The form of a pragma Remote_Types is as follows: 
  3. pragma Remote_Types[(library_unit_name)];

    Legality Rules

  4. A remote types library unit is a library unit to which the pragma Remote_Types applies. The following restrictions apply to the declaration of such a library unit:
    1. it shall be preelaborable;
    2. it shall depend semantically only on declared pure, shared passive, or other remote types library units;
    3. it shall not contain the declaration of any variable within the visible part of the library unit;
    4. if the full view of a type declared in the visible part of the library unit has a part that is of a non-remote access type, then that access type, or the type of some part that includes the access type subcomponent, shall have user-specified Read and Write attributes.
  1. An access type declared in the visible part of a remote types or remote call interface library unit is called a remote access type. Such a type shall be either an access-to-subprogram type or a general access type that designates a class-wide limited private type.
  2. The following restrictions apply to the use of a remote access-to-subprogram type:
    1. A value of a remote access-to-subprogram type shall be converted only to another (subtype-conformant) remote access-to-subprogram type;
    2. The prefix of an Access attribute_reference that yields a value of a remote access-to-subprogram type shall statically denote a (subtype-conformant) remote subprogram.
  1. The following restrictions apply to the use of a remote access-to-class-wide type:
    1. The primitive subprograms of the corresponding specific limited private type shall only have access parameters if they are controlling formal parameters; the types of all the non-controlling formal parameters shall have Read and Write attributes.
    2. A value of a remote access-to-class-wide type shall be explicitly converted only to another remote access-to-class-wide type;
    3. A value of a remote access-to-class-wide type shall be dereferenced (or implicitly converted to an anonymous access type) only as part of a dispatching call where the value designates a controlling operand of the call, see section Remote Subprogram Calls,
    4. The Storage_Pool and Storage_Size attributes are not defined for remote access-to-class-wide types; the expected type for an allocator shall not be a remote access-to-class-wide type; a remote access-to-class-wide type shall not be an actual parameter for a generic formal access type;
    NOTES
  1. (5) A remote types library unit need not be pure, and the types it defines may include levels of indirection implemented by using access types. User-specified Read and Write attributes, see section Stream-Oriented Attributes provide for sending values of such a type between active partitions, with Write marshalling the representation, and Read unmarshalling any levels of indirection.

Remote Call Interface Library Units

  1. A remote call interface library unit can be used as an interface for remote procedure calls (RPCs) (or remote function calls) between active partitions.

    Syntax

  2. The form of a pragma Remote_Call_Interface is as follows: 
  3. pragma Remote_Call_Interface[(library_unit_name)];
  4. The form of a pragma All_Calls_Remote is as follows: 
  5. pragma All_Calls_Remote[(library_unit_name)];
    1. A pragma All_Calls_Remote is a library unit pragma.

Legality Rules

  1. A remote call interface (RCI) is a library unit to which the pragma Remote_Call_Interface applies. A subprogram declared in the visible part of such a library unit is called a remote subprogram.
  2. The declaration of an RCI library unit shall be preelaborable (see section Elaboration Control) and shall depend semantically only upon declared pure, shared passive, remote types, or other remote call interface library units.
  3. In addition, the following restrictions apply to the visible part of an RCI library unit:
    1. it shall not contain the declaration of a variable;
    2. it shall not contain the declaration of a limited type;
    3. it shall not contain a nested generic_declaration;
    4. it shall not contain the declaration of a subprogram to which a pragma Inline applies;
    5. it shall not contain a subprogram (or access-to-subprogram) declaration whose profile has an access parameter, or a formal parameter of a limited type unless that limited type has user-specified Read and Write attributes;
    6. any public child of the library unit shall be a remote call interface library unit.
  1. If a pragma All_Calls_Remote applies to a library unit, the library unit shall be a remote call interface.

    Post-Compilation Rules

  2. A remote call interface library unit shall be assigned to at most one partition of a given program. A remote call interface library unit whose parent is also an RCI library unit shall be assigned only to the same partition as its parent.
  3. Notwithstanding the rule given in section Program Execution, a compilation unit in a given partition that semantically depends on the declaration of an RCI library unit, needs (in the sense of section Program Execution.) only the declaration of the RCI library unit, not the body, to be included in that same partition. Therefore, the body of an RCI library unit is included only in the partition to which the RCI library unit is explicitly assigned.

    Implementation Requirements

  4. If a pragma All_Calls_Remote applies to a given RCI library package, then the implementation shall route any call to a subprogram of the RCI package from outside the declarative region of the package through the Partition Communication Subsystem (PCS); see section Partition Communication Subsystem. Calls to such subprograms from within the declarative region of the package are defined to be local and shall not go through the PCS.

    Implementation Permissions

  5. An implementation need not support the Remote_Call_Interface pragma nor the All_Calls_Remote pragma. Explicit message-based communication between active partitions can be supported as an alternative to RPC.

Consistency of a Distributed System

  1. This clause defines attributes and rules associated with verifying the consistency of a distributed program.

    Static Semantics

  2. For a prefix P that statically denotes a program unit, the following attributes are defined:
  3. P'Version 
    Yields a value of the predefined type String that identifies
the version of the compilation unit that contains the
declaration of the program unit.
  4. P'Body_Version 
    Yields a value of the predefined type String that identifies
the version of the compilation unit that contains the body
(but not any subunits) of the program unit.
  5. The version of a compilation unit changes whenever the version changes for any compilation unit on which it depends semantically. The version also changes whenever the compilation unit itself changes in a semantically significant way. It is implementation defined whether there are other events (such as recompilation) that result in the version of a compilation unit changing.

    Bounded (Run-Time) Errors

  6. In a distributed program, a library unit is consistent if the same version of its declaration is used throughout. It is a bounded error to elaborate a partition of a distributed program that contains a compilation unit that depends on a different version of the declaration of a shared passive or RCI library unit than that included in the partition to which the shared passive or RCI library unit was assigned. As a result of this error, Program_Error can be raised in one or both partitions during elaboration; in any case, the partitions become inaccessible to one another.

Remote Subprogram Calls

  1. A remote subprogram call is a subprogram call that invokes the execution of a subprogram in another partition. The partition that originates the remote subprogram call is the calling partition, and the partition that executes the corresponding subprogram body is the called partition. Some remote procedure calls are allowed to return prior to the completion of subprogram execution. These are called asynchronous remote procedure calls.
  2. There are three different ways of performing a remote subprogram call:
    1. As a direct call on a (remote) subprogram explicitly declared in a remote call interface;
    2. As an indirect call through a value of a remote access-to-subprogram type;
    3. As a dispatching call with a controlling operand designated by a value of a remote access-to-class-wide type.
  1. The first way of calling corresponds to a static binding between the calling and the called partition. The latter two ways correspond to a dynamic binding between the calling and the called partition.
  2. A remote call interface library unit, see section Remote Call Interface Library Units, defines the remote subprograms or remote access types used for remote subprogram calls.

    Legality Rules

  3. In a dispatching call with two or more controlling operands, if one controlling operand is designated by a value of a remote access-to-class-wide type, then all shall be.

    Dynamic Semantics

  4. For the execution of a remote subprogram call, subprogram parameters (and later the results, if any) are passed using a stream-oriented representation, see section The Package Streams, which is suitable for transmission between partitions. This action is called marshalling. Unmarshalling is the reverse action of reconstructing the parameters or results from the stream-oriented representation. Marshalling is performed initially as part of the remote subprogram call in the calling partition; unmarshalling is done in the called partition. After the remote subprogram completes, marshalling is performed in the called partition, and finally unmarshalling is done in the calling partition.
  5. A calling stub is the sequence of code that replaces the subprogram body of a remotely called subprogram in the calling partition. A receiving stub is the sequence of code (the "wrapper") that receives a remote subprogram call on the called partition and invokes the appropriate subprogram body.
  6. Remote subprogram calls are executed at most once, that is, if the subprogram call returns normally, then the called subprogram's body was executed exactly once.
  7. The task executing a remote subprogram call blocks until the subprogram in the called partition returns, unless the call is asynchronous. For an asynchronous remote procedure call, the calling task can become ready before the procedure in the called partition returns.
  8. If a construct containing a remote call is aborted, the remote subprogram call is cancelled. Whether the execution of the remote subprogram is immediately aborted as a result of the cancellation is implementation defined.
  9. If a remote subprogram call is received by a called partition before the partition has completed its elaboration, the call is kept pending until the called partition completes its elaboration (unless the call is cancelled by the calling partition prior to that).
  10. If an exception is propagated by a remotely called subprogram, and the call is not an asynchronous call, the corresponding exception is reraised at the point of the remote subprogram call. For an asynchronous call, if the remote procedure call returns prior to the completion of the remotely called subprogram, any exception is lost.
  11. The exception Communication_Error, see section Partition Communication Subsystem is raised if a remote call cannot be completed due to difficulties in communicating with the called partition.
  12. All forms of remote subprogram calls are potentially blocking operations, see section Protected Subprograms and Protected Actions.
  13. In a remote subprogram call with a formal parameter of a class-wide type, a check is made that the tag of the actual parameter identifies a tagged type declared in a declared-pure or shared passive library unit, or in the visible part of a remote types or remote call interface library unit. Program_Error is raised if this check fails.
  14. In a dispatching call with two or more controlling operands that are designated by values of a remote access-to-class-wide type, a check is made (in addition to the normal Tag_Check -- see section Suppressing Checks.) that all the remote access-to-class-wide values originated from Access attribute_references that were evaluated by tasks of the same active partition. Constraint_Error is raised if this check fails.

    Implementation Requirements

  15. The implementation of remote subprogram calls shall conform to the PCS interface as defined by the specification of the language-defined package System.RPC, see section Partition Communication Subsystem. The calling stub shall use the Do_RPC procedure unless the remote procedure call is asynchronous in which case Do_APC shall be used. On the receiving side, the corresponding receiving stub shall be invoked by the RPC-receiver. NOTES
  16. (6) A given active partition can both make and receive remote subprogram calls. Thus, an active partition can act as both a client and a server.
  17. (7) If a given exception is propagated by a remote subprogram call, but the exception does not exist in the calling partition, the exception can be handled by an others choice or be propagated to and handled by a third partition.

Pragma Asynchronous

  1. This subclause introduces the pragma Asynchronous which allows a remote subprogram call to return prior to completion of the execution of the corresponding remote subprogram body.

    Syntax

  2. The form of a pragma Asynchronous is as follows: 
  3. pragma Asynchronous(local_name);

    Legality Rules

  4. The local_name of a pragma Asynchronous shall denote either:
    1. One or more remote procedures; the formal parameters of the procedure(s) shall all be of mode in;
    2. The first subtype of a remote access-to-procedure type; the formal parameters of the designated profile of the type shall all be of mode in;
    3. The first subtype of a remote access-to-class-wide type.

Static Semantics

  1. A pragma Asynchronous is a representation pragma. When applied to a type, it specifies the type-related asynchronous aspect of the type.

    Dynamic Semantics

  2. A remote call is asynchronous if it is a call to a procedure, or a call through a value of an access-to-procedure type, to which a pragma Asynchronous applies. In addition, if a pragma Asynchronous applies to a remote access-to-class-wide type, then a dispatching call on a procedure with a controlling operand designated by a value of the type is asynchronous if the formal parameters of the procedure are all of mode in.

    Implementation Requirements

  3. Asynchronous remote procedure calls shall be implemented such that the corresponding body executes at most once as a result of the call.

Example of Use of a Remote Access-to-Class-Wide Type

Examples

  1. Example of using a remote access-to-class-wide type to achieve dynamic binding across active partitions: 
  2. package Tapes is
   pragma Pure(Tapes);
   type Tape is abstract tagged limited private;
   -- Primitive dispatching operations where
   -- Tape is controlling operand
   procedure Copy (From, To : access Tape;
                   Num_Recs : in Natural) is abstract;
   procedure Rewind (T : access Tape) is abstract;
   -- More operations
private
   type Tape is ...
end Tapes;

  3. with Tapes;
package Name_Server is
   pragma Remote_Call_Interface;
   -- Dynamic binding to remote operations is achieved
   -- using the access-to-limited-class-wide type Tape_Ptr
   type Tape_Ptr is access all Tapes.Tape'Class;
   -- The following statically bound remote operations
   -- allow for a name-server capability in this example
   function  Find     (Name : String) return Tape_Ptr;
   procedure Register (Name : in String; T : in Tape_Ptr);
   procedure Remove   (T : in Tape_Ptr);
   -- More operations
end Name_Server;

  4. package Tape_Driver is
  -- Declarations are not shown, they are irrelevant here
end Tape_Driver;

  5. with Tapes, Name_Server;
package body Tape_Driver is
   type New_Tape is new Tapes.Tape with ...
   procedure Copy
    (From, To : access New_Tape; Num_Recs: in Natural) is
   begin
     . . .
   end Copy;
   procedure Rewind (T : access New_Tape) is
   begin
      . . .
   end Rewind;
   -- Objects remotely accessible through use
   -- of Name_Server operations
   Tape1, Tape2 : aliased New_Tape;
begin
   Name_Server.Register ("NINE-TRACK",  Tape1'Access);
   Name_Server.Register ("SEVEN-TRACK", Tape2'Access);
end Tape_Driver;

  6. with Tapes, Name_Server;
-- Tape_Driver is not needed
-- and thus not mentioned in the with_clause
procedure Tape_Client is
   T1, T2 : Name_Server.Tape_Ptr;
begin
   T1 := Name_Server.Find ("NINE-TRACK");
   T2 := Name_Server.Find ("SEVEN-TRACK");
   Tapes.Rewind (T1);
   Tapes.Rewind (T2);
   Tapes.Copy (T1, T2, 3);
end Tape_Client;
  7. Notes on the example:
    1. The package Tapes provides the necessary declarations of the type and its primitive operations.
    2. Name_Server is a remote call interface package and is elaborated in a separate active partition to provide the necessary naming services (such as Register and Find) to the entire distributed program through remote subprogram calls.
    3. Tape_Driver is a normal package that is elaborated in a partition configured on the processing node that is connected to the tape device(s). The abstract operations are overridden to support the locally declared tape devices (Tape1, Tape2). The package is not visible to its clients, but it exports the tape devices (as remote objects) through the services of the Name_Server. This allows for tape devices to be dynamically added, removed or replaced without requiring the modification of the clients' code.
    4. The Tape_Client procedure references only declarations in the Tapes and Name_Server packages. Before using a tape for the first time, it needs to query the Name_Server for a system-wide identity for that tape. From then on, it can use that identity to access the tape device.
    5. Values of remote access type Tape_Ptr include the necessary information to complete the remote dispatching operations that result from dereferencing the controlling operands T1 and T2.

Partition Communication Subsystem

  1. The Partition Communication Subsystem (PCS) provides facilities for supporting communication between the active partitions of a distributed program. The package System.RPC is a language-defined interface to the PCS. An implementation conforming to this Annex shall use the RPC interface to implement remote subprogram calls.

    Static Semantics

  2. The following language-defined library package exists: 
  3. with Ada.Streams; --  see section The Package Streams.
package System.RPC is

  4.    type Partition_ID is range 0 .. implementation-defined;

  5.    Communication_Error : exception;

  6.    type Params_Stream_Type(
      Initial_Size : Ada.Streams.Stream_Element_Count) is new
      Ada.Streams.Root_Stream_Type with private;

  7.    procedure Read(
      Stream : in out Params_Stream_Type;
      Item : out Ada.Streams.Stream_Element_Array;
      Last : out Ada.Streams.Stream_Element_Offset);

  8.    procedure Write(
      Stream : in out Params_Stream_Type;
      Item : in Ada.Streams.Stream_Element_Array);

  9.    -- Synchronous call
   procedure Do_RPC(
      Partition  : in Partition_ID;
      Params     : access Params_Stream_Type;
      Result     : access Params_Stream_Type);

  10.    -- Asynchronous call
   procedure Do_APC(
      Partition  : in Partition_ID;
      Params     : access Params_Stream_Type);

  11.    -- The handler for incoming RPCs
   type RPC_Receiver is access procedure(
      Params     : access Params_Stream_Type;
      Result     : access Params_Stream_Type);

  12.    procedure Establish_RPC_Receiver(
      Partition : in Partition_ID;
      Receiver  : in RPC_Receiver);

  13. private
   ... -- not specified by the language
end System.RPC;
  14. A value of the type Partition_ID is used to identify a partition.
  15. An object of the type Params_Stream_Type is used for identifying the particular remote subprogram that is being called, as well as marshalling and unmarshalling the parameters or result of a remote subprogram call, as part of sending them between partitions.
  16. The Read and Write procedures override the corresponding abstract operations for the type Params_Stream_Type.

    Dynamic Semantics

  17. The Do_RPC and Do_APC procedures send a message to the active partition identified by the Partition parameter.
  18. After sending the message, Do_RPC blocks the calling task until a reply message comes back from the called partition or some error is detected by the underlying communication system in which case Communication_Error is raised at the point of the call to Do_RPC.
  19. Do_APC operates in the same way as Do_RPC except that it is allowed to return immediately after sending the message.
  20. Upon normal return, the stream designated by the Result parameter of Do_RPC contains the reply message.
  21. The procedure System.RPC.Establish_RPC_Receiver is called once, immediately after elaborating the library units of an active partition (that is, right after the elaboration of the partition) if the partition includes an RCI library unit, but prior to invoking the main subprogram, if any. The Partition parameter is the Partition_ID of the active partition being elaborated. The Receiver parameter designates an implementation-provided procedure called the RPC-receiver which will handle all RPCs received by the partition from the PCS. Establish_RPC_Receiver saves a reference to the RPC-receiver; when a message is received at the called partition, the RPC-receiver is called with the Params stream containing the message. When the RPC-receiver returns, the contents of the stream designated by Result is placed in a message and sent back to the calling partition.
  22. If a call on Do_RPC is aborted, a cancellation message is sent to the called partition, to request that the execution of the remotely called subprogram be aborted.
  23. The subprograms declared in System.RPC are potentially blocking operations.

    Implementation Requirements

  24. The implementation of the RPC-receiver shall be reentrant, thereby allowing concurrent calls on it from the PCS to service concurrent remote subprogram calls into the partition.

    Documentation Requirements

  25. The implementation of the PCS shall document whether the RPC-receiver is invoked from concurrent tasks. If there is an upper limit on the number of such tasks, this limit shall be documented as well, together with the mechanisms to configure it (if this is supported).

    Implementation Permissions

  26. The PCS is allowed to contain implementation-defined interfaces for explicit message passing, broadcasting, etc. Similarly, it is allowed to provide additional interfaces to query the state of some remote partition (given its partition ID) or of the PCS itself, to set timeouts and retry parameters, to get more detailed error status, etc. These additional interfaces should be provided in child packages of System.RPC.
  27. A body for the package System.RPC need not be supplied by the implementation.

    Implementation Advice

  28. Whenever possible, the PCS on the called partition should allow for multiple tasks to call the RPC-receiver with different messages and should allow them to block until the corresponding subprogram body returns.
  29. The Write operation on a stream of type Params_Stream_Type should raise Storage_Error if it runs out of space trying to write the Item into the stream. NOTES
  30. (8) The package System.RPC is not designed for direct calls by user programs. It is instead designed for use in the implementation of remote subprograms calls, being called by the calling stubs generated for a remote call interface library unit to initiate a remote call, and in turn calling back to an RPC-receiver that dispatches to the receiving stubs generated for the body of a remote call interface, to handle a remote call received from elsewhere.

Information Systems (normative)

  1. This Annex provides a set of facilities relevant to Information Systems programming. These fall into several categories:
    1. an attribute definition clause specifying Machine_Radix for a decimal subtype;
    2. the package Decimal, which declares a set of constants defining the implementation's capacity for decimal types, and a generic procedure for decimal division; and
    3. the child packages Text_IO.Editing and Wide_Text_IO.Editing, which support formatted and localized output of decimal data, based on "picture String" values.
  1. See also: section Fixed Point Types, section Operations of Fixed Point Types, section Type Conversions, See section Representation Attributes, section Input-Output for Real Types, section Interfacing with COBOL, section Interfacing with C, and section Numerics (normative).
  2. The character and string handling packages in section Predefined Language Environment (normative), are also relevant for Information Systems.

    Implementation Advice

  3. If COBOL (respectively, C) is widely supported in the target environment, implementations supporting the Information Systems Annex should provide the child package Interfaces.COBOL (respectively, Interfaces.C) specified in Annex B and should support a convention_identifier of COBOL (respectively, C) in the interfacing pragmas, see section Interface to Other Languages (normative), thus allowing Ada programs to interface with programs written in that language.

Machine_Radix Attribute Definition Clause

Static Semantics

  1. Machine_Radix may be specified for a decimal first subtype (see section Fixed Point Types) via an attribute_definition_clause; the expression of such a clause shall be static, and its value shall be 2 or 10. A value of 2 implies a binary base range; a value of 10 implies a decimal base range.

    Implementation Advice

  2. Packed decimal should be used as the internal representation for objects of subtype S when S'Machine_Radix = 10.

    Examples

  3. Example of Machine_Radix attribute definition clause: 
  4. type Money is delta 0.01 digits 15;
for Money'Machine_Radix use 10;

The Package Decimal

Static Semantics

  1. The library package Decimal has the following declaration: 
  2. package Ada.Decimal is
   pragma Pure(Decimal);

  3.    Max_Scale : constant := implementation-defined;
   Min_Scale : constant := implementation-defined;

  4.    Min_Delta : constant := 10.0**(-Max_Scale);
   Max_Delta : constant := 10.0**(-Min_Scale);

  5.    Max_Decimal_Digits : constant := implementation-defined;

  6.    generic
      type Dividend_Type  is delta <> digits <>;
      type Divisor_Type   is delta <> digits <>;
      type Quotient_Type  is delta <> digits <>;
      type Remainder_Type is delta <> digits <>;
   procedure Divide (Dividend  : in Dividend_Type;
                     Divisor   : in Divisor_Type;
                     Quotient  : out Quotient_Type;
                     Remainder : out Remainder_Type);
   pragma Convention(Intrinsic, Divide);

  7. end Ada.Decimal;
  8. Max_Scale is the largest N such that 10.0**(-N) is allowed as a decimal type's delta. Its type is universal_integer.
  9. Min_Scale is the smallest N such that 10.0**(-N) is allowed as a decimal type's delta. Its type is universal_integer.
  10. Min_Delta is the smallest value allowed for delta in a decimal_fixed_point_definition. Its type is universal_real.
  11. Max_Delta is the largest value allowed for delta in a decimal_fixed_point_definition. Its type is universal_real.
  12. Max_Decimal_Digits is the largest value allowed for digits in a decimal_fixed_point_definition. Its type is universal_integer.

    Static Semantics

  13. The effect of Divide is as follows. The value of Quotient is Quotient_Type(Dividend/Divisor). The value of Remainder is Remainder_Type(Intermediate), where Intermediate is the difference between Dividend and the product of Divisor and Quotient; this result is computed exactly.

    Implementation Requirements

  14. Decimal.Max_Decimal_Digits shall be at least 18.
  15. Decimal.Max_Scale shall be at least 18.
  16. Decimal.Min_Scale shall be at most 0. NOTES
  17. (1) The effect of division yielding a quotient with control over rounding versus truncation is obtained by applying either the function attribute Quotient_Type'Round or the conversion Quotient_Type to the expression Dividend/Divisor.

Edited Output for Decimal Types

  1. The child packages Text_IO.Editing and Wide_Text_IO.Editing provide localizable formatted text output, known as edited output , for decimal types. An edited output string is a function of a numeric value, program-specifiable locale elements, and a format control value. The numeric value is of some decimal type. The locale elements are:
    1. the currency string;
    2. the digits group separator character;
    3. the radix mark character; and
    4. the fill character that replaces leading zeros of the numeric value.
  1. For Text_IO.Editing the edited output and currency strings are of type String, and the locale characters are of type Character. For Wide_Text_IO.Editing their types are Wide_String and Wide_Character, respectively.
  2. Each of the locale elements has a default value that can be replaced or explicitly overridden.
  3. A format-control value is of the private type Picture; it determines the composition of the edited output string and controls the form and placement of the sign, the position of the locale elements and the decimal digits, the presence or absence of a radix mark, suppression of leading zeros, and insertion of particular character values.
  4. A Picture object is composed from a String value, known as a picture String, that serves as a template for the edited output string, and a Boolean value that controls whether a string of all space characters is produced when the number's value is zero. A picture String comprises a sequence of one- or two-Character symbols, each serving as a placeholder for a character or string at a corresponding position in the edited output string. The picture String symbols fall into several categories based on their effect on the edited output string: 
  5. Decimal Digit:      '9'
Radix Control:      '.'  'V'
Sign Control:       '+'  '-'  '<'  '>'  "CR"  "DB"
Currency Control:   '$'  '#'
Zero Suppression:   'Z'  '*'
Simple Insertion:   '_'  'B'  '0'  '/'
  6. The entries are not case-sensitive. Mixed- or lower-case forms for "CR" and "DB", and lower-case forms for 'V', 'Z', and 'B', have the same effect as the upper-case symbols shown.
  7. An occurrence of a '9' Character in the picture String represents a decimal digit position in the edited output string.
  8. A radix control Character in the picture String indicates the position of the radix mark in the edited output string: an actual character position for '.', or an assumed position for 'V'.
  9. A sign control Character in the picture String affects the form of the sign in the edited output string. The '<' and '>' Character values indicate parentheses for negative values. A Character '+', '-', or '<' appears either singly, signifying a fixed-position sign in the edited output, or repeated, signifying a floating-position sign that is preceded by zero or more space characters and that replaces a leading 0.
  10. A currency control Character in the picture String indicates an occurrence of the currency string in the edited output string. The '$' Character represents the complete currency string; the '#' Character represents one character of the currency string. A '$' Character appears either singly, indicating a fixed-position currency string in the edited output, or repeated, indicating a floating-position currency string that occurs in place of a leading 0. A sequence of '#' Character values indicates either a fixed- or floating-position currency string, depending on context.
  11. A zero suppression Character in the picture String allows a leading zero to be replaced by either the space character (for 'Z') or the fill character (for '*').
  12. A simple insertion Character in the picture String represents, in general, either itself (if '/' or '0'), the space character (if 'B'), or the digits group separator character (if '_'). In some contexts it is treated as part of a floating sign, floating currency, or zero suppression string.
  13. An example of a picture String is "<###Z_ZZ9.99>". If the currency string is "FF", the separator character is ',', and the radix mark is '.' then the edited output string values for the decimal values 32.10 and -5432.10 are "bbFFbbb32.10b" and "(bFF5,432.10)", respectively, where 'b' indicates the space character.
  14. The generic packages Text_IO.Decimal_IO and Wide_Text_IO.Decimal_IO (see section Input-Output for Real Types) provide text input and non-edited text output for decimal types. NOTES
  15. (2) A picture String is of type Standard.String, both for Text_IO.Editing and Wide_Text_IO.Editing.

Picture String Formation

  1. A well-formed picture String, or simply picture String, is a String value that conforms to the syntactic rules, composition constraints, and character replication conventions specified in this clause.

Dynamic Semantics 

  1. picture_string ::=
   fixed_$_picture_string
 | fixed_#_picture_string
 | floating_currency_picture_string
 | non_currency_picture_string

  2. fixed_$_picture_string ::=
   [fixed_LHS_sign] fixed_$_char {direct_insertion}
     [zero_suppression] number [RHS_sign]

 | [fixed_LHS_sign {direct_insertion}] [zero_suppression]
     number fixed_$_char {direct_insertion} [RHS_sign]

 | floating_LHS_sign number fixed_$_char {direct_insertion}
     [RHS_sign]

 | [fixed_LHS_sign] fixed_$_char {direct_insertion}
     all_zero_suppression_number {direct_insertion}  [RHS_sign]

 | [fixed_LHS_sign {direct_insertion}] all_zero_suppression_number
     {direct_insertion} fixed_$_char {direct_insertion}
     [RHS_sign]

 | all_sign_number {direct_insertion} fixed_$_char
     {direct_insertion} [RHS_sign]

  3. fixed_#_picture_string ::=
   [fixed_LHS_sign] single_#_currency {direct_insertion}
     [zero_suppression] number [RHS_sign]

 | [fixed_LHS_sign] multiple_#_currency {direct_insertion}
     zero_suppression number [RHS_sign]

 | [fixed_LHS_sign {direct_insertion}] [zero_suppression]
     number fixed_#_currency {direct_insertion} [RHS_sign]

 | floating_LHS_sign number fixed_#_currency {direct_insertion}
     [RHS_sign]

 | [fixed_LHS_sign] single_#_currency {direct_insertion}
     all_zero_suppression_number {direct_insertion} [RHS_sign]

 | [fixed_LHS_sign] multiple_#_currency {direct_insertion}
     all_zero_suppression_number {direct_insertion} [RHS_sign]

 | [fixed_LHS_sign {direct_insertion}] all_zero_suppression_number
     {direct_insertion} fixed_#_currency {direct_insertion}
     [RHS_sign]

 | all_sign_number {direct_insertion} fixed_#_currency
     {direct_insertion} [RHS_sign]

  4. floating_currency_picture_string ::=
   [fixed_LHS_sign] {direct_insertion} floating_$_currency
     number [RHS_sign]
 | [fixed_LHS_sign] {direct_insertion} floating_#_currency
     number [RHS_sign]
 | [fixed_LHS_sign] {direct_insertion} all_currency_number
     {direct_insertion} [RHS_sign]

  5. non_currency_picture_string ::=
   [fixed_LHS_sign {direct_insertion}] zero_suppression
     number [RHS_sign]
 | [floating_LHS_sign]
     number [RHS_sign]
 | [fixed_LHS_sign {direct_insertion}]
   all_zero_suppression_number {direct_insertion} [RHS_sign]
 | all_sign_number {direct_insertion}
 | fixed_LHS_sign direct_insertion {direct_insertion}
     number [RHS_sign]

  6. fixed_LHS_sign ::=  LHS_Sign

  7. LHS_Sign ::=  + | - | <

  8. fixed_$_char ::= $

  9. direct_insertion ::=  simple_insertion

  10. simple_insertion ::=  _ | B | 0 | /

  11. zero_suppression ::=  Z {Z
                      | context_sensitive_insertion}
                      | fill_string

  12. context_sensitive_insertion ::=  simple_insertion

  13. fill_string ::=  * {* | context_sensitive_insertion}

  14. number ::=
   fore_digits [radix [aft_digits] {direct_insertion}]
 | radix aft_digits {direct_insertion}

  15. fore_digits ::= 9 {9 | direct_insertion}

  16. aft_digits ::=  {9 | direct_insertion} 9

  17. radix ::= . | V

  18. RHS_sign ::= + | - | > | CR | DB

  19. floating_LHS_sign ::=
   LHS_Sign {context_sensitive_insertion} LHS_Sign
     {LHS_Sign | context_sensitive_insertion}

  20. single_#_currency ::= #

  21. multiple_#_currency ::= ## {#}

  22. fixed_#_currency ::= single_#_currency | multiple_#_currency

  23. floating_$_currency ::=
   $ {context_sensitive_insertion} $ {$
   | context_sensitive_insertion}

  24. floating_#_currency ::=
   # {context_sensitive_insertion} # {#
   | context_sensitive_insertion}

  25. all_sign_number ::=  all_sign_fore [radix [all_sign_aft]] [>]

  26. all_sign_fore ::=
   sign_char {context_sensitive_insertion} sign_char {sign_char
   | context_sensitive_insertion}

  27. all_sign_aft ::= {all_sign_aft_char} sign_char

all_sign_aft_char ::=  sign_char | context_sensitive_insertion

  28. sign_char ::= + | - | <

  29. all_currency_number ::=  all_currency_fore
  [radix [all_currency_aft]]

  30. all_currency_fore ::=
   currency_char {context_sensitive_insertion}
     currency_char {currency_char | context_sensitive_insertion}

  31. all_currency_aft ::= {all_currency_aft_char} currency_char

all_currency_aft_char ::= currency_char
                          | context_sensitive_insertion

  32. currency_char ::= $ | #

  33. all_zero_suppression_number ::=  all_zero_suppression_fore
  [ radix [all_zero_suppression_aft]]

  34. all_zero_suppression_fore ::=
   zero_suppression_char {zero_suppression_char
   | context_sensitive_insertion}

  35. all_zero_suppression_aft ::= {all_zero_suppression_aft_char}
  zero_suppression_char

all_zero_suppression_aft_char ::=  zero_suppression_char
                                   | context_sensitive_insertion

  36. zero_suppression_char ::= Z | *
  37. The following composition constraints apply to a picture String:
    1. A floating_LHS_sign does not have occurrences of different LHS_Sign Character values.
    2. If a picture String has '<' as fixed_LHS_sign, then it has '>' as RHS_sign.
    3. If a picture String has '<' in a floating_LHS_sign or in an all_sign_number, then it has an occurrence of '>'.
    4. If a picture String has '+' or '-' as fixed_LHS_sign, in a floating_LHS_sign, or in an all_sign_number, then it has no RHS_sign.
    5. An instance of all_sign_number does not have occurrences of different sign_char Character values.
    6. An instance of all_currency_number does not have occurrences of different currency_char Character values.
    7. An instance of all_zero_suppression_number does not have occurrences of different zero_suppression_char Character values, except for possible case differences between 'Z' and 'z'.
  1. A replicable Character is a Character that, by the above rules, can occur in two consecutive positions in a picture String.
  2. A Character replication is a String 
  3. char & '(' & spaces & count_string & ')'
  4. where char is a replicable Character, spaces is a String (possibly empty) comprising only space Character values, and count_string is a String of one or more decimal digit Character values. A Character replication in a picture String has the same effect as (and is said to be equivalent to) a String comprising n consecutive occurrences of char, where n=Integer'Value(count_string).
  5. An expanded picture String is a picture String containing no Character replications. NOTES
  6. (3) Although a sign to the left of the number can float, a sign to the right of the number is in a fixed position.

Edited Output Generation

Dynamic Semantics

  1. The contents of an edited output string are based on:
    1. A value, Item, of some decimal type Num,
    2. An expanded picture String Pic_String,
    3. A Boolean value, Blank_When_Zero,
    4. A Currency string,
    5. A Fill character,
    6. A Separator character, and
    7. A Radix_Mark character.
  1. The combination of a True value for Blank_When_Zero and a '*' character in Pic_String is inconsistent; no edited output string is defined.
  2. A layout error is identified in the rules below if leading non-zero digits of Item, character values of the Currency string, or a negative sign would be truncated; in such cases no edited output string is defined.
  3. The edited output string has lower bound 1 and upper bound N where N = Pic_String'Length + Currency_Length_Adjustment - Radix_Adjustment, and
    1. Currency_Length_Adjustment = Currency'Length - 1 if there is some occurrence of '$' in Pic_String, and 0 otherwise.
    2. Radix_Adjustment = 1 if there is an occurrence of 'V' or 'v' in Pic_Str, and 0 otherwise. 
    3. Let the magnitude of Item be expressed as a base-10 number
I ***I .F ***F , called the displayed magnitude of Item, where:
 p    1  1    q
    4. q = Min(Max(Num'Scale, 0), n) where n is 0 if Pic_String has no radix and is otherwise the number of digit positions following radix in Pic_String, where a digit position corresponds to an occurrence of '9', a zero_suppression_char (for an all_zero_suppression_number), a currency_char (for an all_currency_number), or a sign_char (for an all_sign_number). 
    5. I  /= 0 if p>0.
 p
  1. If n < Num'Scale, then the above number is the result of rounding (away from 0 if exactly midway between values).
  2. If Blank_When_Zero = True and the displayed magnitude of Item is zero, then the edited output string comprises all space character values. Otherwise, the picture String is treated as a sequence of instances of syntactic categories based on the rules in section Picture String Formation, and the edited output string is the concatenation of string values derived from these categories according to the following mapping rules.
  3. Table F-1 shows the mapping from a sign control symbol to a corresponding character or string in the edited output. In the columns showing the edited output, a lower-case 'b' represents the space character. If there is no sign control symbol but the value of Item is negative, a layout error occurs and no edited output string is produced. 
        +---------------------------------------------------+
    |                                                   |
    | Table F-1: Edited Output for Sign Control Symbols |
    |                                                   |
    +----------------+------------------+---------------+
    |                |                  |               |
    | Sign Control   | Edited Output    | Edited Output |
    | Symbol         | for Non-Negative | for Negative  |
    |                | Number           | Number        |
    |                |                  |               |
    +----------------+------------------+---------------+
    |                |                  |               |
    |      '+'       |        '+'       |      '-'      |
    |                |                  |               |
    |      '-'       |        'b'       |      '-'      |
    |                |                  |               |
    |      '<'       |        'b'       |      '('      |
    |                |                  |               |
    |      '>'       |        'b'       |      ')'      |
    |                |                  |               |
    |     "CR"       |       "bb"       |     "CR"      |
    |                |                  |               |
    |     "DB"       |       "bb"       |     "DB"      |
    |                |                  |               |
    +----------------+------------------+---------------+
  4. An instance of fixed_LHS_sign maps to a character as shown in Table F-1.
  5. An instance of fixed_$_char maps to Currency.
  6. An instance of direct_insertion maps to Separator if direct_insertion = '_', and to the direct_insertion Character otherwise.
  7. An instance of number maps to a string integer_part & radix_part & fraction_part where:
    1. The string for integer_part is obtained as follows: 
      1. Occurrences of '9' in fore_digits of number are replaced
from right to left with the decimal digit character values
for I , ..., I , respectively.
     1        p
      2. Each occurrence of '9' in fore_digits to the left of the leftmost '9' replaced according to rule 1 is replaced with '0'.
      3. If p exceeds the number of occurrences of '9' in fore_digits of number, then the excess leftmost digits are eligible for use in the mapping of an instance of zero_suppression, floating_LHS_sign, floating_$_currency, or floating_#_currency to the left of number; if there is no such instance, then a layout error occurs and no edited output string is produced.
    1. The radix_part is:
      1. "" if number does not include a radix, if radix = 'V', or if radix = 'v'
      2. Radix_Mark if number includes '.' as radix
    1. The string for fraction_part is obtained as follows: 
      1. Occurrences of '9' in aft_digits of number are replaced
from left to right with the decimal digit character values
for F , ... F .
     1       q
      2. Each occurrence of '9' in aft_digits to the right of the rightmost '9' replaced according to rule 1 is replaced by '0'.
  1. An instance of zero_suppression maps to the string obtained as follows:
    1. The rightmost 'Z', 'z', or '*' Character values are replaced with the excess digits (if any) from the integer_part of the mapping of the number to the right of the zero_suppression instance,
    2. A context_sensitive_insertion Character is replaced as though it were a direct_insertion Character, if it occurs to the right of some 'Z', 'z', or '*' in zero_suppression that has been mapped to an excess digit,
    3. Each Character to the left of the leftmost Character replaced according to rule 1 above is replaced by:
      1. the space character if the zero suppression Character is 'Z' or 'z', or
      2. the Fill character if the zero suppression Character is '*'.
    1. A layout error occurs if some excess digits remain after all 'Z', 'z', and '*' Character values in zero_suppression have been replaced via rule 1; no edited output string is produced.
  1. An instance of RHS_sign maps to a character or string as shown in Table F-1.
  2. An instance of floating_LHS_sign maps to the string obtained as follows.
    1. Up to all but one of the rightmost LHS_Sign Character values are replaced by the excess digits (if any) from the integer_part of the mapping of the number to the right of the floating_LHS_sign instance.
    2. The next Character to the left is replaced with the character given by the entry in Table F-1 corresponding to the LHS_Sign Character.
    3. A context_sensitive_insertion Character is replaced as though it were a direct_insertion Character, if it occurs to the right of the leftmost LHS_Sign character replaced according to rule 1.
    4. Any other Character is replaced by the space character..
    5. A layout error occurs if some excess digits remain after replacement via rule 1; no edited output string is produced.
  1. An instance of fixed_#_currency maps to the Currency string with n space character values concatenated on the left (if the instance does not follow a radix) or on the right (if the instance does follow a radix), where n is the difference between the length of the fixed_#_currency instance and Currency'Length. A layout error occurs if Currency'Length exceeds the length of the fixed_#_currency instance; no edited output string is produced.
  2. An instance of floating_$_currency maps to the string obtained as follows:
    1. Up to all but one of the rightmost '$' Character values are replaced with the excess digits (if any) from the integer_part of the mapping of the number to the right of the floating_$_currency instance.
    2. The next Character to the left is replaced by the Currency string.
    3. A context_sensitive_insertion Character is replaced as though it were a direct_insertion Character, if it occurs to the right of the leftmost '$' Character replaced via rule 1.
    4. Each other Character is replaced by the space character.
    5. A layout error occurs if some excess digits remain after replacement by rule 1; no edited output string is produced.
  1. An instance of floating_#_currency maps to the string obtained as follows:
    1. Up to all but one of the rightmost '#' Character values are replaced with the excess digits (if any) from the integer_part of the mapping of the number to the right of the floating_#_currency instance.
    2. The substring whose last Character occurs at the position immediately preceding the leftmost Character replaced via rule 1, and whose length is Currency'Length, is replaced by the Currency string.
    3. A context_sensitive_insertion Character is replaced as though it were a direct_insertion Character, if it occurs to the right of the leftmost '#' replaced via rule 1.
    4. Any other Character is replaced by the space character.
    5. A layout error occurs if some excess digits remain after replacement rule 1, or if there is no substring with the required length for replacement rule 2; no edited output string is produced.
  1. An instance of all_zero_suppression_number maps to:
    1. a string of all spaces if the displayed magnitude of Item is zero, the zero_suppression_char is 'Z' or 'z', and the instance of all_zero_suppression_number does not have a radix at its last character position;
    2. a string containing the Fill character in each position except for the character (if any) corresponding to radix, if zero_suppression_char = '*' and the displayed magnitude of Item is zero;
    3. otherwise, the same result as if each zero_suppression_char in all_zero_suppression_aft were '9', interpreting the instance of all_zero_suppression_number as either zero_suppression number (if a radix and all_zero_suppression_aft are present), or as zero_suppression otherwise.
  1. An instance of all_sign_number maps to:
    1. a string of all spaces if the displayed magnitude of Item is zero and the instance of all_sign_number does not have a radix at its last character position;
    2. otherwise, the same result as if each sign_char in all_sign_number_aft were '9', interpreting the instance of all_sign_number as either floating_LHS_sign number (if a radix and all_sign_number_aft are present), or as floating_LHS_sign otherwise.
  1. An instance of all_currency_number maps to:
    1. a string of all spaces if the displayed magnitude of Item is zero and the instance of all_currency_number does not have a radix at its last character position;
    2. otherwise, the same result as if each currency_char in all_currency_number_aft were '9', interpreting the instance of all_currency_number as floating_$_currency number or floating_#_currency number (if a radix and all_currency_number_aft are present), or as floating_$_currency or floating_#_currency otherwise.

Examples

  1. In the result string values shown below, 'b' represents the space character. 
  2. Item:         Picture and Result Strings:

  3. 123456.78     Picture:  "-###**_***_**9.99"
                        "bbb$***123,456.78"
                        "bbFF***123.456,78" (currency = "FF",
                                             separator = '.',
                                             radix mark = ',')

  4. 123456.78     Picture:  "-$$$**_***_**9.99"
              Result:   "bbb$***123,456.78"
                        "bbbFF***123.456,78" (currency = "FF",
                                              separator = '.',
                                              radix mark = ',')

  5. 0.0          Picture: "-$$$$$$.$$"
             Result:  "bbbbbbbbbb"

  6. 0.20         Picture: "-$$$$$$.$$"
             Result:  "bbbbbb$.20"

  7. -1234.565    Picture: "<<<<_<<<.<<###>"
             Result:  "bb(1,234.57DMb)"  (currency = "DM")

  8. 12345.67     Picture: "###_###_##9.99"
             Result:  "bbCHF12,345.67"   (currency = "CHF")

The Package Text_IO.Editing

  1. The package Text_IO.Editing provides a private type Picture with associated operations, and a generic package Decimal_Output. An object of type Picture is composed from a well-formed picture String (see section Picture String Formation) and a Boolean item indicating whether a zero numeric value will result in an edited output string of all space characters. The package Decimal_Output contains edited output subprograms implementing the effects defined in section Edited Output Generation.

    Static Semantics

  2. The library package Text_IO.Editing has the following declaration: 
  3. package Ada.Text_IO.Editing is

  4.    type Picture is private;

  5.    function Valid (Pic_String      : in String;
                   Blank_When_Zero : in Boolean := False)
     return Boolean;

  6.    function To_Picture (Pic_String      : in String;
                        Blank_When_Zero : in Boolean := False)
      return Picture;

  7.    function Pic_String      (Pic : in Picture) return String;
   function Blank_When_Zero (Pic : in Picture) return Boolean;

  8.    Max_Picture_Length  : constant := implementation_defined;

  9.    Picture_Error       : exception;

  10.    Default_Currency    : constant String    := "$";
   Default_Fill        : constant Character := '*';
   Default_Separator   : constant Character := ',';
   Default_Radix_Mark  : constant Character := '.';

  11.    generic
      type Num is delta <> digits <>;
      Default_Currency   : in String
        :=  Text_IO.Editing.Default_Currency;
      Default_Fill       : in Character
        :=  Text_IO.Editing.Default_Fill;
      Default_Separator  : in Character
        :=  Text_IO.Editing.Default_Separator;
      Default_Radix_Mark : in Character
        :=  Text_IO.Editing.Default_Radix_Mark;
   package Decimal_Output is
      function Length (Pic      : in Picture;
                       Currency : in String := Default_Currency)
         return Natural;

  12.       function Valid (Item     : in Num;
                      Pic      : in Picture;
                      Currency : in String := Default_Currency)
         return Boolean;

  13.       function Image
        (Item       : in Num;
         Pic        : in Picture;
         Currency   : in String    := Default_Currency;
         Fill       : in Character := Default_Fill;
         Separator  : in Character := Default_Separator;
         Radix_Mark : in Character := Default_Radix_Mark)
         return String;

  14.       procedure Put
        (File       : in File_Type;
         Item       : in Num;
         Pic        : in Picture;
         Currency   : in String    := Default_Currency;
         Fill       : in Character := Default_Fill;
         Separator  : in Character := Default_Separator;
         Radix_Mark : in Character := Default_Radix_Mark);

  15.       procedure Put
        (Item       : in Num;
         Pic        : in Picture;
         Currency   : in String    := Default_Currency;
         Fill       : in Character := Default_Fill;
         Separator  : in Character := Default_Separator;
         Radix_Mark : in Character := Default_Radix_Mark);

  16.       procedure Put
        (To         : out String;
         Item       : in Num;
         Pic        : in Picture;
         Currency   : in String    := Default_Currency;
         Fill       : in Character := Default_Fill;
         Separator  : in Character := Default_Separator;
         Radix_Mark : in Character := Default_Radix_Mark);
   end Decimal_Output;
private
   ... -- not specified by the language
end Ada.Text_IO.Editing;
  17. The exception Constraint_Error is raised if the Image function or any of the Put procedures is invoked with a null string for Currency. 
  18. function Valid (Pic_String      : in String;
                Blank_When_Zero : in Boolean := False)
  return Boolean;
    1. Valid returns True if Pic_String is a well-formed picture String (see section Picture String Formation) the length of whose expansion does not exceed Max_Picture_Length, and if either Blank_When_Zero is False or Pic_String contains no '*'. 
  1. function To_Picture (Pic_String      : in String;
                     Blank_When_Zero : in Boolean := False)
   return Picture;
    1. To_Picture returns a result Picture such that the application of the function Pic_String to this result yields an expanded picture String equivalent to Pic_String, and such that Blank_When_Zero applied to the result Picture is the same value as the parameter Blank_When_Zero. Picture_Error is raised if not Valid(Pic_String, Blank_When_Zero). 
  1. function Pic_String      (Pic : in Picture) return String;

function Blank_When_Zero (Pic : in Picture) return Boolean;
    1. If Pic is To_Picture(String_Item, Boolean_Item) for some String_Item and Boolean_Item, then:
      1. Pic_String(Pic) returns an expanded picture String equivalent to String_Item and with any lower-case letter replaced with its corresponding upper-case form, and
      2. Blank_When_Zero(Pic) returns Boolean_Item.
    1. If Pic_1 and Pic_2 are objects of type Picture, then "="(Pic_1, Pic_2) is True when
      1. Pic_String(Pic_1) = Pic_String(Pic_2), and
      2. Blank_When_Zero(Pic_1) = Blank_When_Zero(Pic_2). 
  1. function Length (Pic      : in Picture;
                 Currency : in String := Default_Currency)
   return Natural;
    1. Length returns Pic_String(Pic)'Length + Currency_Length_Adjustment - Radix_Adjustment where
      1. Currency_Length_Adjustment =
        1. Currency'Length - 1 if there is some occurrence of '$' in Pic_String(Pic), and
        2. 0 otherwise.
      1. Radix_Adjustment =
        1. 1 if there is an occurrence of 'V' or 'v' in Pic_Str(Pic), and
        2. 0 otherwise. 
  1. function Valid (Item     : in Num;
                Pic      : in Picture;
                Currency : in String := Default_Currency)
   return Boolean;
    1. Valid returns True if Image(Item, Pic, Currency) does not raise Layout_Error, and returns False otherwise. 
  1. function Image (Item       : in Num;
                Pic        : in Picture;
                Currency   : in String    := Default_Currency;
                Fill       : in Character := Default_Fill;
                Separator  : in Character := Default_Separator;
                Radix_Mark : in Character := Default_Radix_Mark)
   return String;
    1. Image returns the edited output String as defined in section Edited Output Generation, for Item, Pic_String(Pic), Blank_When_Zero(Pic), Currency, Fill, Separator, and Radix_Mark. If these rules identify a layout error, then Image raises the exception Layout_Error. 
  1. procedure Put (File       : in File_Type;
               Item       : in Num;
               Pic        : in Picture;
               Currency   : in String    := Default_Currency;
               Fill       : in Character := Default_Fill;
               Separator  : in Character := Default_Separator;
               Radix_Mark : in Character := Default_Radix_Mark);

procedure Put (Item       : in Num;
               Pic        : in Picture;
               Currency   : in String    := Default_Currency;
               Fill       : in Character := Default_Fill;
               Separator  : in Character := Default_Separator;
               Radix_Mark : in Character := Default_Radix_Mark);
    1. Each of these Put procedures outputs Image(Item, Pic, Currency, Fill, Separator, Radix_Mark) consistent with the conventions for Put for other real types in case of bounded line length, see section Get and Put Procedures. 
  1. procedure Put (To         : out String;
               Item       : in Num;
               Pic        : in Picture;
               Currency   : in String    := Default_Currency;
               Fill       : in Character := Default_Fill;
               Separator  : in Character := Default_Separator;
               Radix_Mark : in Character := Default_Radix_Mark);
    1. Put copies Image(Item, Pic, Currency, Fill, Separator, Radix_Mark) to the given string, right justified. Otherwise unassigned Character values in To are assigned the space character. If To'Length is less than the length of the string resulting from Image, then Layout_Error is raised.

Implementation Requirements

  1. Max_Picture_Length shall be at least 30. The implementation shall support currency strings of length up to at least 10, both for Default_Currency in an instantiation of Decimal_Output, and for Currency in an invocation of Image or any of the Put procedures. NOTES
  2. (4) The rules for edited output are based on COBOL (ANSI X3.23:1985, endorsed by ISO as ISO 1989-1985), with the following differences:
    1. The COBOL provisions for picture string localization and for 'P' format are absent from Ada.
    2. The following Ada facilities are not in COBOL:
      1. currency symbol placement after the number,
      2. localization of edited output string for multi-character currency string values, including support for both length-preserving and length-expanding currency symbols in picture strings
      3. localization of the radix mark, digits separator, and fill character, and
      4. parenthesization of negative values.
    The value of 30 for Max_Picture_Length is the same limit as in COBOL.

The Package Wide_Text_IO.Editing

Static Semantics

  1. The child package Wide_Text_IO.Editing has the same contents as Text_IO.Editing, except that:
    1. each occurrence of Character is replaced by Wide_Character,
    2. each occurrence of Text_IO is replaced by Wide_Text_IO,
    3. the subtype of Default_Currency is Wide_String rather than String, and
    4. each occurrence of String in the generic package Decimal_Output is replaced by Wide_String.
    NOTES
  1. (5) Each of the functions Wide_Text_IO.Editing.Valid, To_Picture, and Pic_String has String (versus Wide_String) as its parameter or result subtype, since a picture String is not localizable.

Numerics (normative)

  1. The Numerics Annex specifies
    1. features for complex arithmetic, including complex I/O;
    2. a mode ("strict mode"), in which the predefined arithmetic operations of floating point and fixed point types and the functions and operations of various predefined packages have to provide guaranteed accuracy or conform to other numeric performance requirements, which the Numerics Annex also specifies;
    3. a mode ("relaxed mode"), in which no accuracy or other numeric performance requirements need be satisfied, as for implementations not conforming to the Numerics Annex;
    4. models of floating point and fixed point arithmetic on which the accuracy requirements of strict mode are based; and
    5. the definitions of the model-oriented attributes of floating point types that apply in the strict mode.

Implementation Advice

  1. If Fortran (respectively, C) is widely supported in the target environment, implementations supporting the Numerics Annex should provide the child package Interfaces.Fortran (respectively, Interfaces.C) specified in Annex B and should support a convention_identifier of Fortran (respectively, C) in the interfacing pragmas, see section Interface to Other Languages (normative), thus allowing Ada programs to interface with programs written in that language.

Complex Arithmetic

  1. Types and arithmetic operations for complex arithmetic are provided in Generic_Complex_Types, which is defined in section Complex Types. Implementation-defined approximations to the complex analogs of the mathematical functions known as the "elementary functions" are provided by the subprograms in Generic_Complex_Elementary_Functions, which is defined in section Complex Elementary Functions. Both of these library units are generic children of the predefined package Numerics, see section The Numerics Packages. Nongeneric equivalents of these generic packages for each of the predefined floating point types are also provided as children of Numerics.

Complex Types

Static Semantics

  1. The generic library package Numerics.Generic_Complex_Types has the following declaration: 
  2. generic
   type Real is digits <>;
package Ada.Numerics.Generic_Complex_Types is
   pragma Pure(Generic_Complex_Types);

  3.    type Complex is
      record
         Re, Im : Real'Base;
      end record;

  4.    type Imaginary is private;

  5.    i : constant Imaginary;
   j : constant Imaginary;

  6.    function Re (X : Complex)   return Real'Base;
   function Im (X : Complex)   return Real'Base;
   function Im (X : Imaginary) return Real'Base;

  7.    procedure Set_Re (X  : in out Complex;
                     Re : in     Real'Base);
   procedure Set_Im (X  : in out Complex;
                     Im : in     Real'Base);
   procedure Set_Im (X  :    out Imaginary;
                     Im : in     Real'Base);

  8.    function Compose_From_Cartesian (Re, Im : Real'Base)
     return Complex;
   function Compose_From_Cartesian (Re     : Real'Base)
     return Complex;
   function Compose_From_Cartesian (Im     : Imaginary)
     return Complex;

  9.    function Modulus (X     : Complex) return Real'Base;
   function "abs"   (Right : Complex) return Real'Base
     renames Modulus;

  10.    function Argument (X     : Complex)   return Real'Base;
   function Argument (X     : Complex;
                      Cycle : Real'Base) return Real'Base;

  11.    function Compose_From_Polar
     (Modulus, Argument        : Real'Base)
      return Complex;
   function Compose_From_Polar
     (Modulus, Argument, Cycle : Real'Base)
      return Complex;

  12.    function "+"       (Right : Complex) return Complex;
   function "-"       (Right : Complex) return Complex;
   function Conjugate (X     : Complex) return Complex;

  13.    function "+" (Left, Right : Complex) return Complex;
   function "-" (Left, Right : Complex) return Complex;
   function "*" (Left, Right : Complex) return Complex;
   function "/" (Left, Right : Complex) return Complex;

  14.    function "**" (Left : Complex; Right : Integer) return Complex;

  15.    function "+"       (Right : Imaginary) return Imaginary;
   function "-"       (Right : Imaginary) return Imaginary;
   function Conjugate (X     : Imaginary) return Imaginary
     renames "-";
   function "abs"     (Right : Imaginary) return Real'Base;

  16.    function "+" (Left, Right : Imaginary) return Imaginary;
   function "-" (Left, Right : Imaginary) return Imaginary;
   function "*" (Left, Right : Imaginary) return Real'Base;
   function "/" (Left, Right : Imaginary) return Real'Base;

  17.    function "**" (Left : Imaginary; Right : Integer) return Complex;

  18.    function "<"  (Left, Right : Imaginary) return Boolean;
   function "<=" (Left, Right : Imaginary) return Boolean;
   function ">"  (Left, Right : Imaginary) return Boolean;
   function ">=" (Left, Right : Imaginary) return Boolean;

  19.    function "+" (Left  : Complex;
                 Right : Real'Base) return Complex;
   function "+" (Left  : Real'Base;
                 Right : Complex)   return Complex;
   function "-" (Left  : Complex;
                 Right : Real'Base) return Complex;
   function "-" (Left  : Real'Base;
                 Right : Complex)   return Complex;
   function "*" (Left  : Complex;
                 Right : Real'Base) return Complex;
   function "*" (Left  : Real'Base;
                 Right : Complex)   return Complex;
   function "/" (Left  : Complex;
                 Right : Real'Base) return Complex;
   function "/" (Left  : Real'Base;
                 Right : Complex)   return Complex;

  20.    function "+" (Left  : Complex;
                 Right : Imaginary) return Complex;
   function "+" (Left  : Imaginary;
                 Right : Complex)   return Complex;
   function "-" (Left  : Complex;
                 Right : Imaginary) return Complex;
   function "-" (Left  : Imaginary;
                 Right : Complex)   return Complex;
   function "*" (Left  : Complex;
                 Right : Imaginary) return Complex;
   function "*" (Left  : Imaginary;
                 Right : Complex)   return Complex;
   function "/" (Left  : Complex;
                 Right : Imaginary) return Complex;
   function "/" (Left  : Imaginary;
                 Right : Complex)   return Complex;

  21.    function "+" (Left  : Imaginary;
                 Right : Real'Base) return Complex;
   function "+" (Left  : Real'Base;
                 Right : Imaginary) return Complex;
   function "-" (Left  : Imaginary;
                 Right : Real'Base) return Complex;
   function "-" (Left  : Real'Base;
                 Right : Imaginary) return Complex;
   function "*" (Left  : Imaginary;
                 Right : Real'Base) return Imaginary;
   function "*" (Left  : Real'Base;
                 Right : Imaginary) return Imaginary;
   function "/" (Left  : Imaginary;
                 Right : Real'Base) return Imaginary;
   function "/" (Left  : Real'Base;
                 Right : Imaginary) return Imaginary;

  22. private

  23.    type Imaginary is new Real'Base;
   i : constant Imaginary := 1.0;
   j : constant Imaginary := 1.0;

  24. end Ada.Numerics.Generic_Complex_Types;
  25. The library package Numerics.Complex_Types defines the same types, constants, and subprograms as Numerics.Generic_Complex_Types, except that the predefined type Float is systematically substituted for Real'Base throughout. Nongeneric equivalents of Numerics.Generic_Complex_Types for each of the other predefined floating point types are defined similarly, with the names Numerics.Short_Complex_Types, Numerics.Long_Complex_Types, etc.
  26. Complex is a visible type with cartesian components.
  27. Imaginary is a private type; its full type is derived from Real'Base.
  28. The arithmetic operations and the Re, Im, Modulus, Argument, and Conjugate functions have their usual mathematical meanings. When applied to a parameter of pure-imaginary type, the "imaginary-part" function Im yields the value of its parameter, as the corresponding real value. The remaining subprograms have the following meanings:
    1. The Set_Re and Set_Im procedures replace the designated component of a complex parameter with the given real value; applied to a parameter of pure-imaginary type, the Set_Im procedure replaces the value of that parameter with the imaginary value corresponding to the given real value.
    2. The Compose_From_Cartesian function constructs a complex value from the given real and imaginary components. If only one component is given, the other component is implicitly zero.
    3. The Compose_From_Polar function constructs a complex value from the given modulus (radius) and argument (angle). When the value of the parameter Modulus is positive (resp., negative), the result is the complex value represented by the point in the complex plane lying at a distance from the origin given by the absolute value of Modulus and forming an angle measured counterclockwise from the positive (resp., negative) real axis given by the value of the parameter Argument.
  1. When the Cycle parameter is specified, the result of the Argument function and the parameter Argument of the Compose_From_Polar function are measured in units such that a full cycle of revolution has the given value; otherwise, they are measured in radians.
  2. The computed results of the mathematically multivalued functions are rendered single-valued by the following conventions, which are meant to imply the principal branch:
    1. The result of the Modulus function is nonnegative.
    2. The result of the Argument function is in the quadrant containing the point in the complex plane represented by the parameter X. This may be any quadrant (I through IV); thus, the range of the Argument function is approximately -Pi to Pi (-Cycle/2.0 to Cycle/2.0, if the parameter Cycle is specified). When the point represented by the parameter X lies on the negative real axis, the result approximates
      1. Pi (resp., -Pi) when the sign of the imaginary component of X is positive (resp., negative), if Real'Signed_Zeros is True;
      2. Pi, if Real'Signed_Zeros is False.
    1. Because a result lying on or near one of the axes may not be exactly representable, the approximation inherent in computing the result may place it in an adjacent quadrant, close to but on the wrong side of the axis.

Dynamic Semantics

  1. The exception Numerics.Argument_Error is raised by the Argument and Compose_From_Polar functions with specified cycle, signaling a parameter value outside the domain of the corresponding mathematical function, when the value of the parameter Cycle is zero or negative.
  2. The exception Constraint_Error is raised by the division operator when the value of the right operand is zero, and by the exponentiation operator when the value of the left operand is zero and the value of the exponent is negative, provided that Real'Machine_Overflows is True; when Real'Machine_Overflows is False, the result is unspecified. Constraint_Error can also be raised when a finite result overflows (see section Accuracy Requirements for Complex Arithmetic).

    Implementation Requirements

  3. In the implementation of Numerics.Generic_Complex_Types, the range of intermediate values allowed during the calculation of a final result shall not be affected by any range constraint of the subtype Real.
  4. In the following cases, evaluation of a complex arithmetic operation shall yield the prescribed result, provided that the preceding rules do not call for an exception to be raised:
    1. The results of the Re, Im, and Compose_From_Cartesian functions are exact.
    2. The real (resp., imaginary) component of the result of a binary addition operator that yields a result of complex type is exact when either of its operands is of pure-imaginary (resp., real) type.
    3. The real (resp., imaginary) component of the result of a binary subtraction operator that yields a result of complex type is exact when its right operand is of pure-imaginary (resp., real) type.
    4. The real component of the result of the Conjugate function for the complex type is exact.
    5. When the point in the complex plane represented by the parameter X lies on the nonnegative real axis, the Argument function yields a result of zero.
    6. When the value of the parameter Modulus is zero, the Compose_From_Polar function yields a result of zero.
    7. When the value of the parameter Argument is equal to a multiple of the quarter cycle, the result of the Compose_From_Polar function with specified cycle lies on one of the axes. In this case, one of its components is zero, and the other has the magnitude of the parameter Modulus.
    8. Exponentiation by a zero exponent yields the value one. Exponentiation by a unit exponent yields the value of the left operand. Exponentiation of the value one yields the value one. Exponentiation of the value zero yields the value zero, provided that the exponent is nonzero. When the left operand is of pure-imaginary type, one component of the result of the exponentiation operator is zero.
  1. When the result, or a result component, of any operator of Numerics.Generic_Complex_Types has a mathematical definition in terms of a single arithmetic or relational operation, that result or result component exhibits the accuracy of the corresponding operation of the type Real.
  2. Other accuracy requirements for the Modulus, Argument, and Compose_From_Polar functions, and accuracy requirements for the multiplication of a pair of complex operands or for division by a complex operand, all of which apply only in the strict mode, are given in section Accuracy Requirements for Complex Arithmetic.
  3. The sign of a zero result or zero result component yielded by a complex arithmetic operation or function is implementation defined when Real'Signed_Zeros is True.

    Implementation Permissions

  4. The nongeneric equivalent packages may, but need not, be actual instantiations of the generic package for the appropriate predefined type.
  5. Implementations may obtain the result of exponentiation of a complex or pure-imaginary operand by repeated complex multiplication, with arbitrary association of the factors and with a possible final complex reciprocation (when the exponent is negative). Implementations are also permitted to obtain the result of exponentiation of a complex operand, but not of a pure-imaginary operand, by converting the left operand to a polar representation; exponentiating the modulus by the given exponent; multiplying the argument by the given exponent, when the exponent is positive, or dividing the argument by the absolute value of the given exponent, when the exponent is negative; and reconverting to a cartesian representation. Because of this implementation freedom, no accuracy requirement is imposed on complex exponentiation (except for the prescribed results given above, which apply regardless of the implementation method chosen).

    Implementation Advice

  6. Because the usual mathematical meaning of multiplication of a complex operand and a real operand is that of the scaling of both components of the former by the latter, an implementation should not perform this operation by first promoting the real operand to complex type and then performing a full complex multiplication. In systems that, in the future, support an Ada binding to IEC 559:1989, the latter technique will not generate the required result when one of the components of the complex operand is infinite. (Explicit multiplication of the infinite component by the zero component obtained during promotion yields a NaN that propagates into the final result.) Analogous advice applies in the case of multiplication of a complex operand and a pure-imaginary operand, and in the case of division of a complex operand by a real or pure-imaginary operand.
  7. Likewise, because the usual mathematical meaning of addition of a complex operand and a real operand is that the imaginary operand remains unchanged, an implementation should not perform this operation by first promoting the real operand to complex type and then performing a full complex addition. In implementations in which the Signed_Zeros attribute of the component type is True (and which therefore conform to IEC 559:1989 in regard to the handling of the sign of zero in predefined arithmetic operations), the latter technique will not generate the required result when the imaginary component of the complex operand is a negatively signed zero. (Explicit addition of the negative zero to the zero obtained during promotion yields a positive zero.) Analogous advice applies in the case of addition of a complex operand and a pure-imaginary operand, and in the case of subtraction of a complex operand and a real or pure-imaginary operand.
  8. Implementations in which Real'Signed_Zeros is True should attempt to provide a rational treatment of the signs of zero results and result components. As one example, the result of the Argument function should have the sign of the imaginary component of the parameter X when the point represented by that parameter lies on the positive real axis; as another, the sign of the imaginary component of the Compose_From_Polar function should be the same as (resp., the opposite of) that of the Argument parameter when that parameter has a value of zero and the Modulus parameter has a nonnegative (resp., negative) value.

Complex Elementary Functions

Static Semantics

  1. The generic library package Numerics.Generic_Complex_Elementary_Functions has the following declaration: 
  2. with Ada.Numerics.Generic_Complex_Types;
generic
   with package Complex_Types is new
     Ada.Numerics.Generic_Complex_Types (<>);
   use Complex_Types;
package Ada.Numerics.Generic_Complex_Elementary_Functions is
   pragma Pure(Generic_Complex_Elementary_Functions);

  3.    function Sqrt (X : Complex)   return Complex;
   function Log  (X : Complex)   return Complex;
   function Exp  (X : Complex)   return Complex;
   function Exp  (X : Imaginary) return Complex;
   function "**" (Left  : Complex;
                  Right : Complex)   return Complex;
   function "**" (Left  : Complex;
                  Right : Real'Base) return Complex;
   function "**" (Left  : Real'Base;
                  Right : Complex)   return Complex;

  4.    function Sin (X : Complex) return Complex;
   function Cos (X : Complex) return Complex;
   function Tan (X : Complex) return Complex;
   function Cot (X : Complex) return Complex;

  5.    function Arcsin (X : Complex) return Complex;
   function Arccos (X : Complex) return Complex;
   function Arctan (X : Complex) return Complex;
   function Arccot (X : Complex) return Complex;

  6.    function Sinh (X : Complex) return Complex;
   function Cosh (X : Complex) return Complex;
   function Tanh (X : Complex) return Complex;
   function Coth (X : Complex) return Complex;

  7.    function Arcsinh (X : Complex) return Complex;
   function Arccosh (X : Complex) return Complex;
   function Arctanh (X : Complex) return Complex;
   function Arccoth (X : Complex) return Complex;

  8. end Ada.Numerics.Generic_Complex_Elementary_Functions;
  9. The library package Numerics.Complex_Elementary_Functions defines the same subprograms as Numerics.Generic_Complex_Elementary_Functions, except that the predefined type Float is systematically substituted for Real'Base, and the Complex and Imaginary types exported by Numerics.Complex_Types are systematically substituted for Complex and Imaginary, throughout. Nongeneric equivalents of Numerics.Generic_Complex_Elementary_Functions corresponding to each of the other predefined floating point types are defined similarly, with the names Numerics.Short_Complex_Elementary_Functions, Numerics.Long_Complex_Elementary_Functions, etc.
  10. The overloading of the Exp function for the pure-imaginary type is provided to give the user an alternate way to compose a complex value from a given modulus and argument. In addition to Compose_From_Polar(Rho, Theta), see section Complex Types, the programmer may write Rho * Exp(i * Theta).
  11. The imaginary (resp., real) component of the parameter X of the forward hyperbolic (resp., trigonometric) functions and of the Exp function (and the parameter X, itself, in the case of the overloading of the Exp function for the pure-imaginary type) represents an angle measured in radians, as does the imaginary (resp., real) component of the result of the Log and inverse hyperbolic (resp., trigonometric) functions.
  12. The functions have their usual mathematical meanings. However, the arbitrariness inherent in the placement of branch cuts, across which some of the complex elementary functions exhibit discontinuities, is eliminated by the following conventions:
    1. The imaginary component of the result of the Sqrt and Log functions is discontinuous as the parameter X crosses the negative real axis.
    2. The result of the exponentiation operator when the left operand is of complex type is discontinuous as that operand crosses the negative real axis.
    3. The real (resp., imaginary) component of the result of the Arcsin and Arccos (resp., Arctanh) functions is discontinuous as the parameter X crosses the real axis to the left of -1.0 or the right of 1.0.
    4. The real (resp., imaginary) component of the result of the Arctan (resp., Arcsinh) function is discontinuous as the parameter X crosses the imaginary axis below -i or above i.
    5. The real component of the result of the Arccot function is discontinuous as the parameter X crosses the imaginary axis between -i and i.
    6. The imaginary component of the Arccosh function is discontinuous as the parameter X crosses the real axis to the left of 1.0.
    7. The imaginary component of the result of the Arccoth function is discontinuous as the parameter X crosses the real axis between -1.0 and 1.0.
  1. The computed results of the mathematically multivalued functions are rendered single-valued by the following conventions, which are meant to imply the principal branch:
    1. The real component of the result of the Sqrt and Arccosh functions is nonnegative.
    2. The same convention applies to the imaginary component of the result of the Log function as applies to the result of the natural-cycle version of the Argument function of Numerics.Generic_Complex_Types (see section Complex Types).
    3. The range of the real (resp., imaginary) component of the result of the Arcsin and Arctan (resp., Arcsinh and Arctanh) functions is approximately -Pi/2.0 to Pi/2.0.
    4. The real (resp., imaginary) component of the result of the Arccos and Arccot (resp., Arccoth) functions ranges from 0.0 to approximately Pi.
    5. The range of the imaginary component of the result of the Arccosh function is approximately -Pi to Pi.
  1. In addition, the exponentiation operator inherits the single-valuedness of the Log function.

    Dynamic Semantics

  2. The exception Numerics.Argument_Error is raised by the exponentiation operator, signaling a parameter value outside the domain of the corresponding mathematical function, when the value of the left operand is zero and the real component of the exponent (or the exponent itself, when it is of real type) is zero.
  3. The exception Constraint_Error is raised, signaling a pole of the mathematical function (analogous to dividing by zero), in the following cases, provided that Complex_Types.Real'Machine_Overflows is True:
    1. by the Log, Cot, and Coth functions, when the value of the parameter X is zero;
    2. by the exponentiation operator, when the value of the left operand is zero and the real component of the exponent (or the exponent itself, when it is of real type) is negative;
    3. by the Arctan and Arccot functions, when the value of the parameter X is +/-i;
    4. by the Arctanh and Arccoth functions, when the value of the parameter X is +/-1.0.
  1. Constraint_Error can also be raised when a finite result overflows (see section Accuracy Requirements for Complex Arithmetic) this may occur for parameter values sufficiently near poles, and, in the case of some of the functions, for parameter values having components of sufficiently large magnitude. When Complex_Types.Real'Machine_Overflows is False, the result at poles is unspecified.

    Implementation Requirements

  2. In the implementation of Numerics.Generic_Complex_Elementary_Functions, the range of intermediate values allowed during the calculation of a final result shall not be affected by any range constraint of the subtype Complex_Types.Real.
  3. In the following cases, evaluation of a complex elementary function shall yield the prescribed result (or a result having the prescribed component), provided that the preceding rules do not call for an exception to be raised:
    1. When the parameter X has the value zero, the Sqrt, Sin, Arcsin, Tan, Arctan, Sinh, Arcsinh, Tanh, and Arctanh functions yield a result of zero; the Exp, Cos, and Cosh functions yield a result of one; the Arccos and Arccot functions yield a real result; and the Arccoth function yields an imaginary result.
    2. When the parameter X has the value one, the Sqrt function yields a result of one; the Log, Arccos, and Arccosh functions yield a result of zero; and the Arcsin function yields a real result.
    3. When the parameter X has the value -1.0, the Sqrt function yields the result
      1. i (resp., -i), when the sign of the imaginary component of X is positive (resp., negative), if Complex_Types.Real'Signed_Zeros is True;
      2. i, if Complex_Types.Real'Signed_Zeros is False;
    1. the Log function yields an imaginary result; and the Arcsin and Arccos functions yield a real result.
    2. When the parameter X has the value +/-i, the Log function yields an imaginary result.
    3. Exponentiation by a zero exponent yields the value one. Exponentiation by a unit exponent yields the value of the left operand (as a complex value). Exponentiation of the value one yields the value one. Exponentiation of the value zero yields the value zero.
  1. Other accuracy requirements for the complex elementary functions, which apply only in the strict mode, are given in section Accuracy Requirements for Complex Arithmetic.
  2. The sign of a zero result or zero result component yielded by a complex elementary function is implementation defined when Complex_Types.Real'Signed_Zeros is True.

    Implementation Permissions

  3. The nongeneric equivalent packages may, but need not, be actual instantiations of the generic package with the appropriate predefined nongeneric equivalent of Numerics.Generic_Complex_Types; if they are, then the latter shall have been obtained by actual instantiation of Numerics.Generic_Complex_Types.
  4. The exponentiation operator may be implemented in terms of the Exp and Log functions. Because this implementation yields poor accuracy in some parts of the domain, no accuracy requirement is imposed on complex exponentiation.
  5. The implementation of the Exp function of a complex parameter X is allowed to raise the exception Constraint_Error, signaling overflow, when the real component of X exceeds an unspecified threshold that is approximately log (Complex_Types.Real'Safe_Last). This permission recognizes the impracticality of avoiding overflow in the marginal case that the exponential of the real component of X exceeds the safe range of Complex_Types.Real but both components of the final result do not. Similarly, the Sin and Cos (resp., Sinh and Cosh) functions are allowed to raise the exception Constraint_Error, signaling overflow, when the absolute value of the imaginary (resp., real) component of the parameter X exceeds an unspecified threshold that is approximately log (Complex_Types.Real'Safe_Last)+log (2.0). This permission recognizes the impracticality of avoiding overflow in the marginal case that the hyperbolic sine or cosine of the imaginary (resp., real) component of X exceeds the safe range of Complex_Types.Real but both components of the final result do not.

    Implementation Advice

  6. Implementations in which Complex_Types.Real'Signed_Zeros is True should attempt to provide a rational treatment of the signs of zero results and result components. For example, many of the complex elementary functions have components that are odd functions of one of the parameter components; in these cases, the result component should have the sign of the parameter component at the origin. Other complex elementary functions have zero components whose sign is opposite that of a parameter component at the origin, or is always positive or always negative.

Complex Input-Output

  1. The generic package Text_IO.Complex_IO defines procedures for the formatted input and output of complex values. The generic actual parameter in an instantiation of Text_IO.Complex_IO is an instance of Numerics.Generic_Complex_Types for some floating point subtype. Exceptional conditions are reported by raising the appropriate exception defined in Text_IO.

    Static Semantics

  2. The generic library package Text_IO.Complex_IO has the following declaration: 
  3. with Ada.Numerics.Generic_Complex_Types;
generic
   with package Complex_Types is new
     Ada.Numerics.Generic_Complex_Types (<>);
package Ada.Text_IO.Complex_IO is

  4.    use Complex_Types;

  5.    Default_Fore : Field := 2;
   Default_Aft  : Field := Real'Digits - 1;
   Default_Exp  : Field := 3;

  6.    procedure Get (File  : in  File_Type;
                  Item  : out Complex;
                  Width : in  Field := 0);
   procedure Get (Item  : out Complex;
                  Width : in  Field := 0);

  7.    procedure Put (File : in File_Type;
                  Item : in Complex;
                  Fore : in Field := Default_Fore;
                  Aft  : in Field := Default_Aft;
                  Exp  : in Field := Default_Exp);
   procedure Put (Item : in Complex;
                  Fore : in Field := Default_Fore;
                  Aft  : in Field := Default_Aft;
                  Exp  : in Field := Default_Exp);

  8.    procedure Get (From : in  String;
                  Item : out Complex;
                  Last : out Positive);
   procedure Put (To   : out String;
                  Item : in  Complex;
                  Aft  : in  Field := Default_Aft;
                  Exp  : in  Field := Default_Exp);

  9. end Ada.Text_IO.Complex_IO;
  10. The semantics of the Get and Put procedures are as follows: 
  11. procedure Get (File  : in  File_Type;
               Item  : out Complex;
               Width : in  Field := 0);

procedure Get (Item  : out Complex;
               Width : in  Field := 0);
    1. The input sequence is a pair of optionally signed real literals representing the real and imaginary components of a complex value; optionally, the pair of components may be separated by a comma and/or surrounded by a pair of parentheses. Blanks are freely allowed before each of the components and before the parentheses and comma, if either is used. If the value of the parameter Width is zero, then
      1. line and page terminators are also allowed in these places;
      2. the components shall be separated by at least one blank or line terminator if the comma is omitted; and
      3. reading stops when the right parenthesis has been read, if the input sequence includes a left parenthesis, or when the imaginary component has been read, otherwise.
      If a nonzero value of Width is supplied, then
      1. the components shall be separated by at least one blank if the comma is omitted; and
      2. exactly Width characters are read, or the characters (possibly none) up to a line terminator, whichever comes first (blanks are included in the count).
    1. Returns, in the parameter Item, the value of type Complex that corresponds to the input sequence.
    2. The exception Text_IO.Data_Error is raised if the input sequence does not have the required syntax or if the components of the complex value obtained are not of the base subtype of Complex_Types.Real. 
  1. procedure Put (File : in File_Type;
               Item : in Complex;
               Fore : in Field := Default_Fore;
               Aft  : in Field := Default_Aft;
               Exp  : in Field := Default_Exp);

procedure Put (Item : in Complex;
               Fore : in Field := Default_Fore;
               Aft  : in Field := Default_Aft;
               Exp  : in Field := Default_Exp);
    1. Outputs the value of the parameter Item as a pair of decimal literals representing the real and imaginary components of the complex value, using the syntax of an aggregate. More specifically,
      1. outputs a left parenthesis;
      2. outputs the value of the real component of the parameter Item with the format defined by the corresponding Put procedure of an instance of Text_IO.Float_IO for the base subtype of Complex_Types.Real, using the given values of Fore, Aft, and Exp;
      3. outputs a comma;
      4. outputs the value of the imaginary component of the parameter Item with the format defined by the corresponding Put procedure of an instance of Text_IO.Float_IO for the base subtype of Complex_Types.Real, using the given values of Fore, Aft, and Exp;
      5. outputs a right parenthesis. 
  1. procedure Get (From : in  String;
               Item : out Complex;
               Last : out Positive);
    1. Reads a complex value from the beginning of the given string, following the same rule as the Get procedure that reads a complex value from a file, but treating the end of the string as a line terminator. Returns, in the parameter Item, the value of type Complex that corresponds to the input sequence. Returns in Last the index value such that From(Last) is the last character read.
    2. The exception Text_IO.Data_Error is raised if the input sequence does not have the required syntax or if the components of the complex value obtained are not of the base subtype of Complex_Types.Real. 
  1. procedure Put (To   : out String;
               Item : in  Complex;
               Aft  : in  Field := Default_Aft;
               Exp  : in  Field := Default_Exp);
    1. Outputs the value of the parameter Item to the given string as a pair of decimal literals representing the real and imaginary components of the complex value, using the syntax of an aggregate. More specifically,
      1. a left parenthesis, the real component, and a comma are left justified in the given string, with the real component having the format defined by the Put procedure (for output to a file) of an instance of Text_IO.Float_IO for the base subtype of Complex_Types.Real, using a value of zero for Fore and the given values of Aft and Exp;
      2. the imaginary component and a right parenthesis are right justified in the given string, with the imaginary component having the format defined by the Put procedure (for output to a file) of an instance of Text_IO.Float_IO for the base subtype of Complex_Types.Real, using a value for Fore that completely fills the remainder of the string, together with the given values of Aft and Exp.
    1. The exception Text_IO.Layout_Error is raised if the given string is too short to hold the formatted output.

Implementation Permissions

  1. Other exceptions declared (by renaming) in Text_IO may be raised by the preceding procedures in the appropriate circumstances, as for the corresponding procedures of Text_IO.Float_IO.

The Package Wide_Text_IO.Complex_IO

Static Semantics

  1. Implementations shall also provide the generic library package Wide_Text_IO.Complex_IO. Its declaration is obtained from that of Text_IO.Complex_IO by systematically replacing Text_IO by Wide_Text_IO and String by Wide_String; the description of its behavior is obtained by additionally replacing references to particular characters (commas, parentheses, etc.) by those for the corresponding wide characters.

Numeric Performance Requirements

Implementation Requirements

  1. Implementations shall provide a user-selectable mode in which the accuracy and other numeric performance requirements detailed in the following subclauses are observed. This mode, referred to as the strict mode, may or may not be the default mode; it directly affects the results of the predefined arithmetic operations of real types and the results of the subprograms in children of the Numerics package, and indirectly affects the operations in other language defined packages. Implementations shall also provide the opposing mode, which is known as the relaxed mode.

    Implementation Permissions

  2. Either mode may be the default mode.
  3. The two modes need not actually be different.

Model of Floating Point Arithmetic

  1. In the strict mode, the predefined operations of a floating point type shall satisfy the accuracy requirements specified here and shall avoid or signal overflow in the situations described. This behavior is presented in terms of a model of floating point arithmetic that builds on the concept of the canonical form, see section Attributes of Floating Point Types.

    Static Semantics

  2. Associated with each floating point type is an infinite set of model numbers. The model numbers of a type are used to define the accuracy requirements that have to be satisfied by certain predefined operations of the type; through certain attributes of the model numbers, they are also used to explain the meaning of a user-declared floating point type declaration. The model numbers of a derived type are those of the parent type; the model numbers of a subtype are those of its type.
  3. The model numbers of a floating point type T are zero and all the values expressible in the canonical form (for the type T), in which mantissa has T'Model_Mantissa digits and exponent has a value greater than or equal to T'Model_Emin. (These attributes are defined in section Model-Oriented Attributes of Floating Point Types.)
  4. A model interval of a floating point type is any interval whose bounds are model numbers of the type. The model interval of a type T associated with a value v is the smallest model interval of T that includes v. (The model interval associated with a model number of a type consists of that number only.)

    Implementation Requirements

  5. The accuracy requirements for the evaluation of certain predefined operations of floating point types are as follows.
  6. An operand interval is the model interval, of the type specified for the operand of an operation, associated with the value of the operand.
  7. For any predefined arithmetic operation that yields a result of a floating point type T, the required bounds on the result are given by a model interval of T (called the result interval) defined in terms of the operand values as follows:
    1. The result interval is the smallest model interval of T that includes the minimum and the maximum of all the values obtained by applying the (exact) mathematical operation to values arbitrarily selected from the respective operand intervals.
  1. The result interval of an exponentiation is obtained by applying the above rule to the sequence of multiplications defined by the exponent, assuming arbitrary association of the factors, and to the final division in the case of a negative exponent.
  2. The result interval of a conversion of a numeric value to a floating point type T is the model interval of T associated with the operand value, except when the source expression is of a fixed point type with a small that is not a power of T'Machine_Radix or is a fixed point multiplication or division either of whose operands has a small that is not a power of T'Machine_Radix; in these cases, the result interval is implementation defined.
  3. For any of the foregoing operations, the implementation shall deliver a value that belongs to the result interval when both bounds of the result interval are in the safe range of the result type T, as determined by the values of T'Safe_First and T'Safe_Last; otherwise,
    1. if T'Machine_Overflows is True, the implementation shall either deliver a value that belongs to the result interval or raise Constraint_Error;
    2. if T'Machine_Overflows is False, the result is implementation defined.
  1. For any predefined relation on operands of a floating point type T, the implementation may deliver any value (i.e., either True or False) obtained by applying the (exact) mathematical comparison to values arbitrarily chosen from the respective operand intervals.
  2. The result of a membership test is defined in terms of comparisons of the operand value with the lower and upper bounds of the given range or type mark (the usual rules apply to these comparisons).

    Implementation Permissions

  3. If the underlying floating point hardware implements division as multiplication by a reciprocal, the result interval for division (and exponentiation by a negative exponent) is implementation defined.

Model-Oriented Attributes of Floating Point Types

  1. In implementations that support the Numerics Annex, the model-oriented attributes of floating point types shall yield the values defined here, in both the strict and the relaxed modes. These definitions add conditions to those in section Attributes of Floating Point Types.

    Static Semantics

  2. For every subtype S of a floating point type T:
  3. S'Model_Mantissa 
    Yields the number of digits in the mantissa of the
canonical form of the model numbers of T, see section Attributes of Floating Point Types.
The value of this attribute shall be greater than or
equal to Ceiling(d*log (10)/log (T'Machine_Radix))+1,
where d is the requested decimal precision of T. In
addition, it shall be less than or equal to the value of
T'Machine_Mantissa. This attribute yields a value of the
type universal_integer.
  4. S'Model_Emin 
    Yields the minimum exponent of the canonical form of the model
numbers of T, see section Attributes of Floating Point Types. The value of this attribute shall
be greater than or equal to the value of T'Machine_Emin. This
attribute yields a value of the type universal_integer.
  5. S'Safe_First 
    Yields the lower bound of the safe range of T. The value of
this attribute shall be a model number of T and greater than
or equal to the lower bound of the base range of T. In
addition, if T is declared by a floating_point_definition or
is derived from such a type, and the
floating_point_definition includes a real_range_specification
specifying a lower bound of lb, then the value of this
attribute shall be less than or equal to lb; otherwise, it
shall be less than or equal to -10.0 ** (4*d), where d is the
requested decimal precision of T. This attribute yields a
value of the type universal_real.
  6. S'Safe_Last 
    Yields the upper bound of the safe range of T. The value of
this attribute shall be a model number of T and less than or
equal to the upper bound of the base range of T. In
addition, if T is declared by a floating_point_definition or
is derived from such a type, and the floating_point_definition
includes a real_range_specification specifying an
upper bound of ub, then the value of this attribute shall be
greater than or equal to ub; otherwise, it shall be greater
than or equal to 10.0 ** (4*d), where d is the requested
decimal precision of T. This attribute yields a value of the
type universal_real.
  7. S'Model 
    Denotes a function (of a parameter X) whose specification is
given in section Attributes of Floating Point Types. If X is a model number of T, the
function yields X; otherwise, it yields the value obtained by
rounding or truncating X to either one of the adjacent model
numbers of T. Constraint_Error is raised if the resulting model
number is outside the safe range of S. A zero result has the
sign of X when S'Signed_Zeros is True.
  8. Subject to the constraints given above, the values of S'Model_Mantissa and S'Safe_Last are to be maximized, and the values of S'Model_Emin and S'Safe_First minimized, by the implementation as follows:
    1. First, S'Model_Mantissa is set to the largest value for which values of S'Model_Emin, S'Safe_First, and S'Safe_Last can be chosen so that the implementation satisfies the strict-mode requirements of section Model of Floating Point Arithmetic, in terms of the model numbers and safe range induced by these attributes.
    2. Next, S'Model_Emin is set to the smallest value for which values of S'Safe_First and S'Safe_Last can be chosen so that the implementation satisfies the strict-mode requirements of section Model of Floating Point Arithmetic, in terms of the model numbers and safe range induced by these attributes and the previously determined value of S'Model_Mantissa.
    3. Finally, S'Safe_First and S'Safe_last are set (in either order) to the smallest and largest values, respectively, for which the implementation satisfies the strict-mode requirements of section Model of Floating Point Arithmetic, in terms of the model numbers and safe range induced by these attributes and the previously determined values of S'Model_Mantissa and S'Model_Emin.

Model of Fixed Point Arithmetic

  1. In the strict mode, the predefined arithmetic operations of a fixed point type shall satisfy the accuracy requirements specified here and shall avoid or signal overflow in the situations described.

    Implementation Requirements

  2. The accuracy requirements for the predefined fixed point arithmetic operations and conversions, and the results of relations on fixed point operands, are given below.
  3. The operands of the fixed point adding operators, absolute value, and comparisons have the same type. These operations are required to yield exact results, unless they overflow.
  4. Multiplications and divisions are allowed between operands of any two fixed point types; the result has to be (implicitly or explicitly) converted to some other numeric type. For purposes of defining the accuracy rules, the multiplication or division and the conversion are treated as a single operation whose accuracy depends on three types (those of the operands and the result). For decimal fixed point types, the attribute T'Round may be used to imply explicit conversion with rounding, see section Operations of Fixed Point Types.
  5. When the result type is a floating point type, the accuracy is as given in section Model of Floating Point Arithmetic. For some combinations of the operand and result types in the remaining cases, the result is required to belong to a small set of values called the perfect result set; for other combinations, it is required merely to belong to a generally larger and implementation-defined set of values called the close result set. When the result type is a decimal fixed point type, the perfect result set contains a single value; thus, operations on decimal types are always fully specified.
  6. When one operand of a fixed-fixed multiplication or division is of type universal_real, that operand is not implicitly converted in the usual sense, since the context does not determine a unique target type, but the accuracy of the result of the multiplication or division (i.e., whether the result has to belong to the perfect result set or merely the close result set) depends on the value of the operand of type universal_real and on the types of the other operand and of the result.
  7. For a fixed point multiplication or division whose (exact) mathematical result is v, and for the conversion of a value v to a fixed point type, the perfect result set and close result set are defined as follows:
    1. If the result type is an ordinary fixed point type with a small of s,
        1. if v is an integer multiple of s, then the perfect result set contains only the value v;
        2. otherwise, it contains the integer multiple of s just below v and the integer multiple of s just above v.
      1. The close result set is an implementation-defined set of consecutive integer multiples of s containing the perfect result set as a subset.
    1. If the result type is a decimal type with a small of s,
        1. if v is an integer multiple of s, then the perfect result set contains only the value v;
        2. otherwise, if truncation applies then it contains only the integer multiple of s in the direction toward zero, whereas if rounding applies then it contains only the nearest integer multiple of s (with ties broken by rounding away from zero).
      1. The close result set is an implementation-defined set of consecutive integer multiples of s containing the perfect result set as a subset.
    1. If the result type is an integer type,
        1. if v is an integer, then the perfect result set contains only the value v;
        2. otherwise, it contains the integer nearest to the value v (if v lies equally distant from two consecutive integers, the perfect result set contains the one that is further from zero).
      1. The close result set is an implementation-defined set of consecutive integers containing the perfect result set as a subset.
  1. The result of a fixed point multiplication or division shall belong either to the perfect result set or to the close result set, as described below, if overflow does not occur. In the following cases, if the result type is a fixed point type, let s be its small; otherwise, i.e. when the result type is an integer type, let s be 1.0.
    1. For a multiplication or division neither of whose operands is of type universal_real, let l and r be the smalls of the left and right operands. For a multiplication, if (l*r)/s is an integer or the reciprocal of an integer (the smalls are said to be "compatible" in this case), the result shall belong to the perfect result set; otherwise, it belongs to the close result set. For a division, if l/(r*s) is an integer or the reciprocal of an integer (i.e., the smalls are compatible), the result shall belong to the perfect result set; otherwise, it belongs to the close result set.
    2. For a multiplication or division having one universal_real operand with a value of v, note that it is always possible to factor v as an integer multiple of a "compatible" small, but the integer multiple may be "too big." If there exists a factorization in which that multiple is less than some implementation-defined limit, the result shall belong to the perfect result set; otherwise, it belongs to the close result set.
  1. A multiplication P * Q of an operand of a fixed point type F by an operand of an integer type I, or vice-versa, and a division P / Q of an operand of a fixed point type F by an operand of an integer type I, are also allowed. In these cases, the result has a type of F; explicit conversion of the result is never required. The accuracy required in these cases is the same as that required for a multiplication F(P * Q) or a division F(P / Q) obtained by interpreting the operand of the integer type to have a fixed point type with a small of 1.0.
  2. The accuracy of the result of a conversion from an integer or fixed point type to a fixed point type, or from a fixed point type to an integer type, is the same as that of a fixed point multiplication of the source value by a fixed point operand having a small of 1.0 and a value of 1.0, as given by the foregoing rules. The result of a conversion from a floating point type to a fixed point type shall belong to the close result set. The result of a conversion of a universal_real operand to a fixed point type shall belong to the perfect result set.
  3. The possibility of overflow in the result of a predefined arithmetic operation or conversion yielding a result of a fixed point type T is analogous to that for floating point types, except for being related to the base range instead of the safe range. If all of the permitted results belong to the base range of T, then the implementation shall deliver one of the permitted results; otherwise,
    1. if T'Machine_Overflows is True, the implementation shall either deliver one of the permitted results or raise Constraint_Error;
    2. if T'Machine_Overflows is False, the result is implementation defined.

Accuracy Requirements for the Elementary Functions

  1. In the strict mode, the performance of Numerics.Generic_Elementary_Functions shall be as specified here.

    Implementation Requirements

  2. When an exception is not raised, the result of evaluating a function in an instance EF of Numerics.Generic_Elementary_Functions belongs to a result interval, defined as the smallest model interval of EF.Float_Type that contains all the values of the form f*(1.0+d), where f is the exact value of the corresponding mathematical function at the given parameter values, d is a real number, and |d| is less than or equal to the function's maximum relative error. The function delivers a value that belongs to the result interval when both of its bounds belong to the safe range of EF.Float_Type; otherwise,
    1. if EF.Float_Type'Machine_Overflows is True, the function either delivers a value that belongs to the result interval or raises Constraint_Error, signaling overflow;
    2. if EF.Float_Type'Machine_Overflows is False, the result is implementation defined.
  1. The maximum relative error exhibited by each function is as follows:
    1. 2.0*EF.Float_Type'Model_Epsilon, in the case of the Sqrt, Sin, and Cos functions;
    2. 4.0*EF.Float_Type'Model_Epsilon, in the case of the Log, Exp, Tan, Cot, and inverse trigonometric functions; and
    3. 8.0*EF.Float_Type'Model_Epsilon, in the case of the forward and inverse hyperbolic functions.
  1. The maximum relative error exhibited by the exponentiation operator, which depends on the values of the operands, is (4.0+|Right*log (Left)|/32.0)*EF.Float_Type'Model_Epsilon.
  2. The maximum relative error given above applies throughout the domain of the forward trigonometric functions when the Cycle parameter is specified. When the Cycle parameter is omitted, the maximum relative error given above applies only when the absolute value of the angle parameter X is less than or equal to some implementation-defined angle threshold, which shall be at least EF.Float_Type'Machine_Radix ** Floor(EF.Float_Type'Machine_Mantissa/2). Beyond the angle threshold, the accuracy of the forward trigonometric functions is implementation defined.
  3. The prescribed results specified in section Elementary Functions, for certain functions at particular parameter values take precedence over the maximum relative error bounds; effectively, they narrow to a single value the result interval allowed by the maximum relative error bounds. Additional rules with a similar effect are given by the table below for the inverse trigonometric functions, at particular parameter values for which the mathematical result is possibly not a model number of EF.Float_Type (or is, indeed, even transcendental). In each table entry, the values of the parameters are such that the result lies on the axis between two quadrants; the corresponding accuracy rule, which takes precedence over the maximum relative error bounds, is that the result interval is the model interval of EF.Float_Type associated with the exact mathematical result given in the table. 
  4.   +--------------------------------------------------------------+
  |                                                              |
  |       Tightly Approximated Elementary Function Results       |
  |                                                              |
  +-----------------+----------+----------+------------+-------- +
  |                 |          |          |            |         |
  |                 |          |          |   Exact    | Exact   |
  |                 |          |          |   Result   | Result  |
  |                 | Value of | Value of | when Cycle | when    |
  |    Function     |     X    |     Y    | Specified  | Cycle   |
  |                 |          |          |            | Omitted |
  |                 |          |          |            |         |
  +-----------------+----------+----------+------------+---------+
  |                 |          |          |            |         |
  |     Arcsin      |   1.0    |   n.a.   | Cycle/4.0  |  Pi/2.0 |
  |                 |          |          |            |         |
  |     Arcsin      |   -1.0   |   n.a.   | -Cycle/4.0 | -Pi/2.0 |
  |                 |          |          |            |         |
  |     Arccos      |   0.0    |   n.a.   | Cycle/4.0  |  Pi/2.0 |
  |                 |          |          |            |         |
  |     Arccos      |   -1.0   |   n.a.   | Cycle/2.0  |    Pi   |
  |                 |          |          |            |         |
  | Arctan & Arccot |   0.0    | positive | Cycle/4.0  |  Pi/2.0 |
  |                 |          |          |            |         |
  | Arctan & Arccot |   0.0    | negative | -Cycle/4.0 | -Pi/2.0 |
  |                 |          |          |            |         |
  | Arctan & Arccot | negative |   +0.0   | Cycle/2.0  |    Pi   |
  |                 |          |          |            |         |
  | Arctan & Arccot | negative |   -0.0   | -Cycle/2.0 |   -Pi   |
  |                 |          |          |            |         |
  | Arctan & Arccot | negative |   0.0    | Cycle/2.0  |    Pi   |
  |                 |          |          |            |         |
  +-----------------+----------+----------+------------+---------+
  5. The last line of the table is meant to apply when EF.Float_Type'Signed_ Zeros is False; the two lines just above it, when EF.Float_Type'Signed_Zeros is True and the parameter Y has a zero value with the indicated sign.
  6. The amount by which the result of an inverse trigonometric function is allowed to spill over into a quadrant adjacent to the one corresponding to the principal branch, as given in section Elementary Functions, is limited. The rule is that the result belongs to the smallest model interval of EF.Float_Type that contains both boundaries of the quadrant corresponding to the principal branch. This rule also takes precedence over the maximum relative error bounds, effectively narrowing the result interval allowed by them.
  7. Finally, the following specifications also take precedence over the maximum relative error bounds:
    1. The absolute value of the result of the Sin, Cos, and Tanh functions never exceeds one.
    2. The absolute value of the result of the Coth function is never less than one.
    3. The result of the Cosh function is never less than one.

Implementation Advice

  1. The versions of the forward trigonometric functions without a Cycle parameter should not be implemented by calling the corresponding version with a Cycle parameter of 2.0*Numerics.Pi, since this will not provide the required accuracy in some portions of the domain. For the same reason, the version of Log without a Base parameter should not be implemented by calling the corresponding version with a Base parameter of Numerics.e.

Performance Requirements for Random Number Generation

  1. In the strict mode, the performance of Numerics.Float_Random and Numerics.Discrete_Random shall be as specified here.

    Implementation Requirements

  2. Two different calls to the time-dependent Reset procedure shall reset the generator to different states, provided that the calls are separated in time by at least one second and not more than fifty years.
  3. The implementation's representations of generator states and its algorithms for generating random numbers shall yield a period of at least 2**31-2; much longer periods are desirable but not required.
  4. The implementations of Numerics.Float_Random.Random and Numerics.Discrete_Random.Random shall pass at least 85% of the individual trials in a suite of statistical tests. For Numerics.Float_Random, the tests are applied directly to the floating point values generated (i.e., they are not converted to integers first), while for Numerics.Discrete_Random they are applied to the generated values of various discrete types. Each test suite performs 6 different tests, with each test repeated 10 times, yielding a total of 60 individual trials. An individual trial is deemed to pass if the chi-square value (or other statistic) calculated for the observed counts or distribution falls within the range of values corresponding to the 2.5 and 97.5 percentage points for the relevant degrees of freedom (i.e., it shall be neither too high nor too low). For the purpose of determining the degrees of freedom, measurement categories are combined whenever the expected counts are fewer than 5.

Accuracy Requirements for Complex Arithmetic

  1. In the strict mode, the performance of Numerics.Generic_Complex_Types and Numerics.Generic_Complex_Elementary_Functions shall be as specified here.

    Implementation Requirements

  2. When an exception is not raised, the result of evaluating a real function of an instance CT of Numerics.Generic_Complex_Types (i.e., a function that yields a value of subtype CT.Real'Base or CT.Imaginary) belongs to a result interval defined as for a real elementary function (see section Accuracy Requirements for the Elementary Functions).
  3. When an exception is not raised, each component of the result of evaluating a complex function of such an instance, or of an instance of Numerics.Generic_Complex_Elementary_Functions obtained by instantiating the latter with CT (i.e., a function that yields a value of subtype CT.Complex), also belongs to a result interval. The result intervals for the components of the result are either defined by a maximum relative error bound or by a maximum box error bound. When the result interval for the real (resp., imaginary) component is defined by maximum relative error, it is defined as for that of a real function, relative to the exact value of the real (resp., imaginary) part of the result of the corresponding mathematical function. When defined by maximum box error, the result interval for a component of the result is the smallest model interval of CT.Real that contains all the values of the corresponding part of f*(1.0+d), where f is the exact complex value of the corresponding mathematical function at the given parameter values, d is complex, and |d| is less than or equal to the given maximum box error. The function delivers a value that belongs to the result interval (or a value both of whose components belong to their respective result intervals) when both bounds of the result interval(s) belong to the safe range of CT.Real; otherwise,
    1. if CT.Real'Machine_Overflows is True, the function either delivers a value that belongs to the result interval (or a value both of whose components belong to their respective result intervals) or raises Constraint_Error, signaling overflow;
    2. if CT.Real'Machine_Overflows is False, the result is implementation defined.
  1. The error bounds for particular complex functions are tabulated below. In the table, the error bound is given as the coefficient of CT.Real'Model_Epsilon. 
  2.   +-----------------------------------------------------------------+
  |                                                                 |
  |          Error Bounds for Particular Complex Functions          |
  |                                                                 |
  +-----------------------------+---------+-----------------+-------+
  |                             |         |                 |       |
  |                             | Nature  |    Nature of    | Error |
  |    Function or Operator     |   of    |      Bound      | Bound |
  |                             | Result  |                 |       |
  |                             |         |                 |       |
  +-----------------------------+---------+-----------------+-------+
  |                             |         |                 |       |
  |           Modulus           |  real   | max. rel. error |   3.0 |
  |                             |         |                 |       |
  |          Argument           |  real   | max. rel. error |   4.0 |
  |                             |         |                 |       |
  |     Compose_From_Polar      | complex | max. rel. error |   3.0 |
  |                             |         |                 |       |
  | "*" (both operands complex) | complex | max. box error  |   5.0 |
  |                             |         |                 |       |
  | "/" (right operand complex) | complex | max. box error  |  13.0 |
  |                             |         |                 |       |
  |            Sqrt             | complex | max. rel. error |   6.0 |
  |                             |         |                 |       |
  |             Log             | complex | max. box error  |  13.0 |
  |                             |         |                 |       |
  |   Exp (complex parameter)   | complex | max. rel. error |   7.0 |
  |                             |         |                 |       |
  |  Exp (imaginary parameter)  | complex | max. rel. error |   2.0 |
  |                             |         |                 |       |
  |  Sin, Cos, Sinh, and Cosh   | complex | max. rel. error |  11.0 |
  |                             |         |                 |       |
  |  Tan, Cot, Tanh, and Coth   | complex | max. rel. error |  35.0 |
  |                             |         |                 |       |
  |    inverse trigonometric    | complex | max. rel. error |  14.0 |
  |                             |         |                 |       |
  |     inverse hyperbolic      | complex | max. rel. error |  14.0 |
  |                             |         |                 |       |
  +-----------------------------+---------+-----------------+-------+
  3. The maximum relative error given above applies throughout the domain of the Compose_From_Polar function when the Cycle parameter is specified. When the Cycle parameter is omitted, the maximum relative error applies only when the absolute value of the parameter Argument is less than or equal to the angle threshold, see section Accuracy Requirements for the Elementary Functions. For the Exp function, and for the forward hyperbolic (resp., trigonometric) functions, the maximum relative error given above likewise applies only when the absolute value of the imaginary (resp., real) component of the parameter X (or the absolute value of the parameter itself, in the case of the Exp function with a parameter of pure-imaginary type) is less than or equal to the angle threshold. For larger angles, the accuracy is implementation defined.
  4. The prescribed results specified in section Complex Elementary Functions, for certain functions at particular parameter values take precedence over the error bounds; effectively, they narrow to a single value the result interval allowed by the error bounds for a component of the result. Additional rules with a similar effect are given below for certain inverse trigonometric and inverse hyperbolic functions, at particular parameter values for which a component of the mathematical result is transcendental. In each case, the accuracy rule, which takes precedence over the error bounds, is that the result interval for the stated result component is the model interval of CT.Real associated with the component's exact mathematical value. The cases in question are as follows:
    1. When the parameter X has the value zero, the real (resp., imaginary) component of the result of the Arccot (resp., Arccoth) function is in the model interval of CT.Real associated with the value Pi/2.0.
    2. When the parameter X has the value one, the real component of the result of the Arcsin function is in the model interval of CT.Real associated with the value Pi/2.0.
    3. When the parameter X has the value -1.0, the real component of the result of the Arcsin (resp., Arccos) function is in the model interval of CT.Real associated with the value -Pi/2.0 (resp., Pi).
  1. The amount by which a component of the result of an inverse trigonometric or inverse hyperbolic function is allowed to spill over into a quadrant adjacent to the one corresponding to the principal branch, as given in section Complex Elementary Functions, is limited. The rule is that the result belongs to the smallest model interval of CT.Real that contains both boundaries of the quadrant corresponding to the principal branch. This rule also takes precedence to the maximum error bounds, effectively narrowing the result interval allowed by them.
  2. Finally, the results allowed by the error bounds are narrowed by one further rule: The absolute value of each component of the result of the Exp function, for a pure-imaginary parameter, never exceeds one.

    Implementation Advice

  3. The version of the Compose_From_Polar function without a Cycle parameter should not be implemented by calling the corresponding version with a Cycle parameter of 2.0*Numerics.Pi, since this will not provide the required accuracy in some portions of the domain.

Safety and Security (normative)

  1. This Annex addresses requirements for systems that are safety critical or have security constraints. It provides facilities and specifies documentation requirements that relate to several needs:
    1. Understanding program execution;
    2. Reviewing object code;
    3. Restricting language constructs whose usage might complicate the demonstration of program correctness
    Execution understandability is supported by pragma Normalize_Scalars, and also by requirements for the implementation to document the effect of a program in the presence of a bounded error or where the language rules leave the effect unspecified.
  1. The pragmas Reviewable and Restrictions relate to the other requirements addressed by this Annex. NOTES
  2. (1) The Valid attribute, see section The Valid Attribute, is also useful in addressing these needs, to avoid problems that could otherwise arise from scalars that have values outside their declared range constraints.

Pragma Normalize_Scalars

  1. This pragma ensures that an otherwise uninitialized scalar object is set to a predictable value, but out of range if possible.

    Syntax

  2. The form of a pragma Normalize_Scalars is as follows: 
  3. pragma Normalize_Scalars;

    Post-Compilation Rules

  4. Pragma Normalize_Scalars is a configuration pragma. It applies to all compilation_units included in a partition.

    Documentation Requirements

  5. If a pragma Normalize_Scalars applies, the implementation shall document the implicit initial value for scalar subtypes, and shall identify each case in which such a value is used and is not an invalid representation.

    Implementation Advice

  6. Whenever possible, the implicit initial value for a scalar subtype should be an invalid representation, see section Data Validity. NOTES
  7. (2) The initialization requirement applies to uninitialized scalar objects that are subcomponents of composite objects, to allocated objects, and to stand-alone objects. It also applies to scalar out parameters. Scalar subcomponents of composite out parameters are initialized to the corresponding part of the actual, by virtue of section Parameter Associations.
  8. (3) The initialization requirement does not apply to a scalar for which pragma Import has been specified, since initialization of an imported object is performed solely by the foreign language environment (see section Interfacing Pragmas).
  9. (4) The use of pragma Normalize_Scalars in conjunction with Pragma Restrictions(No_Exceptions) may result in erroneous execution (see section Safety and Security Restrictions).

Documentation of Implementation Decisions

Documentation Requirements

  1. The implementation shall document the range of effects for each situation that the language rules identify as either a bounded error or as having an unspecified effect. If the implementation can constrain the effects of erroneous execution for a given construct, then it shall document such constraints. The documentation might be provided either independently of any compilation unit or partition, or as part of an annotated listing for a given unit or partition. See also section Conformity of an Implementation with the Standard, and section Structure. NOTES
  2. (5) Among the situations to be documented are the conventions chosen for parameter passing, the methods used for the management of run-time storage, and the method used to evaluate numeric expressions if this involves extended range or extra precision.

Reviewable Object Code

  1. Object code review and validation are supported by pragmas Reviewable and Inspection_Point.

Pragma Reviewable

  1. This pragma directs the implementation to provide information to facilitate analysis and review of a program's object code, in particular to allow determination of execution time and storage usage and to identify the correspondence between the source and object programs.

    Syntax

  2. The form of a pragma Reviewable is as follows: 
  3. pragma Reviewable;

    Post-Compilation Rules

  4. Pragma Reviewable is a configuration pragma. It applies to all compilation_units included in a partition.

    Implementation Requirements

  5. The implementation shall provide the following information for any compilation unit to which such a pragma applies:
    1. Where compiler-generated run-time checks remain;
    2. An identification of any construct with a language-defined check that is recognized prior to run time as certain to fail if executed (even if the generation of run-time checks has been suppressed);
    3. For each reference to a scalar object, an identification of the reference as either "known to be initialized," or "possibly uninitialized," independent of whether pragma Normalize_Scalars applies;
    4. Where run-time support routines are implicitly invoked;
    5. An object code listing, including:
      1. Machine instructions, with relative offsets;
      2. Where each data object is stored during its lifetime;
      3. Correspondence with the source program, including an identification of the code produced per declaration and per statement.
    1. An identification of each construct for which the implementation detects the possibility of erroneous execution;
    2. For each subprogram, block, task, or other construct implemented by reserving and subsequently freeing an area on a run-time stack, an identification of the length of the fixed-size portion of the area and an indication of whether the non-fixed size portion is reserved on the stack or in a dynamically-managed storage region.
  1. The implementation shall provide the following information for any partition to which the pragma applies:
    1. An object code listing of the entire partition, including initialization and finalization code as well as run-time system components, and with an identification of those instructions and data that will be relocated at load time;
    2. A description of the run-time model relevant to the partition.
    The implementation shall provide control- and data-flow information, both within each compilation unit and across the compilation units of the partition.

    Implementation Advice

  1. The implementation should provide the above information in both a human-readable and machine-readable form, and should document the latter so as to ease further processing by automated tools.
  2. Object code listings should be provided both in a symbolic format and also in an appropriate numeric format (such as hexadecimal or octal). NOTES
  3. (6) The order of elaboration of library units will be documented even in the absence of pragma Reviewable, see section Program Execution.

Pragma Inspection_Point

  1. An occurrence of a pragma Inspection_Point identifies a set of objects each of whose values is to be available at the point(s) during program execution corresponding to the position of the pragma in the compilation unit. The purpose of such a pragma is to facilitate code validation.

    Syntax

  2. The form of a pragma Inspection_Point is as follows: 
  3. pragma Inspection_Point[(object_name {, object_name})];

    Legality Rules

  4. A pragma Inspection_Point is allowed wherever a declarative_item or statement is allowed. Each object_name shall statically denote the declaration of an object.

    Static Semantics

  5. An inspection point is a point in the object code corresponding to the occurrence of a pragma Inspection_Point in the compilation unit. An object is inspectable at an inspection point if the corresponding pragma Inspection_Point either has an argument denoting that object, or has no arguments.

    Dynamic Semantics

  6. Execution of a pragma Inspection_Point has no effect.

    Implementation Requirements

  7. Reaching an inspection point is an external interaction with respect to the values of the inspectable objects at that point, see section Conformity of an Implementation with the Standard.

    Documentation Requirements

  8. For each inspection point, the implementation shall identify a mapping between each inspectable object and the machine resources (such as memory locations or registers) from which the object's value can be obtained. NOTES
  9. (7) The implementation is not allowed to perform "dead store elimination" on the last assignment to a variable prior to a point where the variable is inspectable. Thus an inspection point has the effect of an implicit reference to each of its inspectable objects.
  10. (8) Inspection points are useful in maintaining a correspondence between the state of the program in source code terms, and the machine state during the program's execution. Assertions about the values of program objects can be tested in machine terms at inspection points. Object code between inspection points can be processed by automated tools to verify programs mechanically.
  11. (9) The identification of the mapping from source program objects to machine resources is allowed to be in the form of an annotated object listing, in human-readable or tool-processable form.

Safety and Security Restrictions

  1. This clause defines restrictions that can be used with pragma Restrictions, see section Pragma Restrictions, these facilitate the demonstration of program correctness by allowing tailored versions of the run-time system.

    Static Semantics

  2. The following restrictions, the same as in section Tasking Restrictions, apply in this Annex: No_Task_Hierarchy, No_Abort_Statement, No_Implicit_Heap_Allocation, Max_Task_Entries is 0, Max_Asynchronous_Select_Nesting is 0, and Max_Tasks is 0. The last three restrictions are checked prior to program execution.
  3. The following additional restrictions apply in this Annex.
  4. Tasking-related restriction:
  5. No_Protected_Types 
    There are no declarations of protected types or protected
objects.
  6. Memory-management related restrictions:
  7. No_Allocators 
    There are no occurrences of an allocator.
  8. No_Local_Allocators 
    Allocators are prohibited in subprograms, generic sub-programs,
tasks, and entry bodies; instantiations of generic
packages are also prohibited in these contexts.
  9. No_Unchecked_Deallocation 
    Semantic dependence on Unchecked_Deallocation is not allowed.
  10. Immediate_Reclamation 
    Except for storage occupied by objects created by allocators
and not deallocated via unchecked deallocation, any storage
reserved at run time for an object is immediately reclaimed
when the object no longer exists.
  11. Exception-related restriction:
  12. No_Exceptions 
    Raise_statements and exception_handlers are not allowed. No
language-defined run-time checks are generated; however, a
run-time check performed automatically by the hardware is
permitted.
  13. Other restrictions:
  14. No_Floating_Point 
    Uses of predefined floating point types and operations, and
declarations of new floating point types, are not allowed.
  15. No_Fixed_Point 
    Uses of predefined fixed point types and operations, and
declarations of new fixed point types, are not allowed.
  16. No_Unchecked_Conversion 
    Semantic dependence on the predefined generic
Unchecked_Conversion is not allowed.
  17. No_Access_Subprograms 
    The declaration of access-to-subprogram types is not allowed.
  18. No_Unchecked_Access 
    The Unchecked_Access attribute is not allowed.
  19. No_Dispatch 
    Occurrences of T'Class are not allowed, for any (tagged)
subtype T.
  20. No_IO 
    Semantic dependence on any of the library units
Sequential_IO, Direct_IO, Text_IO, Wide_Text_IO, or Stream_IO
is not allowed.
  21. No_Delay 
    Delay_Statements and semantic dependence on package Calendar
are not allowed.
  22. No_Recursion 
    As part of the execution of a subprogram, the same subprogram
is not invoked.
  23. No_Reentrancy 
    During the execution of a subprogram by a task, no other task
invokes the same subprogram.

    Implementation Requirements

  24. If an implementation supports pragma Restrictions for a particular argument, then except for the restrictions No_Unchecked_Deallocation, No_Unchecked_Conversion, No_Access_Subprograms, and No_Unchecked_Access, the associated restriction applies to the run-time system.

    Documentation Requirements

  25. If a pragma Restrictions(No_Exceptions) is specified, the implementation shall document the effects of all constructs where language-defined checks are still performed automatically (for example, an overflow check performed by the processor).

    Erroneous Execution

  26. Program execution is erroneous if pragma Restrictions(No_Exceptions) has been specified and the conditions arise under which a generated language-defined run-time check would fail.
  27. Program execution is erroneous if pragma Restrictions(No_Recursion) has been specified and a subprogram is invoked as part of its own execution, or if pragma Restrictions(No_Reentrancy) has been specified and during the execution of a subprogram by a task, another task invokes the same subprogram.

Obsolescent Features (normative)

  1. This Annex contains descriptions of features of the language whose functionality is largely redundant with other features defined by this International Standard. Use of these features is not recommended in newly written programs.

Renamings of Ada 83 Library Units

Static Semantics

  1. The following library_unit_renaming_declarations exist: 
  2. with Ada.Unchecked_Conversion;
generic function Unchecked_Conversion
  renames Ada.Unchecked_Conversion;

  3. with Ada.Unchecked_Deallocation;
generic procedure Unchecked_Deallocation
  renames Ada.Unchecked_Deallocation;

  4. with Ada.Sequential_IO;
generic package Sequential_IO renames Ada.Sequential_IO;

  5. with Ada.Direct_IO;
generic package Direct_IO renames Ada.Direct_IO;

  6. with Ada.Text_IO;
package Text_IO renames Ada.Text_IO;

  7. with Ada.IO_Exceptions;
package IO_Exceptions renames Ada.IO_Exceptions;

  8. with Ada.Calendar;
package Calendar renames Ada.Calendar;

  9. with System.Machine_Code;
package Machine_Code renames System.Machine_Code; -- If supported.

    Implementation Requirements

  10. The implementation shall allow the user to replace these renamings.

Allowed Replacements of Characters

Syntax

  1. The following replacements are allowed for the vertical line, number sign, and quotation mark characters:
    1. A vertical line character (|) can be replaced by an exclamation mark (!) where used as a delimiter.
    2. The number sign characters (#) of a based_literal can be replaced by colons (:) provided that the replacement is done for both occurrences.
    3. The quotation marks (") used as string brackets at both ends of a string literal can be replaced by percent signs (%) provided that the enclosed sequence of characters contains no quotation mark, and provided that both string brackets are replaced. Any percent sign within the sequence of characters shall then be doubled and each such doubled percent sign is interpreted as a single percent sign character value.
    4. These replacements do not change the meaning of the program.

Reduced Accuracy Subtypes

  1. A digits_constraint may be used to define a floating point subtype with a new value for its requested decimal precision, as reflected by its Digits attribute. Similarly, a delta_constraint may be used to define an ordinary fixed point subtype with a new value for its delta, as reflected by its Delta attribute.

    Syntax 

  2. delta_constraint ::= delta static_expression [range_constraint]

    Name Resolution Rules

  3. The expression of a delta_constraint is expected to be of any real type.

    Legality Rules

  4. The expression of a delta_constraint shall be static.
  5. For a subtype_indication with a delta_constraint, the subtype_mark shall denote an ordinary fixed point subtype.
  6. For a subtype_indication with a digits_constraint, the subtype_mark shall denote either a decimal fixed point subtype or a floating point subtype (notwithstanding the rule given in section Fixed Point Types, that only allows a decimal fixed point subtype).

    Static Semantics

  7. A subtype_indication with a subtype_mark that denotes an ordinary fixed point subtype and a delta_constraint defines an ordinary fixed point subtype with a delta given by the value of the expression of the delta_constraint. If the delta_constraint includes a range_constraint, then the ordinary fixed point subtype is constrained by the range_constraint.
  8. A subtype_indication with a subtype_mark that denotes a floating point subtype and a digits_constraint defines a floating point subtype with a requested decimal precision (as reflected by its Digits attribute) given by the value of the expression of the digits_constraint. If the digits_constraint includes a range_constraint, then the floating point subtype is constrained by the range_constraint.

    Dynamic Semantics

  9. A delta_constraint is compatible with an ordinary fixed point subtype if the value of the expression is no less than the delta of the subtype, and the range_constraint, if any, is compatible with the subtype.
  10. A digits_constraint is compatible with a floating point subtype if the value of the expression is no greater than the requested decimal precision of the subtype, and the range_constraint, if any, is compatible with the subtype.
  11. The elaboration of a delta_constraint consists of the elaboration of the range_constraint, if any.

The Constrained Attribute

Static Semantics

  1. For every private subtype S, the following attribute is defined:
  2. S'Constrained 
    Yields the value False if S denotes an unconstrained
nonformal private subtype with discriminants; also yields the
value False if S denotes a generic formal private subtype,
and the associated actual subtype is either an unconstrained
subtype with discriminants or an unconstrained array subtype;
yields the value True otherwise. The value of this attribute
is of the predefined subtype Boolean.

ASCII

Static Semantics

  1. The following declaration exists in the declaration of package Standard: 
  2. package ASCII is

  3.    --  Control characters:

  4.    NUL   : constant Character := nul;
   SOH   : constant Character := soh;
   STX   : constant Character := stx;
   ETX   : constant Character := etx;
   EOT   : constant Character := eot;
   ENQ   : constant Character := enq;
   ACK   : constant Character := ack;
   BEL   : constant Character := bel;
   BS    : constant Character := bs;
   HT    : constant Character := ht;
   LF    : constant Character := lf;
   VT    : constant Character := vt;
   FF    : constant Character := ff;
   CR    : constant Character := cr;
   SO    : constant Character := so;
   SI    : constant Character := si;
   DLE   : constant Character := dle;
   DC1   : constant Character := dc1;
   DC2   : constant Character := dc2;
   DC3   : constant Character := dc3;
   DC4   : constant Character := dc4;
   NAK   : constant Character := nak;
   SYN   : constant Character := syn;
   ETB   : constant Character := etb;
   CAN   : constant Character := can;
   EM    : constant Character := em;
   SUB   : constant Character := sub;
   ESC   : constant Character := esc;
   FS    : constant Character := fs;
   GS    : constant Character := gs;
   RS    : constant Character := rs;
   US    : constant Character := us;
   DEL   : constant Character := del;

  5.    -- Other characters:

  6.    Exclam    : constant Character:= '!';
   Quotation : constant Character:= '"';
   Sharp     : constant Character:= '#';
   Dollar    : constant Character:= '$';
   Percent   : constant Character:= '%';
   Ampersand : constant Character:= '&';
   Colon     : constant Character:= ':';
   Semicolon : constant Character:= ';';
   Query     : constant Character:= '?';
   At_Sign   : constant Character:= '';
   L_Bracket : constant Character:= '[';
   Back_Slash: constant Character:= '\';
   R_Bracket : constant Character:= ']';
   Circumflex: constant Character:= '^';
   Underline : constant Character:= '_';
   Grave     : constant Character:= '`';
   L_Brace   : constant Character:= '{';
   Bar       : constant Character:= '|';
   R_Brace   : constant Character:= '}';
   Tilde     : constant Character:= '~';

  7.    -- Lower case letters:

  8.    LC_A: constant Character:= 'a';
   ...
   LC_Z: constant Character:= 'z';

  9. end ASCII;

Numeric_Error

Static Semantics

  1. The following declaration exists in the declaration of package Standard: 
  2. Numeric_Error : exception renames Constraint_Error;

At Clauses

Syntax 

  1. at_clause ::= for direct_name use at expression;

    Static Semantics

  2. An at_clause of the form "for x use at y;" is equivalent to an attribute_definition_clause of the form "for x'Address use y;".

Interrupt Entries

  1. Implementations are permitted to allow the attachment of task entries to interrupts via the address clause. Such an entry is referred to as an interrupt entry.
  2. The address of the task entry corresponds to a hardware interrupt in an implementation-defined manner. (See Ada.Interrupts.Reference in section The Package Interrupts.)

    Static Semantics

  3. The following attribute is defined:
  4. For any task entry X:
  5. X'Address 
    For a task entry whose address is specified (an interrupt
entry), the value refers to the corresponding hardware
interrupt. For such an entry, as for any other task entry,
the meaning of this value is implementation defined. The
value of this attribute is of the type of the subtype
System.Address.
    1. Address may be specified for single entries via an attribute_definition_clause.

Dynamic Semantics

  1. As part of the initialization of a task object, the address clause for an interrupt entry is elaborated, which evaluates the expression of the address clause. A check is made that the address specified is associated with some interrupt to which a task entry may be attached. If this check fails, Program_Error is raised. Otherwise, the interrupt entry is attached to the interrupt associated with the specified address.
  2. Upon finalization of the task object, the interrupt entry, if any, is detached from the corresponding interrupt and the default treatment is restored.
  3. While an interrupt entry is attached to an interrupt, the interrupt is reserved, see section Interrupt Support.
  4. An interrupt delivered to a task entry acts as a call to the entry issued by a hardware task whose priority is in the System.Interrupt_Priority range. It is implementation defined whether the call is performed as an ordinary entry call, a timed entry call, or a conditional entry call; which kind of call is performed can depend on the specific interrupt.

    Bounded (Run-Time) Errors

  5. It is a bounded error to evaluate E'Caller, see section The Package Task_Identification, in an accept_statement for an interrupt entry. The possible effects are the same as for calling Current_Task from an entry body.

    Documentation Requirements

  6. The implementation shall document to which interrupts a task entry may be attached.
  7. The implementation shall document whether the invocation of an interrupt entry has the effect of an ordinary entry call, conditional call, or a timed call, and whether the effect varies in the presence of pending interrupts.

    Implementation Permissions

  8. The support for this subclause is optional.
  9. Interrupts to which the implementation allows a task entry to be attached may be designated as reserved for the entire duration of program execution; that is, not just when they have an interrupt entry attached to them.
  10. Interrupt entry calls may be implemented by having the hardware execute directly the appropriate accept body. Alternatively, the implementation is allowed to provide an internal interrupt handler to simulate the effect of a normal task calling the entry.
  11. The implementation is allowed to impose restrictions on the specifications and bodies of tasks that have interrupt entries.
  12. It is implementation defined whether direct calls (from the program) to interrupt entries are allowed.
  13. If a select_statement contains both a terminate_alternative and an accept_alternative for an interrupt entry, then an implementation is allowed to impose further requirements for the selection of the terminate_alternative in addition to those given in, see section Task Dependence - Termination of Tasks. NOTES
  14. (1) Queued interrupts correspond to ordinary entry calls. Interrupts that are lost if not immediately processed correspond to conditional entry calls. It is a consequence of the priority rules that an accept body executed in response to an interrupt can be executed with the active priority at which the hardware generates the interrupt, taking precedence over lower priority tasks, without a scheduling action.
  15. (2) Control information that is supplied upon an interrupt can be passed to an associated interrupt entry as one or more parameters of mode in.

    Examples

  16. Example of an interrupt entry: 
  17. task Interrupt_Handler is
  entry Done;
  for Done'Address use
    Ada.Interrupts.Reference (Ada.Interrupts.Names.Device_Done);
end Interrupt_Handler;

Mod Clauses

Syntax 

  1. mod_clause ::= at mod static_expression;

    Static Semantics

  2. A record_representation_clause of the form: 
  3. for r use
    record at mod a
        ...
    end record;
  4. is equivalent to: 
  5. for r'Alignment use a;
for r use
    record
        ...
    end record;

The Storage_Size Attribute

Static Semantics

  1. For any task subtype T, the following attribute is defined:
  2. T'Storage_Size 
    Denotes an implementation-defined value of type
universal_integer representing the number of storage
elements reserved for a task of the subtype T.
    1. Storage_Size may be specified for a task first subtype via an attribute_definition_clause.

Language-Defined Attributes (informative)

  1. This annex summarizes the definitions given elsewhere of the language-defined attributes.
  2. P'Access
      For a prefix P that denotes a subprogram:
    1. P'Access yields an access value that designates the subprogram denoted by P. The type of P'Access is an access-to-subprogram type (S), as determined by the expected type (see section Operations of Access Types).
  1. X'Access
      For a prefix X that denotes an aliased view of an object:
    1. X'Access yields an access value that designates the object denoted by X. The type of X'Access is an access-to-object type, as determined by the expected type. The expected type shall be a general access type (see section Operations of Access Types).
  1. X'Address
      For a prefix X that denotes an object, program unit, or label:
    1. Denotes the address of the first of the storage elements allocated to X. For a program unit or label, this value refers to the machine code associated with the corresponding body or statement. The value of this attribute is of type System.Address (see section Representation Attributes).
  1. S'Adjacent
      For every subtype S of a floating point type T:
    1. S'Adjacent denotes a function with the following specification: 
    2. function S'Adjacent (X, Towards : T) return T
    3. If Towards=X, the function yields X; otherwise, it yields the machine number of the type T adjacent to X in the direction of Towards, if that machine number exists. If the result would be outside the base range of S, Constraint_Error is raised. When T'Signed_Zeros is True, a zero result has the sign of X. When Towards is zero, its sign has no bearing on the result (see section Attributes of Floating Point Types).
  1. S'Aft
      For every fixed point subtype S:
    1. S'Aft yields the number of decimal digits needed after the decimal point to accommodate the delta of the subtype S, unless the delta of the subtype S is greater than 0.1, in which case the attribute yields the value one. (S'Aft is the smallest positive integer N for which (10**N)*S'Delta is greater than or equal to one.) The value of this attribute is of the type universal_integer (see section Operations of Fixed Point Types).
  1. X'Alignment
      For a prefix X that denotes a subtype or object:
    1. The Address of an object that is allocated under control of the implementation is an integral multiple of the Alignment of the object (that is, the Address modulo the Alignment is zero). The offset of a record component is a multiple of the Alignment of the component. For an object that is not allocated under control of the implementation (that is, one that is imported, that is allocated by a user-defined allocator, whose Address has been specified, or is designated by an access value returned by an instance of Unchecked_Conversion), the implementation may assume that the Address is an integral multiple of its Alignment. The implementation shall not assume a stricter alignment.
    2. The value of this attribute is of type universal_integer, and nonnegative; zero means that the object is not necessarily aligned on a storage element boundary (see section Representation Attributes).
  1. S'Base
      For every scalar subtype S:
    1. S'Base denotes an unconstrained subtype of the type of S. This unconstrained subtype is called the base subtype of the type (see section Scalar Types).
  1. S'Bit_Order
      For every specific record subtype S:
    1. Denotes the bit ordering for the type of S. The value of this attribute is of type System.Bit_Order (see section Bit Ordering).
  1. P'Body_Version
      For a prefix P that statically denotes a program unit:
    1. Yields a value of the predefined type String that identifies the version of the compilation unit that contains the body (but not any subunits) of the program unit (see section Consistency of a Distributed System).
  1. T'Callable
      For a prefix T that is of a task type (after any implicit dereference):
    1. Yields the value True when the task denoted by T is callable, and False otherwise (see section Task and Entry Attributes).
  1. E'Caller
      For a prefix E that denotes an entry_declaration:
    1. Yields a value of the type Task_ID that identifies the task whose call is now being serviced. Use of this attribute is allowed only inside an entry_body or accept_statement corresponding to the entry_declaration denoted by E (see section The Package Task_Identification).
  1. S'Ceiling
      For every subtype S of a floating point type T:
    1. S'Ceiling denotes a function with the following specification: 
    2. function S'Ceiling (X : T) return T
    3. The function yields the value Ceiling(X), i.e., the smallest (most negative) integral value greater than or equal to X. When X is zero, the result has the sign of X; a zero result otherwise has a negative sign when S'Signed_Zeros is True (see section Attributes of Floating Point Types).
  1. S'Class
      For every subtype S of a tagged type T (specific or class-wide):
    1. S'Class denotes a subtype of the class-wide type (called T'Class in this International Standard) for the class rooted at T (or if S already denotes a class-wide subtype, then S'Class is the same as S).
    2. S'Class is unconstrained. However, if S is constrained, then the values of S'Class are only those that when converted to the type T belong to S (see section Tagged Types and Type Extensions).
  1. S'Class
      For every subtype S of an untagged private type whose full view is tagged:
    1. Denotes the class-wide subtype corresponding to the full view of S. This attribute is allowed only from the beginning of the private part in which the full view is declared, until the declaration of the full view. After the full view, the Class attribute of the full view can be used (see section Private Operations).
  1. X'Component_Size
      For a prefix X that denotes an array subtype or array object (after any implicit dereference):
    1. Denotes the size in bits of components of the type of X. The value of this attribute is of type universal_integer (see section Representation Attributes).
  1. S'Compose
      For every subtype S of a floating point type T:
    1. S'Compose denotes a function with the following specification: 
    2. function S'Compose
 (Fraction : T;
  Exponent : universal_integer) return T
    3. Let v be the value (Fraction*T'Machine_Radix) ** (Exponent-k), where k is the normalized exponent of Fraction. If v is a machine number of the type T, or if |v|>=T'Model_Small, the function yields v; otherwise, it yields either one of the machine numbers of the type T adjacent to v. Constraint_Error is optionally raised if v is outside the base range of S. A zero result has the sign of Fraction when S'Signed_Zeros is True (see section Attributes of Floating Point Types).
  1. A'Constrained
      For a prefix A that is of a discriminated type (after any implicit dereference):
    1. Yields the value True if A denotes a constant, a value, or a constrained variable, and False otherwise (see section Operations of Discriminated Types).
  1. S'Copy_Sign
      For every subtype S of a floating point type T:
    1. S'Copy_Sign denotes a function with the following specification: 
    2. function S'Copy_Sign (Value, Sign : T) return T
    3. If the value of Value is nonzero, the function yields a result whose magnitude is that of Value and whose sign is that of Sign; otherwise, it yields the value zero. Constraint_Error is optionally raised if the result is outside the base range of S. A zero result has the sign of Sign when S'Signed_Zeros is True (see section Attributes of Floating Point Types).
  1. E'Count
      For a prefix E that denotes an entry of a task or protected unit:
    1. Yields the number of calls presently queued on the entry E of the current instance of the unit. The value of this attribute is of the type universal_integer (see section Task and Entry Attributes).
  1. S'Definite
      For a prefix S that denotes a formal indefinite subtype:
    1. S'Definite yields True if the actual subtype corresponding to S is definite; otherwise it yields False. The value of this attribute is of the predefined type Boolean (see section Formal Private and Derived Types).
  1. S'Delta
      For every fixed point subtype S:
    1. S'Delta denotes the delta of the fixed point subtype S. The value of this attribute is of the type universal_real (see section Operations of Fixed Point Types).
  1. S'Denorm
      For every subtype S of a floating point type T:
    1. Yields the value True if every value expressible in the form 
                                 T'Machine_Emin
+/-mantissa*T'Machine_Radix
      where mantissa is a nonzero T'Machine_Mantissa-digit fraction in the number base T'Machine_Radix, the first digit of which is zero, is a machine number, see section Floating Point Types, of the type T; yields the value False otherwise. The value of this attribute is of the predefined type Boolean (see section Attributes of Floating Point Types).
  1. S'Digits
      For every decimal fixed point subtype S:
    1. S'Digits denotes the digits of the decimal fixed point subtype S, which corresponds to the number of decimal digits that are representable in objects of the subtype. The value of this attribute is of the type universal_integer (see section Operations of Fixed Point Types).
  1. S'Digits
      For every floating point subtype S:
    1. S'Digits denotes the requested decimal precision for the subtype S. The value of this attribute is of the type universal_integer (see section Operations of Floating Point Types).
  1. S'Exponent
      For every subtype S of a floating point type T:
    1. S'Exponent denotes a function with the following specification: 
    2. function S'Exponent (X : T) return universal_integer
    3. The function yields the normalized exponent of X (see section Attributes of Floating Point Types).
  1. S'External_Tag
      For every subtype S of a tagged type T (specific or class-wide):
    1. S'External_Tag denotes an external string representation for S'Tag; it is of the predefined type String. External_Tag may be specified for a specific tagged type via an attribute_definition_clause; the expression of such a clause shall be static. The default external tag representation is implementation defined (see section Dispatching Operations of Tagged Types and section Stream-Oriented Attributes). See section Representation Attributes.
  1. A'First(N)
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'First(N) denotes the lower bound of the N-th index range; its type is the corresponding index type (see section Operations of Array Types).
  1. A'First
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'First denotes the lower bound of the first index range; its type is the corresponding index type (see section Operations of Array Types).
  1. S'First
      For every scalar subtype S:
    1. S'First denotes the lower bound of the range of S. The value of this attribute is of the type of S. See section Scalar Types.
  1. R.C'First_Bit
      For a component C of a composite, non-array object R:
    1. Denotes the offset, from the start of the first of the storage elements occupied by C, of the first bit occupied by C. This offset is measured in bits. The first bit of a storage element is numbered zero. The value of this attribute is of the type universal_integer. See section Storage Place Attributes.
  1. S'Floor
      For every subtype S of a floating point type T:
    1. S'Floor denotes a function with the following specification: 
    2. function S'Floor (X : T) return T
    3. The function yields the value Floor(X), i.e., the largest (most positive) integral value less than or equal to X. When X is zero, the result has the sign of X; a zero result otherwise has a positive sign. See section Attributes of Floating Point Types.
  1. S'Fore
      For every fixed point subtype S:
    1. S'Fore yields the minimum number of characters needed before the decimal point for the decimal representation of any value of the subtype S, assuming that the representation does not include an exponent, but includes a one-character prefix that is either a minus sign or a space. (This minimum number does not include superfluous zeros or underlines, and is at least 2.) The value of this attribute is of the type universal_integer. See section Operations of Fixed Point Types.
  1. S'Fraction
      For every subtype S of a floating point type T:
    1. S'Fraction denotes a function with the following specification: 
    2. function S'Fraction (X : T) return T
    3. The function yields the value (X*T'Machine_Radix) ** -k, where k is the normalized exponent of X. A zero result, which can only occur when X is zero, has the sign of X. See section Attributes of Floating Point Types.
  1. E'Identity
      For a prefix E that denotes an exception:
    1. E'Identity returns the unique identity of the exception. The type of this attribute is Exception_Id. See section The Package Exceptions.
  1. T'Identity
      For a prefix T that is of a task type (after any implicit dereference):
    1. Yields a value of the type Task_ID that identifies the task denoted by T. See section The Package Task_Identification.
  1. S'Image
      For every scalar subtype S:
    1. S'Image denotes a function with the following specification: 
    2. function S'Image(Arg : S'Base) return String
    3. The function returns an image of the value of Arg as a String. See section Scalar Types.
  1. S'Class'Input
      For every subtype S'Class of a class-wide type T'Class:
    1. S'Class'Input denotes a function with the following specification: 
    2. function S'Class'Input
  (Stream : access Ada.Streams.Root_Stream_Type'Class)
  return T'Class
    3. First reads the external tag from Stream and determines the corresponding internal tag (by calling Tags.Internal_Tag(String'Input(Stream)) -- see section Tagged Types and Type Extensions.) and then dispatches to the subprogram denoted by the Input attribute of the specific type identified by the internal tag; returns that result. See section Stream-Oriented Attributes.
  1. S'Input
      For every subtype S of a specific type T:
    1. S'Input denotes a function with the following specification: 
    2. function S'Input
  (Stream : access Ada.Streams.Root_Stream_Type'Class)
  return T
    3. S'Input reads and returns one value from Stream, using any bounds or discriminants written by a corresponding S'Output to determine how much to read. See section Stream-Oriented Attributes.
  1. A'Last(N)
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Last(N) denotes the upper bound of the N-th index range; its type is the corresponding index type. See section Operations of Array Types.
  1. A'Last
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Last denotes the upper bound of the first index range; its type is the corresponding index type. See section Operations of Array Types.
  1. S'Last
      For every scalar subtype S:
    1. S'Last denotes the upper bound of the range of S. The value of this attribute is of the type of S. See section Scalar Types.
  1. R.C'Last_Bit
      For a component C of a composite, non-array object R:
    1. Denotes the offset, from the start of the first of the storage elements occupied by C, of the last bit occupied by C. This offset is measured in bits. The value of this attribute is of the type universal_integer. See section Storage Place Attributes.
  1. S'Leading_Part
      For every subtype S of a floating point type T:
    1. S'Leading_Part denotes a function with the following specification: 
    2. function S'Leading_Part
  (X            : T;
   Radix_Digits : universal_integer) return T
    3. Let v be the value T'Machine_Radix ** (k-Radix_Digits), where k is the normalized exponent of X. The function yields the value
      1. Floor(X/v)*v, when X is nonnegative and Radix_Digits is positive;
      2. Ceiling(X/v)*v, when X is negative and Radix_Digits is positive.
    1. Constraint_Error is raised when Radix_Digits is zero or negative. A zero result, which can only occur when X is zero, has the sign of X. See section Attributes of Floating Point Types.
  1. A'Length(N)
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Length(N) denotes the number of values of the N-th index range (zero for a null range); its type is universal_integer. See section Operations of Array Types.
  1. A'Length
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Length denotes the number of values of the first index range (zero for a null range); its type is universal_integer. See section Operations of Array Types.
  1. S'Machine
      For every subtype S of a floating point type T:
    1. S'Machine denotes a function with the following specification: 
    2. function S'Machine (X : T) return T
    3. If X is a machine number of the type T, the function yields X; otherwise, it yields the value obtained by rounding or truncating X to either one of the adjacent machine numbers of the type T. Constraint_Error is raised if rounding or truncating X to the precision of the machine numbers results in a value outside the base range of S. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. S'Machine_Emax
      For every subtype S of a floating point type T:
    1. Yields the largest (most positive) value of exponent such that every value expressible in the canonical form (for the type T), having a mantissa of T'Machine_Mantissa digits, is a machine number (see section Floating Point Types) of the type T. This attribute yields a value of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Machine_Emin
      For every subtype S of a floating point type T:
    1. Yields the smallest (most negative) value of exponent such that every value expressible in the canonical form (for the type T), having a mantissa of T'Machine_Mantissa digits, is a machine number (see section Floating Point Types) of the type T. This attribute yields a value of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Machine_Mantissa
      For every subtype S of a floating point type T:
    1. Yields the largest value of p such that every value expressible in the canonical form (for the type T), having a p-digit mantissa and an exponent between T'Machine_Emin and T'Machine_Emax, is a machine number (see section Floating Point Types) of the type T. This attribute yields a value of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Machine_Overflows
      For every subtype S of a fixed point type T:
    1. Yields the value True if overflow and divide-by-zero are detected and reported by raising Constraint_Error for every predefined operation that yields a result of the type T; yields the value False otherwise. The value of this attribute is of the predefined type Boolean. See section Attributes of Fixed Point Types.
  1. S'Machine_Overflows
      For every subtype S of a floating point type T:
    1. Yields the value True if overflow and divide-by-zero are detected and reported by raising Constraint_Error for every predefined operation that yields a result of the type T; yields the value False otherwise. The value of this attribute is of the predefined type Boolean. See section Attributes of Floating Point Types.
  1. S'Machine_Radix
      For every subtype S of a fixed point type T:
    1. Yields the radix of the hardware representation of the type T. The value of this attribute is of the type universal_integer. See section Attributes of Fixed Point Types.
  1. S'Machine_Radix
      For every subtype S of a floating point type T:
    1. Yields the radix of the hardware representation of the type T. The value of this attribute is of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Machine_Rounds
      For every subtype S of a fixed point type T:
    1. Yields the value True if rounding is performed on inexact results of every predefined operation that yields a result of the type T; yields the value False otherwise. The value of this attribute is of the predefined type Boolean. See section Attributes of Fixed Point Types.
  1. S'Machine_Rounds
      For every subtype S of a floating point type T:
    1. Yields the value True if rounding is performed on inexact results of every predefined operation that yields a result of the type T; yields the value False otherwise. The value of this attribute is of the predefined type Boolean. See section Attributes of Floating Point Types.
  1. S'Max
      For every scalar subtype S:
    1. S'Max denotes a function with the following specification: 
    2. function S'Max(Left, Right : S'Base) return S'Base
    3. The function returns the greater of the values of the two parameters. See section Scalar Types.
  1. S'Max_Size_In_Storage_Elements
      For every subtype S:
    1. Denotes the maximum value for Size_In_Storage_Elements that will be requested via Allocate for an access type whose designated subtype is S. The value of this attribute is of type universal_integer. See section The Max_Size_In_Storage_Elements Attribute.
  1. S'Min
      For every scalar subtype S:
    1. S'Min denotes a function with the following specification: 
    2. function S'Min(Left, Right : S'Base) return S'Base
    3. The function returns the lesser of the values of the two parameters. See section Scalar Types.
  1. S'Model
      For every subtype S of a floating point type T:
    1. S'Model denotes a function with the following specification: 
    2. function S'Model (X : T) return T
    3. If the Numerics Annex is not supported, the meaning of this attribute is implementation defined; see section Model-Oriented Attributes of Floating Point Types for the definition that applies to implementations supporting the Numerics Annex. See section Attributes of Floating Point Types.
  1. S'Model_Emin
      For every subtype S of a floating point type T:
    1. If the Numerics Annex is not supported, this attribute yields an implementation defined value that is greater than or equal to the value of T'Machine_Emin. See section Model-Oriented Attributes of Floating Point Types for further requirements that apply to implementations supporting the Numerics Annex. The value of this attribute is of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Model_Epsilon
      For every subtype S of a floating point type T:
    1. Yields the value T'Machine_Radix ** (1-T'Model_Mantissa). The value of this attribute is of the type universal_real. See section Attributes of Floating Point Types.
  1. S'Model_Mantissa
      For every subtype S of a floating point type T:
    1. If the Numerics Annex is not supported, this attribute yields an implementation defined value that is greater than or equal to Ceiling(d*log (10)/log (T'Machine_Radix))+1, where d is the requested decimal precision of T, and less than or equal to the value of T'Machine_Mantissa. See section Model-Oriented Attributes of Floating Point Types for further requirements that apply to implementations supporting the Numerics Annex. The value of this attribute is of the type universal_integer. See section Attributes of Floating Point Types.
  1. S'Model_Small
      For every subtype S of a floating point type T:
    1. Yields the value T'Machine_Radix ** (T'Model_Emin-1). The value of this attribute is of the type universal_real. See section Attributes of Floating Point Types.
  1. S'Modulus
      For every modular subtype S:
    1. S'Modulus yields the modulus of the type of S, as a value of the type universal_integer. See section Integer Types.
  1. S'Class'Output
      For every subtype S'Class of a class-wide type T'Class:
    1. S'Class'Output denotes a procedure with the following specification: 
    2. procedure S'Class'Output
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : in T'Class)
    3. First writes the external tag of Item to Stream (by calling String'Output(Tags.External_Tag(Item'Tag) -- see section Tagged Types and Type Extensions.) and then dispatches to the subprogram denoted by the Output attribute of the specific type identified by the tag. See section Stream-Oriented Attributes.
  1. S'Output
      For every subtype S of a specific type T:
    1. S'Output denotes a procedure with the following specification: 
    2. procedure S'Output
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : in T)
    3. S'Output writes the value of Item to Stream, including any bounds or discriminants. See section Stream-Oriented Attributes.
  1. D'Partition_ID
      For a prefix D that denotes a library-level declaration, excepting a declaration of or within a declared-pure library unit:
    1. Denotes a value of the type universal_integer that identifies the partition in which D was elaborated. If D denotes the declaration of a remote call interface library unit, see section Remote Call Interface Library Units, the given partition is the one where the body of D was elaborated. See section Partitions.
  1. S'Pos
      For every discrete subtype S:
    1. S'Pos denotes a function with the following specification: 
    2. function S'Pos(Arg : S'Base) return universal_integer
    3. This function returns the position number of the value of Arg, as a value of type universal_integer. See section Operations of Discrete Types.
  1. R.C'Position
      For a component C of a composite, non-array object R:
    1. Denotes the same value as R.C'Address - R'Address. The value of this attribute is of the type universal_integer. See section Storage Place Attributes.
  1. S'Pred
      For every scalar subtype S:
    1. S'Pred denotes a function with the following specification: 
    2. function S'Pred(Arg : S'Base) return S'Base
    3. For an enumeration type, the function returns the value whose position number is one less than that of the value of Arg; Constraint_Error is raised if there is no such value of the type. For an integer type, the function returns the result of subtracting one from the value of Arg. For a fixed point type, the function returns the result of subtracting small from the value of Arg. For a floating point type, the function returns the machine number (as defined in section Floating Point Types.) immediately below the value of Arg; Constraint_Error is raised if there is no such machine number. See section Scalar Types.
  1. A'Range(N)
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Range(N) is equivalent to the range A'First(N) .. A'Last(N), except that the prefix A is only evaluated once. See section Operations of Array Types.
  1. A'Range
      For a prefix A that is of an array type (after any implicit dereference), or denotes a constrained array subtype:
    1. A'Range is equivalent to the range A'First .. A'Last, except that the prefix A is only evaluated once. See section Operations of Array Types.
  1. S'Range
      For every scalar subtype S:
    1. S'Range is equivalent to the range S'First .. S'Last. See section Scalar Types.
  1. S'Class'Read
      For every subtype S'Class of a class-wide type T'Class:
    1. S'Class'Read denotes a procedure with the following specification: 
    2. procedure S'Class'Read
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : out T'Class)
    3. Dispatches to the subprogram denoted by the Read attribute of the specific type identified by the tag of Item. See section Stream-Oriented Attributes.
  1. S'Read
      For every subtype S of a specific type T:
    1. S'Read denotes a procedure with the following specification: 
    2. procedure S'Read
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : out T)
    3. S'Read reads the value of Item from Stream. See section Stream-Oriented Attributes.
  1. S'Remainder
      For every subtype S of a floating point type T:
    1. S'Remainder denotes a function with the following specification: 
    2. function S'Remainder (X, Y : T) return T
    3. For nonzero Y, let v be the value X-n*Y, where n is the integer nearest to the exact value of X/Y; if |n-X/Y|=1/2, then n is chosen to be even. If v is a machine number of the type T, the function yields v; otherwise, it yields zero. Constraint_Error is raised if Y is zero. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. S'Round
      For every decimal fixed point subtype S:
    1. S'Round denotes a function with the following specification: 
    2. function S'Round(X : universal_real) return S'Base
    3. The function returns the value obtained by rounding X (away from 0, if X is midway between two values of the type of S). See section Operations of Fixed Point Types.
  1. S'Rounding
      For every subtype S of a floating point type T:
    1. S'Rounding denotes a function with the following specification: 
    2. function S'Rounding (X : T) return T
    3. The function yields the integral value nearest to X, rounding away from zero if X lies exactly halfway between two integers. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. S'Safe_First
      For every subtype S of a floating point type T:
    1. Yields the lower bound of the safe range, see section Floating Point Types, of the type T. If the Numerics Annex is not supported, the value of this attribute is implementation defined; See section Model-Oriented Attributes of Floating Point Types for the definition that applies to implementations supporting the Numerics Annex. The value of this attribute is of the type universal_real. See section Attributes of Floating Point Types.
  1. S'Safe_Last
      For every subtype S of a floating point type T:
    1. Yields the upper bound of the safe range, see section Floating Point Types of the type T. If the Numerics Annex is not supported, the value of this attribute is implementation defined; See section Model-Oriented Attributes of Floating Point Types for the definition that applies to implementations supporting the Numerics Annex. The value of this attribute is of the type universal_real. See section Attributes of Floating Point Types.
  1. S'Scale
      For every decimal fixed point subtype S:
    1. S'Scale denotes the scale of the subtype S, defined as the value N such that S'Delta = 10.0**(-N). The scale indicates the position of the point relative to the rightmost significant digits of values of subtype S. The value of this attribute is of the type universal_integer. See section Operations of Fixed Point Types.
  1. S'Scaling
      For every subtype S of a floating point type T:
    1. S'Scaling denotes a function with the following specification: 
    2. function S'Scaling
  (X          : T;
   Adjustment : universal_integer) return T
    3. Let v be the value X*T'Machine_Radix ** Adjustment. If v is a machine number of the type T, or if |v|>=T'Model_Small, the function yields v; otherwise, it yields either one of the machine numbers of the type T adjacent to v. Constraint_Error is optionally raised if v is outside the base range of S. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. S'Signed_Zeros
      For every subtype S of a floating point type T:
    1. Yields the value True if the hardware representation for the type T has the capability of representing both positively and negatively signed zeros, these being generated and used by the predefined operations of the type T as specified in IEC 559:1989; yields the value False otherwise. The value of this attribute is of the predefined type Boolean. See section Attributes of Floating Point Types.
  1. S'Size
      For every subtype S:
    1. If S is definite, denotes the size (in bits) that the implementation would choose for the following objects of subtype S:
      1. A record component of subtype S when the record type is packed.
      2. The formal parameter of an instance of Unchecked_Conversion that converts from subtype S to some other subtype.
    1. If S is indefinite, the meaning is implementation defined. The value of this attribute is of the type universal_integer. See section Representation Attributes.
  1. X'Size
      For a prefix X that denotes an object:
    1. Denotes the size in bits of the representation of the object. The value of this attribute is of the type universal_integer. See section Representation Attributes.
  1. S'Small
      For every fixed point subtype S:
    1. S'Small denotes the small of the type of S. The value of this attribute is of the type universal_real. See section Operations of Fixed Point Types.
  1. S'Storage_Pool
      For every access subtype S:
    1. Denotes the storage pool of the type of S. The type of this attribute is Root_Storage_Pool'Class. See section Storage Management.
  1. S'Storage_Size
      For every access subtype S:
    1. Yields the result of calling Storage_Size(S'Storage_Pool), which is intended to be a measure of the number of storage elements reserved for the pool. The type of this attribute is universal_integer. See section Storage Management.
  1. T'Storage_Size
      For a prefix T that denotes a task object (after any implicit dereference):
    1. Denotes the number of storage elements reserved for the task. The value of this attribute is of the type universal_integer. The Storage_Size includes the size of the task's stack, if any. The language does not specify whether or not it includes other storage associated with the task (such as the "task control block" used by some implementations.) See section Representation Attributes.
  1. S'Succ
      For every scalar subtype S:
    1. S'Succ denotes a function with the following specification: 
    2. function S'Succ(Arg : S'Base) return S'Base
    3. For an enumeration type, the function returns the value whose position number is one more than that of the value of Arg; Constraint_Error is raised if there is no such value of the type. For an integer type, the function returns the result of adding one to the value of Arg. For a fixed point type, the function returns the result of adding small to the value of Arg. For a floating point type, the function returns the machine number (as defined in section Floating Point Types.) immediately above the value of Arg; Constraint_Error is raised if there is no such machine number. See section Scalar Types.
  1. S'Tag
      For every subtype S of a tagged type T (specific or class-wide):
    1. S'Tag denotes the tag of the type T (or if T is class-wide, the tag of the root type of the corresponding class). The value of this attribute is of type Tag. See section Tagged Types and Type Extensions.
  1. X'Tag
      For a prefix X that is of a class-wide tagged type (after any implicit dereference):
    1. X'Tag denotes the tag of X. The value of this attribute is of type Tag. See section Tagged Types and Type Extensions.
  1. T'Terminated
      For a prefix T that is of a task type (after any implicit dereference):
    1. Yields the value True if the task denoted by T is terminated, and False otherwise. The value of this attribute is of the predefined type Boolean. See section Task and Entry Attributes.
  1. S'Truncation
      For every subtype S of a floating point type T:
    1. S'Truncation denotes a function with the following specification: 
    2. function S'Truncation (X : T) return T
    3. The function yields the value Ceiling(X) when X is negative, and Floor(X) otherwise. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. S'Unbiased_Rounding
      For every subtype S of a floating point type T:
    1. S'Unbiased_Rounding denotes a function with the following specification: 
    2. function S'Unbiased_Rounding (X : T) return T
    3. The function yields the integral value nearest to X, rounding toward the even integer if X lies exactly halfway between two integers. A zero result has the sign of X when S'Signed_Zeros is True. See section Attributes of Floating Point Types.
  1. X'Unchecked_Access
      For a prefix X that denotes an aliased view of an object:
    1. All rules and semantics that apply to X'Access, see section Operations of Access Types, apply also to X'Unchecked_Access, except that, for the purposes of accessibility rules and checks, it is as if X were declared immediately within a library package. See section Unchecked Access Value Creation.
  1. S'Val
      For every discrete subtype S:
    1. S'Val denotes a function with the following specification: 
    2. function S'Val(Arg : universal_integer) return S'Base
    3. This function returns a value of the type of S whose position number equals the value of Arg. See section Operations of Discrete Types.
  1. 262 X'Valid
      For a prefix X that denotes a scalar object (after any implicit dereference):
    1. Yields True if and only if the object denoted by X is normal and has a valid representation. The value of this attribute is of the predefined type Boolean. See section The Valid Attribute.
  1. S'Value
      For every scalar subtype S:
    1. S'Value denotes a function with the following specification: 
    2. function S'Value(Arg : String) return S'Base
    3. This function returns a value given an image of the value as a String, ignoring any leading or trailing spaces. See section Scalar Types.
  1. P'Version
      For a prefix P that statically denotes a program unit:
    1. Yields a value of the predefined type String that identifies the version of the compilation unit that contains the declaration of the program unit. See section Consistency of a Distributed System.
  1. S'Wide_Image
      For every scalar subtype S:
    1. S'Wide_Image denotes a function with the following specification: 
    2. function S'Wide_Image(Arg : S'Base) return Wide_String
    3. The function returns an image of the value of Arg, that is, a sequence of characters representing the value in display form. See section Scalar Types.
  1. S'Wide_Value
      For every scalar subtype S:
    1. S'Wide_Value denotes a function with the following specification: 
    2. function S'Wide_Value(Arg : Wide_String) return S'Base
    3. This function returns a value given an image of the value as a Wide_String, ignoring any leading or trailing spaces. See section Scalar Types.
  1. S'Wide_Width
      For every scalar subtype S:
    1. S'Wide_Width denotes the maximum length of a Wide_String returned by S'Wide_Image over all values of the subtype S. It denotes zero for a subtype that has a null range. Its type is universal_integer. See section Scalar Types.
  1. S'Width
      For every scalar subtype S:
    1. S'Width denotes the maximum length of a String returned by S'Image over all values of the subtype S. It denotes zero for a subtype that has a null range. Its type is universal_integer. See section Scalar Types.
  1. S'Class'Write
      For every subtype S'Class of a class-wide type T'Class:
    1. S'Class'Write denotes a procedure with the following specification: 
    2. procedure S'Class'Write
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item   : in T'Class)
    3. Dispatches to the subprogram denoted by the Write attribute of the specific type identified by the tag of Item. See section Stream-Oriented Attributes.
  1. S'Write
      For every subtype S of a specific type T:
    1. S'Write denotes a procedure with the following specification: 
    2. procedure S'Write
  (Stream : access Ada.Streams.Root_Stream_Type'Class;
   Item : in T)
    3. S'Write writes the value of Item to Stream. See section Stream-Oriented Attributes.

Language-Defined Pragmas (informative)

  1. This Annex summarizes the definitions given elsewhere of the language-defined pragmas. 
  2. pragma All_Calls_Remote[(library_unit_name)];
--  see section Remote Call Interface Library Units.

  3. pragma Asynchronous(local_name);
--  see section Pragma Asynchronous.

  4. pragma Atomic(local_name);
--  see section Shared Variable Control.

  5. pragma Atomic_Components(array_local_name);
--  see section Shared Variable Control.

  6. pragma Attach_Handler(handler_name, expression);
--  see section Protected Procedure Handlers.

  7. pragma Controlled(first_subtype_local_name);
--  see section Pragma Controlled.

  8. pragma Convention([Convention =>] convention_identifier,
  [Entity =>] local_name);
--  see section Interfacing Pragmas.

  9. pragma Discard_Names[([On => ] local_name)];
--  see section Pragma Discard_Names.

  10. pragma Elaborate(library_unit_name{, library_unit_name});
--  see section Elaboration Control.

  11. pragma Elaborate_All(library_unit_name{, library_unit_name});
--  see section Elaboration Control.

  12. pragma Elaborate_Body[(library_unit_name)];
--  see section Elaboration Control.

  13. pragma Export( [Convention =>] convention_identifier,
  [Entity =>] local_name [, [External_Name =>] string_expression]
  [, [Link_Name =>] string_expression]);
--  see section Interfacing Pragmas.

  14. pragma Import( [Convention =>] convention_identifier,
  [Entity =>] local_name [, [External_Name =>] string_expression]
  [, [Link_Name =>] string_expression]);
--  see section Interfacing Pragmas.

  15. pragma Inline(name {, name});
--  see section Inline Expansion of Subprograms.

  16. pragma Inspection_Point[(object_name {, object_name})];
--  see section Pragma Inspection_Point.

  17. pragma Interrupt_Handler(handler_name);
--  see section Protected Procedure Handlers.

  18. pragma Interrupt_Priority[(expression)];
--  see section Task Priorities.

  19. pragma Linker_Options(string_expression);
--  see section Interfacing Pragmas.

  20. pragma List(identifier);
--  see section Pragmas.

  21. pragma Locking_Policy(policy_identifier);
--  see section Priority Ceiling Locking.

  22. pragma Normalize_Scalars;
--  see section Pragma Normalize_Scalars.

  23. pragma Optimize(identifier);
--  see section Pragmas.

  24. pragma Pack(first_subtype_local_name);
--  see section Pragma Pack.

  25. pragma Page;
--  see section Pragmas.

  26. pragma Preelaborate[(library_unit_name)];
--  see section Elaboration Control.

  27. pragma Priority(expression);
--  see section Task Priorities.

  28. pragma Pure[(library_unit_name)];
--  see section Elaboration Control.

  29. pragma Queuing_Policy(policy_identifier);
--  see section Entry Queuing Policies.

  30. pragma Remote_Call_Interface[(library_unit_name)];
--  see section Remote Call Interface Library Units.

  31. pragma Remote_Types[(library_unit_name)];
--  see section Remote Types Library Units.

  32. pragma Restrictions(restriction{, restriction});
--  see section Pragma Restrictions.

  33. pragma Reviewable;
--  see section Pragma Reviewable.

  34. pragma Shared_Passive[(library_unit_name)];
--  see section Shared Passive Library Units.

  35. pragma Storage_Size(expression);
--  see section Representation Attributes.

  36. pragma Suppress(identifier [, [On =>] name]);
--  see section Suppressing Checks.

  37. pragma Task_Dispatching_Policy(policy_identifier );
--  see section The Standard Task Dispatching Policy.

  38. pragma Volatile(local_name);
--  see section Shared Variable Control.

  39. pragma Volatile_Components(array_local_name);
--  see section Shared Variable Control.

Implementation-Defined Characteristics (informative)

  1. The Ada language allows for certain machine dependences in a controlled manner. Each Ada implementation must document all implementation-defined characteristics:
    1. Whether or not each recommendation given in Implementation Advice is followed. See section Structure.
    2. Capacity limitations of the implementation. See section Conformity of an Implementation with the Standard.
    3. Variations from the standard that are impractical to avoid given the implementation's execution environment. See section Conformity of an Implementation with the Standard.
    4. Which code_statements cause external interactions. See section Conformity of an Implementation with the Standard.
    5. The coded representation for the text of an Ada program. See section Character Set, (4).
    6. The control functions allowed in comments. See section Character Set.
    7. The representation for an end of line. See section Lexical Elements, Separators, and Delimiters.
    8. Maximum supported line length and lexical element length. See section Lexical Elements, Separators, and Delimiters, (15).
    9. Implementation-defined pragmas. See section Pragmas.
    10. Effect of pragma Optimize. See section Pragmas.
    11. The sequence of characters of the value returned by S'Image when some of the graphic characters of S'Wide_Image are not defined in Character. See section Scalar Types.
    12. The predefined integer types declared in Standard. See section Integer Types.
    13. Any nonstandard integer types and the operators defined for them. See section Integer Types.
    14. Any nonstandard real types and the operators defined for them. See section Real Types.
    15. What combinations of requested decimal precision and range are supported for floating point types. See section Floating Point Types.
    16. The predefined floating point types declared in Standard. See section Floating Point Types, (16).
    17. The small of an ordinary fixed point type. See section Fixed Point Types.
    18. What combinations of small, range, and digits are supported for fixed point types. See section Fixed Point Types.
    19. The result of Tags.Expanded_Name for types declared within an unnamed block_statement. See section Tagged Types and Type Extensions.
    20. Implementation-defined attributes. See section Attributes.
    21. Any implementation-defined time types. See section Delay Statements, Duration, and Time.
    22. The time base associated with relative delays. See section Delay Statements, Duration, and Time.
    23. The time base of the type Calendar.Time. See section Delay Statements, Duration, and Time.
    24. The timezone used for package Calendar operations. See section Delay Statements, Duration, and Time.
    25. Any limit on delay_until_statements of select_statements. See section Delay Statements, Duration, and Time, (29).
    26. Whether or not two nonoverlapping parts of a composite object are independently addressable, in the case where packing, record layout, or Component_Size is specified for the object. See section Shared Variables.
    27. The representation for a compilation. See section Separate Compilation.
    28. Any restrictions on compilations that contain multiple compilation_units. See section Separate Compilation.
    29. The mechanisms for creating an environment and for adding and replacing compilation units. See section The Compilation Process.
    30. The manner of explicitly assigning library units to a partition. See section Program Execution.
    31. The implementation-defined means, if any, of specifying which compilation units are needed by a given compilation unit. See section Program Execution, (2).
    32. The manner of designating the main subprogram of a partition. See section Program Execution.
    33. The order of elaboration of library_items. See section Program Execution.
    34. Parameter passing and function return for the main subprogram. See section Program Execution.
    35. The mechanisms for building and running partitions. See section Program Execution.
    36. The details of program execution, including program termination. See section Program Execution.
    37. The semantics of any nonactive partitions supported by the implementation. See section Program Execution.
    38. The information returned by Exception_Message. See section The Package Exceptions.
    39. The result of Exceptions.Exception_Name for types declared within an unnamed block_statement. See section The Package Exceptions.
    40. The information returned by Exception_Information. See section The Package Exceptions.
    41. Implementation-defined check names. See section Suppressing Checks.
    42. The interpretation of each aspect of representation. See section Representation Items.
    43. Any restrictions placed upon representation items. See section Representation Items.
    44. The meaning of Size for indefinite subtypes. See section Representation Attributes.
    45. The default external representation for a type tag. See section Representation Attributes.
    46. What determines whether a compilation unit is the same in two different partitions. See section Representation Attributes.
    47. Implementation-defined components. See section Record Representation Clauses.
    48. If Word_Size = Storage_Unit, the default bit ordering. See section Bit Ordering, (5).
    49. The contents of the visible part of package System and its language-defined children. See section The Package System.
    50. The contents of the visible part of package System.Machine_Code, and the meaning of code_statements. See section Machine Code Insertions.
    51. The effect of unchecked conversion. See section Unchecked Type Conversions.
    52. The manner of choosing a storage pool for an access type when Storage_Pool is not specified for the type. See section Storage Management.
    53. Whether or not the implementation provides user-accessible names for the standard pool type(s). See section Storage Management.
    54. The meaning of Storage_Size. See section Storage Management.
    55. Implementation-defined aspects of storage pools. See section Storage Management.
    56. The set of restrictions allowed in a pragma Restrictions. See section Pragma Restrictions, (7).
    57. The consequences of violating limitations on Restrictions pragmas. See section Pragma Restrictions.
    58. The representation used by the Read and Write attributes of elementary types in terms of stream elements. See section Stream-Oriented Attributes.
    59. The names and characteristics of the numeric subtypes declared in the visible part of package Standard. See section The Package Standard.
    60. The accuracy actually achieved by the elementary functions. See section Elementary Functions.
    61. The sign of a zero result from some of the operators or functions in Numerics.Generic_Elementary_Functions, when Float_Type'Signed_Zeros is True. See section Elementary Functions.
    62. The value of Numerics.Float_Random.Max_Image_Width. See section Random Number Generation.
    63. The value of Numerics.Discrete_Random.Max_Image_Width. See section Random Number Generation, (27).
    64. The algorithms for random number generation. See See section Lexical Elements.
    65. The string representation of a random number generator's state. See section Random Number Generation.
    66. The minimum time interval between calls to the time-dependent Reset procedure that are guaranteed to initiate different random number sequences. See section Random Number Generation.
    67. The values of the Model_Mantissa, Model_Emin, Model_Epsilon, Model, Safe_First, and Safe_Last attributes, if the Numerics Annex is not supported. See section Attributes of Floating Point Types.
    68. Any implementation-defined characteristics of the input-output packages. See section External Files and File Objects.
    69. The value of Buffer_Size in Storage_IO. See section The Generic Package Storage_IO.
    70. external files for standard input, standard output, and standard error. See section Text Input-Output.
    71. The accuracy of the value produced by Put. See section Input-Output for Real Types.
    72. The meaning of Argument_Count, Argument, and Command_Name. See section The Package Command_Line, (1).
    73. Implementation-defined convention names. See section Interfacing Pragmas.
    74. The meaning of link names. See section Interfacing Pragmas.
    75. The manner of choosing link names when neither the link name nor the address of an imported or exported entity is specified. See section Interfacing Pragmas, (36).
    76. The effect of pragma Linker_Options. See section Interfacing Pragmas.
    77. The contents of the visible part of package Interfaces and its language-defined descendants. See section The Package Interfaces.
    78. Implementation-defined children of package Interfaces. The contents of the visible part of package Interfaces. See section Exceptions.
    79. The types Floating, Long_Floating, Binary, Long_Binary, Decimal_Element, and COBOL_Character; and the initializations of the variables Ada_To_COBOL and COBOL_To_Ada, in Interfaces.COBOL See section Interfacing with COBOL.
    80. Support for access to machine instructions. See section Access to Machine Operations.
    81. Implementation-defined aspects of access to machine operations. See section Access to Machine Operations.
    82. Implementation-defined aspects of interrupts. See section Interrupt Support.
    83. Implementation-defined aspects of preelaboration. See section Preelaboration Requirements.
    84. The semantics of pragma Discard_Names. See section Pragma Discard_Names.
    85. The result of the Task_Identification.Image attribute. See section The Package Task_Identification, (7).
    86. The value of Current_Task when in a protected entry or interrupt handler. See section The Package Task_Identification.
    87. The effect of calling Current_Task from an entry body or interrupt handler. See section The Package Task_Identification.
    88. Implementation-defined aspects of Task_Attributes. See section The Package Task_Attributes.
    89. Values of all Metrics. See section Real-Time Systems (normative).
    90. The declarations of Any_Priority and Priority. See section Task Priorities.
    91. Implementation-defined execution resources. See section Task Priorities.
    92. Whether, on a multiprocessor, a task that is waiting for access to a protected object keeps its processor busy. See section The Task Dispatching Model.
    93. The affect of implementation defined execution resources on task dispatching. See section The Task Dispatching Model.
    94. Implementation-defined policy_identifiers allowed in a pragma Task_Dispatching_Policy. See section The Standard Task Dispatching Policy.
    95. Implementation-defined aspects of priority inversion. See section The Standard Task Dispatching Policy, (16).
    96. Implementation defined task dispatching. See section The Standard Task Dispatching Policy.
    97. Implementation-defined policy_identifiers allowed in a pragma Locking_Policy. See section Priority Ceiling Locking.
    98. Default ceiling priorities. See section Priority Ceiling Locking.
    99. The ceiling of any protected object used internally by the implementation. See section Priority Ceiling Locking.
    100. Implementation-defined queuing policies. See section Entry Queuing Policies.
    101. On a multiprocessor, any conditions that cause the completion of an aborted construct to be delayed later than what is specified for a single processor. See section Preemptive Abort.
    102. Any operations that implicitly require heap storage allocation. See section Tasking Restrictions.
    103. Implementation-defined aspects of pragma Restrictions. See section Tasking Restrictions.
    104. Implementation-defined aspects of package Real_Time. See section Monotonic Time.
    105. Implementation-defined aspects of delay_statements. See section Delay Accuracy.
    106. The upper bound on the duration of interrupt blocking caused by the implementation. See section Other Optimizations and Determinism Rules.
    107. The means for creating and executing distributed programs. See section Distributed Systems (normative), (5).
    108. Any events that can result in a partition becoming inaccessible. See section Partitions.
    109. The scheduling policies, treatment of priorities, and management of shared resources between partitions in certain cases. See section Partitions.
    110. Events that cause the version of a compilation unit to change. See section Consistency of a Distributed System.
    111. Whether the execution of the remote subprogram is immediately aborted as a result of cancellation. See section Remote Subprogram Calls.
    112. Implementation-defined aspects of the PCS. See section Partition Communication Subsystem.
    113. Implementation-defined interfaces in the PCS. See section Partition Communication Subsystem.
    114. The values of named numbers in the package Decimal. See section The Package Decimal.
    115. The value of Max_Picture_Length in the package Text_IO.Editing See section The Package Text_IO.Editing.
    116. The value of Max_Picture_Length in the package Wide_Text_IO.Editing See section The Package Wide_Text_IO.Editing.
    117. The accuracy actually achieved by the complex elementary functions and by other complex arithmetic operations. See section Complex Arithmetic.
    118. The sign of a zero result (or a component thereof) from any operator or function in Numerics.Generic_Complex_Types, when Real'Signed_Zeros is True. See section Complex Types.
    119. The sign of a zero result (or a component thereof) from any operator or function in Numerics.Generic_Complex_Elementary_Functions, when Complex_Types.Real'Signed_Zeros is True. See section Complex Elementary Functions.
    120. Whether the strict mode or the relaxed mode is the default. See section Numeric Performance Requirements, (2).
    121. The result interval in certain cases of fixed-to-float conversion. See section Model of Floating Point Arithmetic.
    122. The result of a floating point arithmetic operation in overflow situations, when the Machine_Overflows attribute of the result type is False. See section Model of Floating Point Arithmetic.
    123. The result interval for division (or exponentiation by a negative exponent), when the floating point hardware implements division as multiplication by a reciprocal. See section Model of Floating Point Arithmetic.
    124. The definition of close result set, which determines the accuracy of certain fixed point multiplications and divisions. See section Model of Fixed Point Arithmetic.
    125. Conditions on a universal_real operand of a fixed point multiplication or division for which the result shall be in the perfect result set. See section Model of Fixed Point Arithmetic.
    126. The result of a fixed point arithmetic operation in overflow situations, when the Machine_Overflows attribute of the result type is False. See section Model of Fixed Point Arithmetic.
    127. The result of an elementary function reference in overflow situations, when the Machine_Overflows attribute of the result type is False. See section Accuracy Requirements for the Elementary Functions.
    128. The value of the angle threshold, within which certain elementary functions, complex arithmetic operations, and complex elementary functions yield results conforming to a maximum relative error bound. See section Accuracy Requirements for the Elementary Functions.
    129. The accuracy of certain elementary functions for parameters beyond the angle threshold. See section Accuracy Requirements for the Elementary Functions.
    130. The result of a complex arithmetic operation or complex elementary function reference in overflow situations, when the Machine_Overflows attribute of the corresponding real type is False. See section Accuracy Requirements for Complex Arithmetic.
    131. The accuracy of certain complex arithmetic operations and certain complex elementary functions for parameters (or components thereof) beyond the angle threshold. See section Accuracy Requirements for Complex Arithmetic.
    132. Information regarding bounded errors and erroneous execution. See section Documentation of Implementation Decisions.
    133. Implementation-defined aspects of pragma Inspection_Point. See section Pragma Inspection_Point, (8).
    134. Implementation-defined aspects of pragma Restrictions. See section Safety and Security Restrictions.
    135. Any restrictions on pragma Restrictions. See section Safety and Security Restrictions.

Glossary (informative)

  1. This Annex contains informal descriptions of some terms used in this International Standard. To find more formal definitions, look the term up in the index.
  2. Access type. An access type has values that designate aliased objects. Access types correspond to "pointer types" or "reference types" in some other languages.
  3. Aliased. An aliased view of an object is one that can be designated by an access value. Objects allocated by allocators are aliased. Objects can also be explicitly declared as aliased with the reserved word aliased. The Access attribute can be used to create an access value designating an aliased object.
  4. Array type. An array type is a composite type whose components are all of the same type. Components are selected by indexing.
  5. Character type. A character type is an enumeration type whose values include characters.
  6. Class. A class is a set of types that is closed under derivation, which means that if a given type is in the class, then all types derived from that type are also in the class. The set of types of a class share common properties, such as their primitive operations.
  7. Compilation unit. The text of a program can be submitted to the compiler in one or more compilations. Each compilation is a succession of compilation_units. A compilation_unit contains either the declaration, the body, or a renaming of a program unit.
  8. Composite type. A composite type has components.
  9. Construct. A construct is a piece of text (explicit or implicit) that is an instance of a syntactic category defined under "Syntax."
  10. Controlled type. A controlled type supports user-defined assignment and finalization. Objects are always finalized before being destroyed. Declaration. A declaration is a language construct that associates a name with (a view of) an entity. A declaration may appear explicitly in the program text (an explicit declaration), or may be supposed to occur at a given place in the text as a consequence of the semantics of another construct (an implicit declaration).
  11. Definition. All declarations contain a definition for a view of an entity. A view consists of an identification of the entity (the entity of the view), plus view-specific characteristics that affect the use of the entity through that view (such as mode of access to an object, formal parameter names and defaults for a subprogram, or visibility to components of a type). In most cases, a declaration also contains the definition for the entity itself (a renaming_declaration is an example of a declaration that does not define a new entity, but instead defines a view of an existing entity, see section Renaming Declarations.
  12. Derived type. A derived type is a type defined in terms of another type, which is the parent type of the derived type. Each class containing the parent type also contains the derived type. The derived type inherits properties such as components and primitive operations from the parent. A type together with the types derived from it (directly or indirectly) form a derivation class.
  13. Discrete type. A discrete type is either an integer type or an enumeration type. Discrete types may be used, for example, in case_statements and as array indices.
  14. Discriminant. A discriminant is a parameter of a composite type. It can control, for example, the bounds of a component of the type if that type is an array type. A discriminant of a task type can be used to pass data to a task of the type upon creation.
  15. Elementary type. An elementary type does not have components.
  16. Enumeration type. An enumeration type is defined by an enumeration of its values, which may be named by identifiers or character literals.
  17. Exception. An exception represents a kind of exceptional situation; an occurrence of such a situation (at run time) is called an exception occurrence. To raise an exception is to abandon normal program execution so as to draw attention to the fact that the corresponding situation has arisen. Performing some actions in response to the arising of an exception is called handling the exception.
  18. Execution. The process by which a construct achieves its run-time effect is called execution. Execution of a declaration is also called elaboration. Execution of an expression is also called evaluation.
  19. Generic unit. A generic unit is a template for a (nongeneric) program unit; the template can be parameterized by objects, types, subprograms, and packages. An instance of a generic unit is created by a generic_instantiation. The rules of the language are enforced when a generic unit is compiled, using a generic contract model; additional checks are performed upon instantiation to verify the contract is met. That is, the declaration of a generic unit represents a contract between the body of the generic and instances of the generic. Generic units can be used to perform the role that macros sometimed play in other languages.
  20. Integer type. Integer types comprise the signed integer types and the modular types. A signed integer type has a base range that includes both positive and negative numbers, and has operations that may raise an exception when the result is outside the base range. A modular type has a base range whose lower bound is zero, and has operations with "wraparound" semantics. Modular types subsume what are called "unsigned types" in some other languages.
  21. Library unit. A library unit is a separately compiled program unit, and is always a package, subprogram, or generic unit. Library units may have other (logically nested) library units as children, and may have other program units physically nested within them. A root library unit, together with its children and grandchildren and so on, form a subsystem.
  22. Limited type. A limited type is (a view of) a type for which the assignment operation is not allowed. A nonlimited type is a (view of a) type for which the assignment operation is allowed.
  23. Object. An object is either a constant or a variable. An object contains a value. An object is created by an object_declaration or by an allocator. A formal parameter is (a view of) an object. A subcomponent of an object is an object.
  24. Package. Packages are program units that allow the specification of groups of logically related entities. Typically, a package contains the declaration of a type (often a private type or private extension) along with the declarations of primitive subprograms of the type, which can be called from outside the package, while their inner workings remain hidden from outside users.
  25. Partition. A partition is a part of a program. Each partition consists of a set of library units. Each partition may run in a separate address space, possibly on a separate computer. A program may contain just one partition. A distributed program typically contains multiple partitions, which can execute concurrently.
  26. Pragma. A pragma is a compiler directive. There are language-defined pragmas that give instructions for optimization, listing control, etc. An implementation may support additional (implementation-defined) pragmas.
  27. Primitive operations. The primitive operations of a type are the operations (such as subprograms) declared together with the type declaration. They are inherited by other types in the same class of types. For a tagged type, the primitive subprograms are dispatching subprograms, providing run-time polymorphism. A dispatching subprogram may be called with statically tagged operands, in which case the subprogram body invoked is determined at compile time. Alternatively, a dispatching subprogram may be called using a dispatching call, in which case the subprogram body invoked is determined at run time.
  28. Private extension. A private extension is like a record extension, except that the components of the extension part are hidden from its clients.
  29. Private type. A private type is a partial view of a type whose full view is hidden from its clients.
  30. Program unit. A program unit is either a package, a task unit, a protected unit, a protected entry, a generic unit, or an explicitly declared subprogram other than an enumeration literal. Certain kinds of program units can be separately compiled. Alternatively, they can appear physically nested within other program units.
  31. Program. A program is a set of partitions, each of which may execute in a separate address space, possibly on a separate computer. A partition consists of a set of library units.
  32. Protected type. A protected type is a composite type whose components are protected from concurrent access by multiple tasks.
  33. Real type. A real type has values that are approximations of the real numbers. Floating point and fixed point types are real types.
  34. Record extension. A record extension is a type that extends another type by adding additional components.
  35. Record type. A record type is a composite type consisting of zero or more named components, possibly of different types.
  36. Scalar type. A scalar type is either a discrete type or a real type.
  37. Subtype. A subtype is a type together with a constraint, which constrains the values of the subtype to satisfy a certain condition. The values of a subtype are a subset of the values of its type.
  38. Tagged type. The objects of a tagged type have a run-time type tag, which indicates the specific type with which the object was originally created. An operand of a class-wide tagged type can be used in a dispatching call; the tag indicates which subprogram body to invoke. Nondispatching calls, in which the subprogram body to invoke is determined at compile time, are also allowed. Tagged types may be extended with additional components.
  39. Task type. A task type is a composite type whose values are tasks, which are active entities that may execute concurrently with other tasks. The top-level task of a partition is called the environment task.
  40. Type. Each object has a type. A type has an associated set of values, and a set of primitive operations which implement the fundamental aspects of its semantics. Types are grouped into classes. The types of a given class share a set of primitive operations. Classes are closed under derivation; that is, if a type is in a class, then all of its derivatives are in that class.
  41. View. (See Definition.)

Syntax Summary (informative)

  1. This Annex summarizes the complete syntax of the language. section Method of Description and Syntax Notation, for a description of the notation used. 
    section Character Set
character ::=
     graphic_character
   | format_effector
   | other_control_function

section Character Set
graphic_character ::=
     identifier_letter
   | digit
   | space_character
   | special_character

section Identifiers
identifier ::= identifier_letter {[underline] letter_or_digit}

section Identifiers
letter_or_digit ::= identifier_letter | digit

section Numeric Literals
numeric_literal ::= decimal_literal | based_literal

section Decimal Literals
decimal_literal ::= numeral [.numeral] [exponent]

section Decimal Literals
numeral ::= digit {[underline] digit}

section Decimal Literals
exponent ::= E [+] numeral | E - numeral

section Based Literals
based_literal ::= base # based_numeral [.based_numeral] # [exponent]

section Based Literals
base ::= numeral

section Based Literals
based_numeral ::= extended_digit {[underline] extended_digit}

section Based Literals
extended_digit ::= digit | A | B | C | D | E | F

section Character Literals
character_literal ::= 'graphic_character'

section String Literals
string_literal ::= "{string_element}"

section String Literals
string_element ::= "" | non_quotation_mark_graphic_character

A string_element is either a pair of quotation marks (""), or a
single graphic_character other than a quotation mark.

section Comments
comment ::= --{non_end_of_line_character}

section Pragmas
pragma ::=
   pragma identifier [(pragma_argument_association
      {, pragma_argument_association})];

section Pragmas
pragma_argument_association ::=
     [pragma_argument_identifier =>] name
   | [pragma_argument_identifier =>] expression

section Declarations
basic_declaration ::=
     type_declaration         | subtype_declaration
   | object_declaration       | number_declaration
   | subprogram_declaration   | abstract_subprogram_declaration
   | package_declaration      | renaming_declaration
   | exception_declaration    | generic_declaration
   | generic_instantiation

section Declarations
defining_identifier ::= identifier

section Type Declarations
type_declaration ::=
     full_type_declaration
   | incomplete_type_declaration
   | private_type_declaration
   | private_extension_declaration

section Type Declarations
full_type_declaration ::=
     type defining_identifier [known_discriminant_part]
       is type_definition;
   | task_type_declaration
   | protected_type_declaration

section Type Declarations
type_definition ::=
     enumeration_type_definition | integer_type_definition
   | real_type_definition        | array_type_definition
   | record_type_definition      | access_type_definition
   | derived_type_definition

section Subtype Declarations
subtype_declaration ::=
   subtype defining_identifier is subtype_indication;

section Subtype Declarations
subtype_indication ::=  subtype_mark [constraint]

section Subtype Declarations
subtype_mark ::= subtype_name

section Subtype Declarations
constraint ::= scalar_constraint | composite_constraint

section Subtype Declarations
scalar_constraint ::=
   range_constraint | digits_constraint | delta_constraint

section Subtype Declarations
composite_constraint ::=
   index_constraint | discriminant_constraint

section Object Declarations
object_declaration ::=
    defining_identifier_list : [aliased] [constant]
      subtype_indication [:= expression];
  | defining_identifier_list : [aliased] [constant]
      array_type_definition [:= expression];
  | single_task_declaration
  | single_protected_declaration

section Object Declarations
defining_identifier_list ::=
   defining_identifier {, defining_identifier}

section Number Declarations
number_declaration ::=
   defining_identifier_list : constant := static_expression;

section Derived Types and Classes
derived_type_definition ::= [abstract] new
  parent_subtype_indication [record_extension_part]

section Scalar Types
range_constraint ::= range range

section Scalar Types
range ::=
     range_attribute_reference
   | simple_expression .. simple_expression

section Enumeration Types
enumeration_type_definition ::=
   (enumeration_literal_specification
     {, enumeration_literal_specification})

section Enumeration Types
enumeration_literal_specification ::=
   defining_identifier | defining_character_literal

section Enumeration Types
defining_character_literal ::= character_literal

section Integer Types
integer_type_definition ::=
   signed_integer_type_definition | modular_type_definition

section Integer Types
signed_integer_type_definition ::=
   range static_simple_expression .. static_simple_expression

section Integer Types
modular_type_definition ::= mod static_expression

section Real Types
real_type_definition ::=
   floating_point_definition | fixed_point_definition

section Floating Point Types
floating_point_definition ::=
   digits static_expression [real_range_specification]

section Floating Point Types
real_range_specification ::=
   range static_simple_expression .. static_simple_expression

section Fixed Point Types
fixed_point_definition ::=
   ordinary_fixed_point_definition | decimal_fixed_point_definition

section Fixed Point Types
ordinary_fixed_point_definition ::=
   delta static_expression real_range_specification

section Fixed Point Types
decimal_fixed_point_definition ::=
   delta static_expression digits static_expression
     [real_range_specification]

section Fixed Point Types
digits_constraint ::=
   digits static_expression [range_constraint]

section Array Types
array_type_definition ::=
   unconstrained_array_definition | constrained_array_definition

section Array Types
unconstrained_array_definition ::=
   array(index_subtype_definition {, index_subtype_definition})
     of component_definition

section Array Types
index_subtype_definition ::= subtype_mark range <>

section Array Types
constrained_array_definition ::=
   array (discrete_subtype_definition
     {, discrete_subtype_definition}) of component_definition

section Array Types
discrete_subtype_definition ::= discrete_subtype_indication | range

section Array Types
component_definition ::= [aliased] subtype_indication

section Index Constraints and Discrete Ranges
index_constraint ::= (discrete_range {, discrete_range})

section Index Constraints and Discrete Ranges
discrete_range ::= discrete_subtype_indication | range

section Discriminants
discriminant_part ::=
   unknown_discriminant_part | known_discriminant_part

section Discriminants
unknown_discriminant_part ::= (<>)

section Discriminants
known_discriminant_part ::=
   (discriminant_specification {; discriminant_specification})

section Discriminants
discriminant_specification ::=
     defining_identifier_list : subtype_mark
       [:= default_expression]
   | defining_identifier_list : access_definition
       [:= default_expression]

section Discriminants
default_expression ::= expression

section Discriminant Constraints
discriminant_constraint ::=
   (discriminant_association {, discriminant_association})

section Discriminant Constraints
discriminant_association ::=
   [discriminant_selector_name
     {| discriminant_selector_name} =>] expression

section Record Types
record_type_definition ::=
   [[abstract] tagged] [limited] record_definition

section Record Types
record_definition ::=
     record
        component_list
     end record
   | null record

section Record Types
component_list ::=
     component_item {component_item}
   | {component_item} variant_part
   |  null;

section Record Types
component_item ::= component_declaration | representation_clause

section Record Types
component_declaration ::=
   defining_identifier_list : component_definition
     [:= default_expression];

section Variant Parts and Discrete Choices
variant_part ::=
   case discriminant_direct_name is
      variant
      {variant}
   end case;

section Variant Parts and Discrete Choices
variant ::=
   when discrete_choice_list =>
      component_list

section Variant Parts and Discrete Choices
discrete_choice_list ::= discrete_choice {| discrete_choice}

section Variant Parts and Discrete Choices
discrete_choice ::= expression | discrete_range | others

section Type Extensions
record_extension_part ::= with record_definition

section Access Types
access_type_definition ::=
     access_to_object_definition
   | access_to_subprogram_definition

section Access Types
access_to_object_definition ::=
    access [general_access_modifier] subtype_indication

section Access Types
general_access_modifier ::= all | constant

section Access Types
access_to_subprogram_definition ::=
     access [protected] procedure parameter_profile
   | access [protected] function  parameter_and_result_profile

section Access Types
access_definition ::= access subtype_mark

section Incomplete Type Declarations
incomplete_type_declaration ::=
   type defining_identifier [discriminant_part];

section Declarative Parts
declarative_part ::= {declarative_item}

section Declarative Parts
declarative_item ::= basic_declarative_item | body

section Declarative Parts
basic_declarative_item ::=
   basic_declaration | representation_clause | use_clause

section Declarative Parts
body ::= proper_body | body_stub

section Declarative Parts
proper_body ::=
   subprogram_body | package_body | task_body | protected_body

section Names
name ::=
     direct_name                | explicit_dereference
   | indexed_component          | slice
   | selected_component         | attribute_reference
   | type_conversion            | function_call
   | character_literal

section Names
direct_name ::= identifier | operator_symbol

section Names
prefix ::= name | implicit_dereference

section Names
explicit_dereference ::= name.all

section Names
implicit_dereference ::= name

section Indexed Components
indexed_component ::= prefix(expression {, expression})

section Slices
slice ::= prefix(discrete_range)

section Selected Components
selected_component ::= prefix . selector_name

section Selected Components
selector_name ::= identifier | character_literal | operator_symbol

section Attributes
attribute_reference ::= prefix'attribute_designator

section Attributes
attribute_designator ::=
     identifier[(static_expression)]
   | Access | Delta | Digits

section Attributes
range_attribute_reference ::= prefix'range_attribute_designator

section Attributes
range_attribute_designator ::= Range[(static_expression)]

section Aggregates
aggregate ::=
   record_aggregate | extension_aggregate | array_aggregate

section Record Aggregates
record_aggregate ::= (record_component_association_list)

section Record Aggregates
record_component_association_list ::=
     record_component_association {, record_component_association}
   | null record

section Record Aggregates
record_component_association ::=
   [ component_choice_list => ] expression

section Record Aggregates
component_choice_list ::=
     component_selector_name {| component_selector_name}
   | others

section Extension Aggregates
extension_aggregate ::=
(ancestor_part with record_component_association_list)

section Extension Aggregates
ancestor_part ::= expression | subtype_mark

section Array Aggregates
array_aggregate ::=
   positional_array_aggregate | named_array_aggregate

section Array Aggregates
positional_array_aggregate ::=
     (expression, expression {, expression})
   | (expression {, expression}, others => expression)

section Array Aggregates
named_array_aggregate ::=
   (array_component_association {, array_component_association})

section Array Aggregates
array_component_association ::=
   discrete_choice_list => expression

section Expressions
expression ::=
     relation {and relation} | relation {and then relation}
   | relation {or relation}  | relation {or else relation}
   | relation {xor relation}

section Expressions
relation ::=
     simple_expression [relational_operator simple_expression]
   | simple_expression [not] in range
   | simple_expression [not] in subtype_mark

section Expressions
simple_expression ::=
   [unary_adding_operator] term {binary_adding_operator term}

section Expressions
term ::= factor {multiplying_operator factor}

section Expressions
factor ::= primary [** primary] | abs primary | not primary

section Expressions
primary ::=
     numeric_literal   | null
   | string_literal    | aggregate
   | name              | qualified_expression
   | allocator         | (expression)

section Operators and Expression Evaluation
logical_operator             ::=  and | or  | xor

section Operators and Expression Evaluation
relational_operator          ::=  =   | /=  | <   | <= | > | >=

section Operators and Expression Evaluation
binary_adding_operator       ::=  +   | -   | &

section Operators and Expression Evaluation
unary_adding_operator        ::=  +   | -

section Operators and Expression Evaluation
multiplying_operator         ::=  *   | /   | mod | rem

section Operators and Expression Evaluation
highest_precedence_operator  ::=  **  | abs | not

section Type Conversions
type_conversion ::=
     subtype_mark(expression)
   | subtype_mark(name)

section Qualified Expressions
qualified_expression ::=
   subtype_mark'(expression) | subtype_mark'aggregate

section Allocators
allocator ::=
   new subtype_indication | new qualified_expression

section Simple and Compound Statements - Sequences of Statements
sequence_of_statements ::= statement {statement}

section Simple and Compound Statements - Sequences of Statements
statement ::=
   {label} simple_statement | {label} compound_statement

section Simple and Compound Statements - Sequences of Statements
simple_statement ::= null_statement
   | assignment_statement   | exit_statement
   | goto_statement         | procedure_call_statement
   | return_statement       | entry_call_statement
   | requeue_statement      | delay_statement
   | abort_statement        | raise_statement
   | code_statement

section Simple and Compound Statements - Sequences of Statements
compound_statement ::=
     if_statement           | case_statement
   | loop_statement         | block_statement
   | accept_statement       | select_statement

section Simple and Compound Statements - Sequences of Statements
null_statement ::= null;

section Simple and Compound Statements - Sequences of Statements
label ::= <<label_statement_identifier>>

section Simple and Compound Statements - Sequences of Statements
statement_identifier ::= direct_name

section Assignment Statements
assignment_statement ::= variable_name := expression;

section If Statements
if_statement ::=
   if condition then
      sequence_of_statements
   {elsif condition then
      sequence_of_statements}
   [else
      sequence_of_statements]
   end if;

section If Statements
condition ::= boolean_expression

section Case Statements
case_statement ::=
   case expression is
      case_statement_alternative
      {case_statement_alternative}
   end case;

section Case Statements
case_statement_alternative ::=
   when discrete_choice_list =>
      sequence_of_statements

section Loop Statements
loop_statement ::=
   [loop_statement_identifier:]
      [iteration_scheme] loop
         sequence_of_statements
      end loop [loop_identifier];

section Loop Statements
iteration_scheme ::= while condition
   | for loop_parameter_specification

section Loop Statements
loop_parameter_specification ::=
   defining_identifier in [reverse] discrete_subtype_definition

section Block Statements
block_statement ::=
   [block_statement_identifier:]
      [declare
         declarative_part]
      begin
         handled_sequence_of_statements
      end [block_identifier];

section Exit Statements
exit_statement ::= exit [loop_name] [when condition];

section Goto Statements
goto_statement ::= goto label_name;

section Subprogram Declarations
subprogram_declaration ::= subprogram_specification;

section Subprogram Declarations
abstract_subprogram_declaration ::= subprogram_specification is abstract;

section Subprogram Declarations
subprogram_specification ::=
     procedure defining_program_unit_name parameter_profile
   | function defining_designator parameter_and_result_profile

section Subprogram Declarations
designator ::= [parent_unit_name . ]identifier | operator_symbol

section Subprogram Declarations
defining_designator ::=
   defining_program_unit_name | defining_operator_symbol

section Subprogram Declarations
defining_program_unit_name ::=
   [parent_unit_name . ]defining_identifier

section Subprogram Declarations
operator_symbol ::= string_literal

section Subprogram Declarations
defining_operator_symbol ::= operator_symbol

section Subprogram Declarations
parameter_profile ::= [formal_part]

section Subprogram Declarations
parameter_and_result_profile ::= [formal_part] return subtype_mark

section Subprogram Declarations
formal_part ::=
   (parameter_specification {; parameter_specification})

section Subprogram Declarations
parameter_specification ::=
     defining_identifier_list : mode subtype_mark
       [:= default_expression]
   | defining_identifier_list : access_definition
       [:= default_expression]

section Subprogram Declarations
mode ::= [in] | in out | out

section Subprogram Bodies
subprogram_body ::=
   subprogram_specification is
      declarative_part
   begin
      handled_sequence_of_statements
   end [designator];

section Subprogram Calls
procedure_call_statement ::=
     procedure_name;
   | procedure_prefix actual_parameter_part;

section Subprogram Calls
function_call ::=
     function_name
   | function_prefix actual_parameter_part

section Subprogram Calls
actual_parameter_part ::=
   (parameter_association {, parameter_association})

section Subprogram Calls
parameter_association ::=
   [formal_parameter_selector_name =>] explicit_actual_parameter

section Subprogram Calls
explicit_actual_parameter ::= expression | variable_name

section Return Statements
return_statement ::= return [expression];

section Package Specifications and Declarations
package_declaration ::= package_specification;

section Package Specifications and Declarations
package_specification ::=
   package defining_program_unit_name is
      {basic_declarative_item}
   [private
      {basic_declarative_item}]
   end [[parent_unit_name.]identifier]

section Package Bodies
package_body ::=
   package body defining_program_unit_name is
      declarative_part
   [begin
      handled_sequence_of_statements]
   end [[parent_unit_name.]identifier];

section Private Types and Private Extensions
private_type_declaration ::=
   type defining_identifier [discriminant_part] is
     [[abstract] tagged] [limited] private;

section Private Types and Private Extensions
private_extension_declaration ::=
   type defining_identifier [discriminant_part] is
     [abstract] new ancestor_subtype_indication with private;

section Use Clauses
use_clause ::= use_package_clause | use_type_clause

section Use Clauses
use_package_clause ::= use package_name {, package_name};

section Use Clauses
use_type_clause ::= use type subtype_mark {, subtype_mark};

section Renaming Declarations
renaming_declaration ::=
      object_renaming_declaration
    | exception_renaming_declaration
    | package_renaming_declaration
    | subprogram_renaming_declaration
    | generic_renaming_declaration

section Object Renaming Declarations
object_renaming_declaration ::=
   defining_identifier : subtype_mark renames object_name;

section Exception Renaming Declarations
exception_renaming_declaration ::=
   defining_identifier : exception renames exception_name;

section Package Renaming Declarations
package_renaming_declaration ::=
   package defining_program_unit_name renames package_name;

section Subprogram Renaming Declarations
subprogram_renaming_declaration ::=
   subprogram_specification renames callable_entity_name;

section Generic Renaming Declarations
generic_renaming_declaration ::=
     generic package defining_program_unit_name renames
       generic_package_name;
   | generic procedure defining_program_unit_name renames
       generic_procedure_name;
   | generic function defining_program_unit_name renames
       generic_function_name;

section Task Units and Task Objects
task_type_declaration ::=
   task type defining_identifier [known_discriminant_part]
     [is task_definition];

section Task Units and Task Objects
single_task_declaration ::=
   task defining_identifier [is task_definition];

section Task Units and Task Objects
task_definition ::=
      {task_item}
   [ private
      {task_item}]
   end [task_identifier]

section Task Units and Task Objects
task_item ::= entry_declaration | representation_clause

section Task Units and Task Objects
task_body ::=
   task body defining_identifier is
      declarative_part
   begin
      handled_sequence_of_statements
   end [task_identifier];

section Protected Units and Protected Objects
protected_type_declaration ::=
   protected type defining_identifier [known_discriminant_part] is
     protected_definition;

section Protected Units and Protected Objects
single_protected_declaration ::=
   protected defining_identifier is protected_definition;

section Protected Units and Protected Objects
protected_definition ::=
      { protected_operation_declaration }
   [ private
      { protected_element_declaration } ]
   end [protected_identifier]

section Protected Units and Protected Objects
protected_operation_declaration ::=
     subprogram_declaration
   | entry_declaration
   | representation_clause

section Protected Units and Protected Objects
protected_element_declaration ::=
   protected_operation_declaration | component_declaration

section Protected Units and Protected Objects
protected_body ::=
   protected body defining_identifier is
      { protected_operation_item }
   end [protected_identifier];

section Protected Units and Protected Objects
protected_operation_item ::=
     subprogram_declaration
   | subprogram_body
   | entry_body
   | representation_clause

section Entries and Accept Statements
entry_declaration ::=
   entry defining_identifier [(discrete_subtype_definition)]
     parameter_profile;

section Entries and Accept Statements
accept_statement ::=
   accept entry_direct_name [(entry_index)] parameter_profile [do
      handled_sequence_of_statements
   end [entry_identifier]];

section Entries and Accept Statements
entry_index ::= expression

section Entries and Accept Statements
entry_body ::=
   entry defining_identifier entry_body_formal_part entry_barrier is
      declarative_part
   begin
      handled_sequence_of_statements
   end [entry_identifier];

section Entries and Accept Statements
entry_body_formal_part ::=
   [(entry_index_specification)] parameter_profile

section Entries and Accept Statements
entry_barrier ::= when condition

section Entries and Accept Statements
entry_index_specification ::=
   for defining_identifier in discrete_subtype_definition

section Entry Calls
entry_call_statement ::= entry_name [actual_parameter_part];

section Requeue Statements
requeue_statement ::= requeue entry_name [with abort];

section Delay Statements, Duration, and Time
delay_statement ::= delay_until_statement | delay_relative_statement

section Delay Statements, Duration, and Time
delay_until_statement ::= delay until delay_expression;

section Delay Statements, Duration, and Time
delay_relative_statement ::= delay delay_expression;

section Select Statements
select_statement ::=
     selective_accept
   | timed_entry_call
   | conditional_entry_call
   | asynchronous_select

section Selective Accept
selective_accept ::=
   select
      [guard]
      select_alternative
   { or
      [guard]
      select_alternative }
   [ else
      sequence_of_statements ]
  end select;

section Selective Accept
guard ::= when condition =>

section Selective Accept
select_alternative ::=
     accept_alternative
   | delay_alternative
   | terminate_alternative

section Selective Accept
accept_alternative ::=
accept_statement [sequence_of_statements]

section Selective Accept
delay_alternative ::=
delay_statement [sequence_of_statements]

section Selective Accept
terminate_alternative ::= terminate;

section Timed Entry Calls
timed_entry_call ::=
   select
      entry_call_alternative
   or
      delay_alternative
   end select;

section Timed Entry Calls
entry_call_alternative ::=
   entry_call_statement [sequence_of_statements]

section Conditional Entry Calls
conditional_entry_call ::=
   select
      entry_call_alternative
   else
      sequence_of_statements
   end select;

section Asynchronous Transfer of Control
asynchronous_select ::=
   select
      triggering_alternative
   then abort
      abortable_part
   end select;

section Asynchronous Transfer of Control
triggering_alternative ::=
   triggering_statement [sequence_of_statements]

section Asynchronous Transfer of Control
triggering_statement ::= entry_call_statement | delay_statement

section Asynchronous Transfer of Control
abortable_part ::= sequence_of_statements

section Abort of a Task - Abort of a Sequence of Statements
abort_statement ::= abort task_name {, task_name};

section Compilation Units - Library Units
compilation ::= {compilation_unit}

section Compilation Units - Library Units
compilation_unit ::=
     context_clause library_item
   | context_clause subunit

section Compilation Units - Library Units
library_item ::= [private] library_unit_declaration
   | library_unit_body
   | [private] library_unit_renaming_declaration

section Compilation Units - Library Units
library_unit_declaration ::=
     subprogram_declaration | package_declaration
   | generic_declaration    | generic_instantiation

section Compilation Units - Library Units
library_unit_renaming_declaration ::=
     package_renaming_declaration
   | generic_renaming_declaration
   | subprogram_renaming_declaration

section Compilation Units - Library Units
library_unit_body ::= subprogram_body | package_body

section Compilation Units - Library Units
parent_unit_name ::= name

section Context Clauses - With Clauses
context_clause ::= {context_item}

section Context Clauses - With Clauses
context_item ::= with_clause | use_clause

section Context Clauses - With Clauses
with_clause ::= with library_unit_name {, library_unit_name};

section Subunits of Compilation Units
body_stub ::=
     subprogram_body_stub
   | package_body_stub
   | task_body_stub
   | protected_body_stub

section Subunits of Compilation Units
subprogram_body_stub ::= subprogram_specification is separate;

section Subunits of Compilation Units
package_body_stub ::= package body defining_identifier is separate;

section Subunits of Compilation Units
task_body_stub ::= task body defining_identifier is separate;

section Subunits of Compilation Units
protected_body_stub ::=
   protected body defining_identifier is separate;

section Subunits of Compilation Units
subunit ::= separate (parent_unit_name) proper_body

section Exception Declarations
exception_declaration ::= defining_identifier_list : exception;

section Exception Handlers
handled_sequence_of_statements ::=
      sequence_of_statements
   [exception
      exception_handler
      {exception_handler}]

section Exception Handlers
exception_handler ::=
  when [choice_parameter_specification:] exception_choice
    {| exception_choice} =>
     sequence_of_statements

section Exception Handlers
choice_parameter_specification ::= defining_identifier

section Exception Handlers
exception_choice ::= exception_name | others

section Raise Statements
raise_statement ::= raise [exception_name];

section Generic Declarations
generic_declaration ::=
   generic_subprogram_declaration | generic_package_declaration

section Generic Declarations
generic_subprogram_declaration ::=
   generic_formal_part subprogram_specification;

section Generic Declarations
generic_package_declaration ::=
   generic_formal_part package_specification;

section Generic Declarations
generic_formal_part ::=
   generic {generic_formal_parameter_declaration | use_clause}

section Generic Declarations
generic_formal_parameter_declaration ::=
      formal_object_declaration
    | formal_type_declaration
    | formal_subprogram_declaration
    | formal_package_declaration

section Generic Instantiation
generic_instantiation ::=
     package defining_program_unit_name is
       new generic_package_name [generic_actual_part];
   | procedure defining_program_unit_name is
       new generic_procedure_name [generic_actual_part];
   | function defining_designator is
       new generic_function_name [generic_actual_part];

section Generic Instantiation
generic_actual_part ::=
   (generic_association {, generic_association})

section Generic Instantiation
generic_association ::=
   [generic_formal_parameter_selector_name =>]
     explicit_generic_actual_parameter

section Generic Instantiation
explicit_generic_actual_parameter ::= expression | variable_name
   | subprogram_name | entry_name | subtype_mark
   | package_instance_name

section Formal Objects
formal_object_declaration ::=
   defining_identifier_list : mode subtype_mark
     [:= default_expression];

section Formal Types
formal_type_declaration ::=
   type defining_identifier[discriminant_part] is
     formal_type_definition;

section Formal Types
formal_type_definition ::=
     formal_private_type_definition
   | formal_derived_type_definition
   | formal_discrete_type_definition
   | formal_signed_integer_type_definition
   | formal_modular_type_definition
   | formal_floating_point_definition
   | formal_ordinary_fixed_point_definition
   | formal_decimal_fixed_point_definition
   | formal_array_type_definition
   | formal_access_type_definition

section Formal Private and Derived Types
formal_private_type_definition ::=
   [[abstract] tagged] [limited] private

section Formal Private and Derived Types
formal_derived_type_definition ::=
   [abstract] new subtype_mark [with private]

section Formal Scalar Types
formal_discrete_type_definition ::= (<>)

section Formal Scalar Types
formal_signed_integer_type_definition ::= range <>

section Formal Scalar Types
formal_modular_type_definition ::= mod <>

section Formal Scalar Types
formal_floating_point_definition ::= digits <>

section Formal Scalar Types
formal_ordinary_fixed_point_definition ::= delta <>

section Formal Scalar Types
formal_decimal_fixed_point_definition ::= delta <> digits <>

section Formal Array Types
formal_array_type_definition ::= array_type_definition

section Formal Access Types
formal_access_type_definition ::= access_type_definition

section Formal Subprograms
formal_subprogram_declaration ::=
   with subprogram_specification [is subprogram_default];

section Formal Subprograms
subprogram_default ::= default_name | <>

section Formal Subprograms
default_name ::= name

section Formal Packages
formal_package_declaration ::=
   with package defining_identifier is new
     generic_package_name formal_package_actual_part;

section Formal Packages
formal_package_actual_part ::= (<>) | [generic_actual_part]

section Representation Items
representation_clause ::=
     attribute_definition_clause
   | enumeration_representation_clause
   | record_representation_clause
   | at_clause

section Representation Items
local_name ::=
     direct_name
   | direct_name'attribute_designator
   | library_unit_name

section Representation Attributes
attribute_definition_clause ::=
     for local_name'attribute_designator use expression;
   | for local_name'attribute_designator use name;

section Enumeration Representation Clauses
enumeration_representation_clause ::=
   for first_subtype_local_name use enumeration_aggregate;

section Enumeration Representation Clauses
enumeration_aggregate ::= array_aggregate

section Record Representation Clauses
record_representation_clause ::=
   for first_subtype_local_name use
      record [mod_clause]
         {component_clause}
      end record;

section Record Representation Clauses
component_clause ::=
   component_local_name at position range first_bit .. last_bit;

section Record Representation Clauses
position ::= static_expression

section Record Representation Clauses
first_bit ::= static_simple_expression

section Record Representation Clauses
last_bit ::= static_simple_expression

section Machine Code Insertions
code_statement ::= qualified_expression;

section Pragma Restrictions
restriction ::= restriction_identifier
   | restriction_parameter_identifier => expression

section Reduced Accuracy Subtypes
delta_constraint ::= delta static_expression [range_constraint]

section At Clauses
at_clause ::= for direct_name use at expression;

section Mod Clauses
mod_clause ::= at mod static_expression;

    SYNTAX CROSS REFERENCE 

  2. abort_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

abortable_part
   asynchronous_select                   section Asynchronous Transfer of Control

abstract_subprogram_declaration
   basic_declaration                     section Declarations

accept_alternative
   select_alternative                    section Selective Accept

accept_statement
   accept_alternative                    section Selective Accept
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

access_definition
   discriminant_specification            section Discriminants
   parameter_specification               section Subprogram Declarations

access_type_definition
   formal_access_type_definition         section Formal Access Types
   type_definition                       section Type Declarations

access_to_object_definition
   access_type_definition                section Access Types

access_to_subprogram_definition
   access_type_definition                section Access Types

actual_parameter_part
   entry_call_statement                  section Entry Calls
   function_call                         section Subprogram Calls
   procedure_call_statement              section Subprogram Calls

aggregate
   primary                               section Expressions
   qualified_expression                  section Qualified Expressions

allocator
   primary                               section Expressions

ancestor_part
   extension_aggregate                   section Extension Aggregates

array_aggregate
   aggregate                             section Aggregates
   enumeration_aggregate                 section Enumeration Representation Clauses

array_component_association
   named_array_aggregate                 section Array Aggregates

array_type_definition
   formal_array_type_definition          section Formal Array Types
   object_declaration                    section Object Declarations
   type_definition                       section Type Declarations

assignment_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

asynchronous_select
   select_statement                      section Select Statements

at_clause
   representation_clause                 section Representation Items

attribute_definition_clause
   representation_clause                 section Representation Items

attribute_designator
   attribute_definition_clause           section Representation Attributes
   attribute_reference                   section Attributes
   local_name                            section Representation Items

attribute_reference
   name                                  section Names

base
   based_literal                         section Based Literals

based_literal
   numeric_literal                       section Numeric Literals

based_numeral
   based_literal                         section Based Literals

basic_declaration
   basic_declarative_item                section Declarative Parts

basic_declarative_item
   declarative_item                      section Declarative Parts
   package_specification                 section Package Specifications and Declarations

binary_adding_operator
   simple_expression                     section Expressions

block_statement
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

body
   declarative_item                      section Declarative Parts

body_stub
   body                                  section Declarative Parts

case_statement
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

case_statement_alternative
   case_statement                        section Case Statements

character
   comment                               section Comments

character_literal
   defining_character_literal            section Enumeration Types
   name                                  section Names
   selector_name                         section Selected Components

choice_parameter_specification
   exception_handler                     section Exception Handlers

code_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

compilation_unit
   compilation                           section Compilation Units - Library Units

component_choice_list
   record_component_association          section Record Aggregates

component_clause
   record_representation_clause          section Record Representation Clauses

component_declaration
   component_item                        section Record Types
   protected_element_declaration         section Protected Units and Protected Objects

component_definition
   component_declaration                 section Record Types
   constrained_array_definition          section Array Types
   unconstrained_array_definition        section Array Types

component_item
   component_list                        section Record Types

component_list
   record_definition                     section Record Types
   variant                               section Variant Parts and Discrete Choices

composite_constraint
   constraint                            section Subtype Declarations

compound_statement
   statement                             section Simple and Compound Statements - Sequences of Statements

condition
   entry_barrier                         section Entries and Accept Statements
   exit_statement                        section Exit Statements
   guard                                 section Selective Accept
   if_statement                          section If Statements
   iteration_scheme                      section Loop Statements

conditional_entry_call
   select_statement                      section Select Statements

constrained_array_definition
   array_type_definition                 section Array Types

constraint
   subtype_indication                    section Subtype Declarations

context_clause
   compilation_unit                      section Compilation Units - Library Units

context_item
   context_clause                        section Context Clauses - With Clauses

decimal_fixed_point_definition
   fixed_point_definition                section Fixed Point Types

decimal_literal
   numeric_literal                       section Numeric Literals

declarative_item
   declarative_part                      section Declarative Parts

declarative_part
   block_statement                       section Block Statements
   entry_body                            section Entries and Accept Statements
   package_body                          section Package Bodies
   subprogram_body                       section Subprogram Bodies
   task_body                             section Task Units and Task Objects
default_expression
   component_declaration                 section Record Types
   discriminant_specification            section Discriminants
   formal_object_declaration             section Formal Objects
   parameter_specification               section Subprogram Declarations

default_name
   subprogram_default                    section Formal Subprograms

defining_character_literal
   enumeration_literal_specification     section Enumeration Types

defining_designator
   generic_instantiation                 section Generic Instantiation
   subprogram_specification              section Subprogram Declarations

defining_identifier
   choice_parameter_specification        section Exception Handlers
   defining_identifier_list              section Object Declarations
   defining_program_unit_name            section Subprogram Declarations
   entry_body                            section Entries and Accept Statements
   entry_declaration                     section Entries and Accept Statements
   entry_index_specification             section Entries and Accept Statements
   enumeration_literal_specification     section Enumeration Types
   exception_renaming_declaration        section Exception Renaming Declarations
   formal_package_declaration            section Formal Packages
   formal_type_declaration               section Formal Types
   full_type_declaration                 section Type Declarations
   incomplete_type_declaration           section Incomplete Type Declarations
   loop_parameter_specification          section Loop Statements
   object_renaming_declaration           section Object Renaming Declarations
   package_body_stub                     section Subunits of Compilation Units
   private_extension_declaration         section Private Types and Private Extensions
   private_type_declaration              section Private Types and Private Extensions
   protected_body                        section Protected Units and Protected Objects
   protected_body_stub                   section Subunits of Compilation Units
   protected_type_declaration            section Protected Units and Protected Objects
   single_protected_declaration          section Protected Units and Protected Objects
   single_task_declaration               section Task Units and Task Objects
   subtype_declaration                   section Subtype Declarations
   task_body                             section Task Units and Task Objects
   task_body_stub                        section Subunits of Compilation Units
   task_type_declaration                 section Task Units and Task Objects

defining_identifier_list
   component_declaration                 section Record Types
   discriminant_specification            section Discriminants
   exception_declaration                 section Exception Declarations
   formal_object_declaration             section Formal Objects
   number_declaration                    section Number Declarations
   object_declaration                    section Object Declarations
   parameter_specification               section Subprogram Declarations

defining_operator_symbol
   defining_designator                   section Subprogram Declarations

defining_program_unit_name
   defining_designator                   section Subprogram Declarations
   generic_instantiation                 section Generic Instantiation
   generic_renaming_declaration          section Generic Renaming Declarations
   package_body                          section Package Bodies
   package_renaming_declaration          section Package Renaming Declarations
   package_specification                 section Package Specifications and Declarations
   subprogram_specification              section Subprogram Declarations

delay_alternative
   select_alternative                    section Selective Accept
   timed_entry_call                      section Timed Entry Calls

delay_relative_statement
   delay_statement                       section Delay Statements, Duration, and Time

delay_statement
   delay_alternative                     section Selective Accept
   simple_statement                      section Simple and Compound Statements - Sequences of Statements
   triggering_statement                  section Asynchronous Transfer of Control

delay_until_statement
   delay_statement                       section Delay Statements, Duration, and Time

delta_constraint
   scalar_constraint                     section Subtype Declarations

derived_type_definition
   type_definition                       section Type Declarations

designator
   subprogram_body                       section Subprogram Bodies

digit
   extended_digit                        section Based Literals
   graphic_character                     section Character Set
   letter_or_digit                       section Identifiers
   numeral                               section Decimal Literals

digits_constraint
   scalar_constraint                     section Subtype Declarations

direct_name
   accept_statement                      section Entries and Accept Statements
   at_clause                             section At Clauses
   local_name                            section Representation Items
   name                                  section Names
   statement_identifier                  section Simple and Compound Statements - Sequences of Statements
   variant_part                          section Variant Parts and Discrete Choices

discrete_choice
   discrete_choice_list                  section Variant Parts and Discrete Choices

discrete_choice_list
   array_component_association           section Array Aggregates
   case_statement_alternative            section Case Statements
   variant                               section Variant Parts and Discrete Choices

discrete_range
   discrete_choice                       section Variant Parts and Discrete Choices
   index_constraint                      section Index Constraints and Discrete Ranges
   slice                                 section Slices

discrete_subtype_definition
   constrained_array_definition          section Array Types
   entry_declaration                     section Entries and Accept Statements
   entry_index_specification             section Entries and Accept Statements
   loop_parameter_specification          section Loop Statements

discriminant_association
   discriminant_constraint               section Discriminant Constraints

discriminant_constraint
   composite_constraint                  section Subtype Declarations

discriminant_part
   formal_type_declaration               section Formal Types
   incomplete_type_declaration           section Incomplete Type Declarations
   private_extension_declaration         section Private Types and Private Extensions
   private_type_declaration              section Private Types and Private Extensions

discriminant_specification
   known_discriminant_part               section Discriminants

entry_barrier
   entry_body                            section Entries and Accept Statements

entry_body
   protected_operation_item              section Protected Units and Protected Objects

entry_body_formal_part
   entry_body                            section Entries and Accept Statements

entry_call_alternative
   conditional_entry_call                section Conditional Entry Calls
   timed_entry_call                      section Timed Entry Calls

entry_call_statement
   entry_call_alternative                section Timed Entry Calls
   simple_statement                      section Simple and Compound Statements - Sequences of Statements
   triggering_statement                  section Asynchronous Transfer of Control

entry_declaration
   protected_operation_declaration       section Protected Units and Protected Objects
   task_item                             section Task Units and Task Objects

entry_index
   accept_statement                      section Entries and Accept Statements

entry_index_specification
   entry_body_formal_part                section Entries and Accept Statements

enumeration_aggregate
   enumeration_representation_clause     section Enumeration Representation Clauses

enumeration_literal_specification
   enumeration_type_definition           section Enumeration Types

enumeration_representation_clause
   representation_clause                 section Representation Items

enumeration_type_definition
   type_definition                       section Type Declarations

exception_choice
   exception_handler                     section Exception Handlers

exception_declaration
   basic_declaration                     section Declarations

exception_handler
   handled_sequence_of_statements        section Exception Handlers

exception_renaming_declaration
   renaming_declaration                  section Renaming Declarations

exit_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

explicit_actual_parameter
   parameter_association                 section Subprogram Calls

explicit_dereference
   name                                  section Names

explicit_generic_actual_parameter
   generic_association                   section Generic Instantiation

exponent
   based_literal                         section Based Literals
   decimal_literal                       section Decimal Literals

expression
   ancestor_part                         section Extension Aggregates
   array_component_association           section Array Aggregates
   assignment_statement                  section Assignment Statements
   at_clause                             section At Clauses
   attribute_definition_clause           section Representation Attributes
   attribute_designator                  section Attributes
   case_statement                        section Case Statements
   condition                             section If Statements
   decimal_fixed_point_definition        section Fixed Point Types
   default_expression                    section Discriminants
   delay_relative_statement              section Delay Statements, Duration, and Time
   delay_until_statement                 section Delay Statements, Duration, and Time
   delta_constraint                      section Reduced Accuracy Subtypes
   digits_constraint                     section Fixed Point Types
   discrete_choice                       section Variant Parts and Discrete Choices
   discriminant_association              section Discriminant Constraints
   entry_index                           section Entries and Accept Statements
   explicit_actual_parameter             section Subprogram Calls
   explicit_generic_actual_parameter     section Generic Instantiation
   floating_point_definition             section Floating Point Types
   indexed_component                     section Indexed Components
   mod_clause                            section Mod Clauses
   modular_type_definition               section Integer Types
   number_declaration                    section Number Declarations
   object_declaration                    section Object Declarations
   ordinary_fixed_point_definition       section Fixed Point Types
   position                              section Record Representation Clauses
   positional_array_aggregate            section Array Aggregates
   pragma_argument_association           section Pragmas
   primary                               section Expressions
   qualified_expression                  section Qualified Expressions
   range_attribute_designator            section Attributes
   record_component_association          section Record Aggregates
   restriction                           section Pragma Restrictions
   return_statement                      section Return Statements
   type_conversion                       section Type Conversions

extended_digit
   based_numeral                         section Based Literals

extension_aggregate
   aggregate                             section Aggregates

factor
   term                                  section Expressions

first_bit
   component_clause                      section Record Representation Clauses

fixed_point_definition
   real_type_definition                  section Real Types

floating_point_definition
   real_type_definition                  section Real Types

formal_access_type_definition
   formal_type_definition                section Formal Types

formal_array_type_definition
   formal_type_definition                section Formal Types

formal_decimal_fixed_point_definition
   formal_type_definition                section Formal Types

formal_derived_type_definition
   formal_type_definition                section Formal Types

formal_discrete_type_definition
   formal_type_definition                section Formal Types

formal_floating_point_definition
   formal_type_definition                section Formal Types

formal_modular_type_definition
   formal_type_definition                section Formal Types

formal_object_declaration
   generic_formal_parameter_declaration  section Generic Declarations

formal_ordinary_fixed_point_definition
   formal_type_definition                section Formal Types

formal_package_actual_part
   formal_package_declaration            section Formal Packages

formal_package_declaration
   generic_formal_parameter_declaration  section Generic Declarations

formal_part
   parameter_and_result_profile          section Subprogram Declarations
   parameter_profile                     section Subprogram Declarations

formal_private_type_definition
   formal_type_definition                section Formal Types

formal_signed_integer_type_definition
   formal_type_definition                section Formal Types

formal_subprogram_declaration
   generic_formal_parameter_declaration  section Generic Declarations

formal_type_declaration
   generic_formal_parameter_declaration  section Generic Declarations

formal_type_definition
   formal_type_declaration               section Formal Types

format_effector
   character                             section Character Set

full_type_declaration
   type_declaration                      section Type Declarations

function_call
   name                                  section Names

general_access_modifier
   access_to_object_definition           section Access Types

generic_actual_part
   formal_package_actual_part            section Formal Packages
   generic_instantiation                 section Generic Instantiation

generic_association
   generic_actual_part                   section Generic Instantiation

generic_declaration
   basic_declaration                     section Declarations
   library_unit_declaration              section Compilation Units - Library Units

generic_formal_parameter_declaration
   generic_formal_part                   section Generic Declarations

generic_formal_part
   generic_package_declaration           section Generic Declarations
   generic_subprogram_declaration        section Generic Declarations

generic_instantiation
   basic_declaration                     section Declarations
   library_unit_declaration              section Compilation Units - Library Units

generic_package_declaration
   generic_declaration                   section Generic Declarations

generic_renaming_declaration
   library_unit_renaming_declaration     section Compilation Units - Library Units
   renaming_declaration                  section Renaming Declarations

generic_subprogram_declaration
   generic_declaration                   section Generic Declarations

goto_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

graphic_character
   character                             section Character Set
   character_literal                     section Character Literals
   string_element                        section String Literals

guard
   selective_accept                      section Selective Accept

handled_sequence_of_statements
   accept_statement                      section Entries and Accept Statements
   block_statement                       section Block Statements
   entry_body                            section Entries and Accept Statements
   package_body                          section Package Bodies
   subprogram_body                       section Subprogram Bodies
   task_body                             section Task Units and Task Objects

identifier
   accept_statement                      section Entries and Accept Statements
   attribute_designator                  section Attributes
   block_statement                       section Block Statements
   defining_identifier                   section Declarations
   designator                            section Subprogram Declarations
   direct_name                           section Names
   entry_body                            section Entries and Accept Statements
   loop_statement                        section Loop Statements
   package_body                          section Package Bodies
   package_specification                 section Package Specifications and Declarations
   pragma                                section Pragmas
   pragma_argument_association           section Pragmas
   protected_body                        section Protected Units and Protected Objects
   protected_definition                  section Protected Units and Protected Objects
   restriction                           section Pragma Restrictions
   selector_name                         section Selected Components
   task_body                             section Task Units and Task Objects
   task_definition                       section Task Units and Task Objects

identifier_letter
   graphic_character                     section Character Set
   identifier                            section Identifiers
   letter_or_digit                       section Identifiers

if_statement
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

implicit_dereference
   prefix                                section Names

incomplete_type_declaration
   type_declaration                      section Type Declarations

index_constraint
   composite_constraint                  section Subtype Declarations

index_subtype_definition
   unconstrained_array_definition        section Array Types

indexed_component
   name                                  section Names

integer_type_definition
   type_definition                       section Type Declarations

iteration_scheme
   loop_statement                        section Loop Statements

known_discriminant_part
   discriminant_part                     section Discriminants
   full_type_declaration                 section Type Declarations
   protected_type_declaration            section Protected Units and Protected Objects
   task_type_declaration                 section Task Units and Task Objects

label
   statement                             section Simple and Compound Statements - Sequences of Statements

last_bit
   component_clause                      section Record Representation Clauses

letter_or_digit
   identifier                            section Identifiers

library_item
   compilation_unit                      section Compilation Units - Library Units

library_unit_body
   library_item                          section Compilation Units - Library Units

library_unit_declaration
   library_item                          section Compilation Units - Library Units

library_unit_renaming_declaration
   library_item                          section Compilation Units - Library Units

local_name
   attribute_definition_clause           section Representation Attributes
   component_clause                      section Record Representation Clauses
   enumeration_representation_clause     section Enumeration Representation Clauses
   record_representation_clause          section Record Representation Clauses

loop_parameter_specification
   iteration_scheme                      section Loop Statements

loop_statement
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

mod_clause
   record_representation_clause          section Record Representation Clauses

mode
   formal_object_declaration             section Formal Objects
   parameter_specification               section Subprogram Declarations

modular_type_definition
   integer_type_definition               section Integer Types

multiplying_operator
   term                                  section Expressions

name
   abort_statement                       section Abort of a Task - Abort of a Sequence of Statements
   assignment_statement                  section Assignment Statements
   attribute_definition_clause           section Representation Attributes
   default_name                          section Formal Subprograms
   entry_call_statement                  section Entry Calls
   exception_choice                      section Exception Handlers
   exception_renaming_declaration        section Exception Renaming Declarations
   exit_statement                        section Exit Statements
   explicit_actual_parameter             section Subprogram Calls
   explicit_dereference                  section Names
   explicit_generic_actual_parameter     section Generic Instantiation
   formal_package_declaration            section Formal Packages
   function_call                         section Subprogram Calls
   generic_instantiation                 section Generic Instantiation
   generic_renaming_declaration          section Generic Renaming Declarations
   goto_statement                        section Goto Statements
   implicit_dereference                  section Names
   local_name                            section Representation Items
   object_renaming_declaration           section Object Renaming Declarations
   package_renaming_declaration          section Package Renaming Declarations
   parent_unit_name                      section Compilation Units - Library Units
   pragma_argument_association           section Pragmas
   prefix                                section Names
   primary                               section Expressions
   procedure_call_statement              section Subprogram Calls
   raise_statement                       section Raise Statements
   requeue_statement                     section Requeue Statements
   subprogram_renaming_declaration       section Subprogram Renaming Declarations
   subtype_mark                          section Subtype Declarations
   type_conversion                       section Type Conversions
   use_package_clause                    section Use Clauses
   with_clause                           section Context Clauses - With Clauses

named_array_aggregate
   array_aggregate                       section Array Aggregates

null_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

number_declaration
   basic_declaration                     section Declarations

numeral
   base                                  section Based Literals
   decimal_literal                       section Decimal Literals
   exponent                              section Decimal Literals

numeric_literal
   primary                               section Expressions

object_declaration
   basic_declaration                     section Declarations

object_renaming_declaration
   renaming_declaration                  section Renaming Declarations

operator_symbol
   defining_operator_symbol              section Subprogram Declarations
   designator                            section Subprogram Declarations
   direct_name                           section Names
   selector_name                         section Selected Components

ordinary_fixed_point_definition
   fixed_point_definition                section Fixed Point Types

other_control_function
   character                             section Character Set

package_body
   library_unit_body                     section Compilation Units - Library Units
   proper_body                           section Declarative Parts

package_body_stub
   body_stub                             section Subunits of Compilation Units

package_declaration
   basic_declaration                     section Declarations
   library_unit_declaration              section Compilation Units - Library Units

package_renaming_declaration
   library_unit_renaming_declaration     section Compilation Units - Library Units
   renaming_declaration                  section Renaming Declarations

package_specification
   generic_package_declaration           section Generic Declarations
   package_declaration                   section Package Specifications and Declarations

parameter_and_result_profile
   access_to_subprogram_definition       section Access Types
   subprogram_specification              section Subprogram Declarations

parameter_association
   actual_parameter_part                 section Subprogram Calls

parameter_profile
   accept_statement                      section Entries and Accept Statements
   access_to_subprogram_definition       section Access Types
   entry_body_formal_part                section Entries and Accept Statements
   entry_declaration                     section Entries and Accept Statements
   subprogram_specification              section Subprogram Declarations

parameter_specification
   formal_part                           section Subprogram Declarations

parent_unit_name
   defining_program_unit_name            section Subprogram Declarations
   designator                            section Subprogram Declarations
   package_body                          section Package Bodies
   package_specification                 section Package Specifications and Declarations
   subunit                               section Subunits of Compilation Units

position
   component_clause                      section Record Representation Clauses

positional_array_aggregate
   array_aggregate                       section Array Aggregates

pragma_argument_association
   pragma                                section Pragmas

prefix
   attribute_reference                   section Attributes
   function_call                         section Subprogram Calls
   indexed_component                     section Indexed Components
   procedure_call_statement              section Subprogram Calls
   range_attribute_reference             section Attributes
   selected_component                    section Selected Components
   slice                                 section Slices

primary
   factor                                section Expressions

private_extension_declaration
   type_declaration                      section Type Declarations

private_type_declaration
   type_declaration                      section Type Declarations

procedure_call_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

proper_body
   body                                  section Declarative Parts
   subunit                               section Subunits of Compilation Units

protected_body
   proper_body                           section Declarative Parts

protected_body_stub
   body_stub                             section Subunits of Compilation Units

protected_definition
   protected_type_declaration            section Protected Units and Protected Objects
   single_protected_declaration          section Protected Units and Protected Objects

protected_element_declaration
   protected_definition                  section Protected Units and Protected Objects

protected_operation_declaration
   protected_definition                  section Protected Units and Protected Objects
   protected_element_declaration         section Protected Units and Protected Objects

protected_operation_item
   protected_body                        section Protected Units and Protected Objects

protected_type_declaration
   full_type_declaration                 section Type Declarations

qualified_expression
   allocator                             section Allocators
   code_statement                        section Machine Code Insertions
   primary                               section Expressions

raise_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

range
   discrete_range                        section Index Constraints and Discrete Ranges
   discrete_subtype_definition           section Array Types
   range_constraint                      section Scalar Types
   relation                              section Expressions

range_attribute_designator
   range_attribute_reference             section Attributes

range_attribute_reference
   range                                 section Scalar Types

range_constraint
   delta_constraint                      section Reduced Accuracy Subtypes
   digits_constraint                     section Fixed Point Types
   scalar_constraint                     section Subtype Declarations

real_range_specification
   decimal_fixed_point_definition        section Fixed Point Types
   floating_point_definition             section Floating Point Types
   ordinary_fixed_point_definition       section Fixed Point Types

real_type_definition
   type_definition                       section Type Declarations

record_aggregate
   aggregate                             section Aggregates

record_component_association
   record_component_association_list     section Record Aggregates

record_component_association_list
   extension_aggregate                   section Extension Aggregates
   record_aggregate                      section Record Aggregates

record_definition
   record_extension_part                 section Type Extensions
   record_type_definition                section Record Types

record_extension_part
   derived_type_definition               section Derived Types and Classes

record_representation_clause
   representation_clause                 section Representation Items

record_type_definition
   type_definition                       section Type Declarations

relation
   expression                            section Expressions

relational_operator
   relation                              section Expressions

renaming_declaration
   basic_declaration                     section Declarations

representation_clause
   basic_declarative_item                section Declarative Parts
   component_item                        section Record Types
   protected_operation_declaration       section Protected Units and Protected Objects
   protected_operation_item              section Protected Units and Protected Objects
   task_item                             section Task Units and Task Objects

requeue_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

return_statement
   simple_statement                      section Simple and Compound Statements - Sequences of Statements

scalar_constraint
   constraint                            section Subtype Declarations

select_alternative
   selective_accept                      section Selective Accept

select_statement
   compound_statement                    section Simple and Compound Statements - Sequences of Statements

selected_component
   name                                  section Names

selective_accept
   select_statement                      section Select Statements

selector_name
   component_choice_list                 section Record Aggregates
   discriminant_association              section Discriminant Constraints
   generic_association                   section Generic Instantiation
   parameter_association                 section Subprogram Calls
   selected_component                    section Selected Components

sequence_of_statements
   abortable_part                        section Asynchronous Transfer of Control
   accept_alternative                    section Selective Accept
   case_statement_alternative            section Case Statements
   conditional_entry_call                section Conditional Entry Calls
   delay_alternative                     section Selective Accept
   entry_call_alternative                section Timed Entry Calls
   exception_handler                     section Exception Handlers
   handled_sequence_of_statements        section Exception Handlers
   if_statement                          section If Statements
   loop_statement                        section Loop Statements
   selective_accept                      section Selective Accept
   triggering_alternative                section Asynchronous Transfer of Control

signed_integer_type_definition
   integer_type_definition               section Integer Types

simple_expression
   first_bit                             section Record Representation Clauses
   last_bit                              section Record Representation Clauses
   range                                 section Scalar Types
   real_range_specification              section Floating Point Types
   relation                              section Expressions
   signed_integer_type_definition        section Integer Types

simple_statement
   statement                             section Simple and Compound Statements - Sequences of Statements

single_protected_declaration
   object_declaration                    section Object Declarations

single_task_declaration
   object_declaration                    section Object Declarations

slice
   name                                  section Names

space_character
   graphic_character                     section Character Set

special_character
   graphic_character                     section Character Set

statement
   sequence_of_statements                section Simple and Compound Statements - Sequences of Statements

statement_identifier
   block_statement                       section Block Statements
   label                                 section Simple and Compound Statements - Sequences of Statements
   loop_statement                        section Loop Statements
string_element
   string_literal                        section String Literals

string_literal
   operator_symbol                       section Subprogram Declarations
   primary                               section Expressions

subprogram_body
   library_unit_body                     section Compilation Units - Library Units
   proper_body                           section Declarative Parts
   protected_operation_item              section Protected Units and Protected Objects

subprogram_body_stub
   body_stub                             section Subunits of Compilation Units

subprogram_declaration
   basic_declaration                     section Declarations
   library_unit_declaration              section Compilation Units - Library Units
   protected_operation_declaration       section Protected Units and Protected Objects
   protected_operation_item              section Protected Units and Protected Objects

subprogram_default
   formal_subprogram_declaration         section Formal Subprograms

subprogram_renaming_declaration
   library_unit_renaming_declaration     section Compilation Units - Library Units
   renaming_declaration                  section Renaming Declarations

subprogram_specification
   abstract_subprogram_declaration       section Subprogram Declarations
   formal_subprogram_declaration         section Formal Subprograms
   generic_subprogram_declaration        section Generic Declarations
   subprogram_body                       section Subprogram Bodies
   subprogram_body_stub                  section Subunits of Compilation Units
   subprogram_declaration                section Subprogram Declarations
   subprogram_renaming_declaration       section Subprogram Renaming Declarations

subtype_declaration
   basic_declaration                     section Declarations

subtype_indication
   access_to_object_definition           section Access Types
   allocator                             section Allocators
   component_definition                  section Array Types
   derived_type_definition               section Derived Types and Classes
   discrete_range                        section Index Constraints and Discrete Ranges
   discrete_subtype_definition           section Array Types
   object_declaration                    section Object Declarations
   private_extension_declaration         section Private Types and Private Extensions
   subtype_declaration                   section Subtype Declarations

subtype_mark
   access_definition                     section Access Types
   ancestor_part                         section Extension Aggregates
   discriminant_specification            section Discriminants
   explicit_generic_actual_parameter     section Generic Instantiation
   formal_derived_type_definition        section Formal Private and Derived Types
   formal_object_declaration             section Formal Objects
   index_subtype_definition              section Array Types
   object_renaming_declaration           section Object Renaming Declarations
   parameter_and_result_profile          section Subprogram Declarations
   parameter_specification               section Subprogram Declarations
   qualified_expression                  section Qualified Expressions
   relation                              section Expressions
   subtype_indication                    section Subtype Declarations
   type_conversion                       section Type Conversions
   use_type_clause                       section Use Clauses

subunit
   compilation_unit                      section Compilation Units - Library Units

task_body
   proper_body                           section Declarative Parts

task_body_stub
   body_stub                             section Subunits of Compilation Units

task_definition
   single_task_declaration               section Task Units and Task Objects
   task_type_declaration                 section Task Units and Task Objects

task_item
   task_definition                       section Task Units and Task Objects

task_type_declaration
   full_type_declaration                 section Type Declarations

term
   simple_expression                     section Expressions

terminate_alternative
   select_alternative                    section Selective Accept

timed_entry_call
   select_statement                      section Select Statements

triggering_alternative
   asynchronous_select                   section Asynchronous Transfer of Control

triggering_statement
   triggering_alternative                section Asynchronous Transfer of Control

type_conversion
   name                                  section Names

type_declaration
   basic_declaration                     section Declarations

type_definition
   full_type_declaration                 section Type Declarations

unary_adding_operator
   simple_expression                     section Expressions

unconstrained_array_definition
   array_type_definition                 section Array Types

underline
   based_numeral                         section Based Literals
   identifier                            section Identifiers
   numeral                               section Decimal Literals

unknown_discriminant_part
   discriminant_part                     section Discriminants

use_clause
   basic_declarative_item                section Declarative Parts
   context_item                          section Context Clauses - With Clauses
   generic_formal_part                   section Generic Declarations

use_package_clause
   use_clause                            section Use Clauses

use_type_clause
   use_clause                            section Use Clauses

variant
   variant_part                          section Variant Parts and Discrete Choices

variant_part
   component_list                        section Record Types

with_clause
   context_item                          section Context Clauses - With Clauses

Index

Index entries are given by paragraph number. A list of all
language-defined library units may be found under Language-Defined
Library Units. A list of all language-defined types may be found under
Language-Defined Types.

Operator index

&  operator    section Expressions(1), section Binary Adding Operators(1), section Binary Adding Operators(3)

*  operator    section Expressions(1), section Multiplying Operators(1), section Multiplying Operators(1)
** operator    section Expressions(1), section Highest Precedence Operators(1), section Highest Precedence Operators(7)

+  operator    section Expressions(1), section Binary Adding Operators(1), section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1)

=  operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)

-  operator    section Expressions(1), section Binary Adding Operators(1), section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1)

/  operator    section Expressions(1), section Multiplying Operators(1), section Multiplying Operators(1)
/= operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)

<  operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)
<= operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)

>  operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)
>= operator    section Expressions(1), section Relational Operators and Membership Tests(1), section Relational Operators and Membership Tests(1)

Digits index

10646-1:1993, ISO/IEC standard    section Normative References.
1539:1991,    ISO/IEC standard    section Normative References.
1989:1985,    ISO standard        section Normative References.

6429:1992,    ISO/IEC standard    section Normative References.
646:1991,     ISO/IEC standard    section Normative References.

8859-1:1987,  ISO/IEC standard    section Normative References.

9899:1990,    ISO/IEC standard    section Normative References.

index

A_Form    section Type Conversions.
abnormal completion    section Completion and Finalization.
abnormal state of an object    section Data Validity.
   [partial]    section Abort of a Task - Abort of a Sequence of Statements(21), see section Exceptions and Optimization(6), see section Exceptions in Input-Output(21), see section Exceptions and Optimization(6), see section Exceptions in Input-Output.
abnormal task    section Abort of a Task - Abort of a Sequence of Statements.
abort
   of a partition    section Partitions.
   of a task    section Abort of a Task - Abort of a Sequence of Statements.
   of the execution of a construct    section Abort of a Task - Abort of a Sequence of Statements.
abort completion point    section Abort of a Task - Abort of a Sequence of Statements.
abort-deferred operation    section Abort of a Task - Abort of a Sequence of Statements.
abort_statement    section Abort of a Task - Abort of a Sequence of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Abort_Task    section The Package Task_Identification.
abortable_part    section Asynchronous Transfer of Control.
   used    section Asynchronous Transfer of Control(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
abs operator    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
absolute value    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
abstract data type (ADT)
   See also abstract type    section Abstract Types and Subprograms.
   See private types and private extensions    section Private Types and Private Extensions.
abstract subprogram    section Abstract Types and Subprograms(1), see section Abstract Types and Subprograms(1), see section Abstract Types and Subprograms.
abstract type    section Abstract Types and Subprograms(1), see section Abstract Types and Subprograms(1), see section Abstract Types and Subprograms.
abstract_subprogram_declaration    section Subprogram Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Acc    section Storage Management.
accept_alternative    section Selective Accept.
   used    section Selective Accept(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
accept_statement    section Entries and Accept Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Selective Accept(5), see section Syntax Summary (informative)(5), see section Selective Accept(5), see section Syntax Summary (informative).
acceptable interpretation    section The Context of Overload Resolution.
Access attribute    section Operations of Access Types(24), see section Operations of Access Types(24), see section Operations of Access Types,
                    section Language-Defined Attributes (informative)(2),        section Language-Defined Attributes (informative)(2),        section Language-Defined Attributes (informative).
   See also Unchecked_Access attribute    section Unchecked Access Value Creation.
access discriminant    section Discriminants.
access parameter    section Subprogram Declarations.
access paths
   distinct    section Formal Parameter Modes.
access type    section Access Types(1), see section Glossary (informative)(1), see section Glossary (informative).
access types
   input-output unspecified    section External Files and File Objects.
access value    section Access Types.
access-to-constant type    section Access Types.
access-to-object type    section Access Types.
access-to-subprogram type    section Access Types(7), see section Access Types(7), see section Access Types.
access-to-variable type    section Access Types.
Access_Check    section Suppressing Checks.
   [partial]    section Names(13), see section Type Conversions(13), see section Type Conversions.
access_definition    section Access Types.
   used    section Discriminants(5), see section Subprogram Declarations(15), see section Syntax Summary (informative)(5), see section Subprogram Declarations(15), see section Syntax Summary (informative).
access_type_definition    section Access Types.
   used    section Type Declarations(4), see section Formal Access Types(2), see section Syntax Summary (informative)(4), see section Formal Access Types(2), see section Syntax Summary (informative).
access_to_object_definition    section Access Types.
   used    section Access Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
access_to_subprogram_definition    section Access Types.
   used    section Access Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
accessibility
   from shared passive library units    section Shared Passive Library Units.
accessibility level    section Operations of Access Types.
accessibility rule
   Access attribute    section Operations of Access Types(28), see section Operations of Access Types(28), see section Operations of Access Types.
   record extension    section Type Extensions.
   requeue statement    section Requeue Statements.
   type conversion    section Type Conversions(17), see section Type Conversions(17), see section Type Conversions.
Accessibility_Check    section Suppressing Checks.
   [partial]    section Operations of Access Types(29), see section Type Conversions(48), see section Return Statements(29), see section Type Conversions(48), see section Return Statements,
                section Remote Subprogram Calls.
accessible partition    section Partitions.
accuracy    section Type Conversions(32), see section Numeric Performance Requirements(32), see section Numeric Performance Requirements.
ACK    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
acquire
   execution resource associated with protected object
         section Protected Subprograms and Protected Actions.
Activate    section Subprogram Calls.
activation
   of a task    section Task Execution - Task Activation.
activation failure    section Task Execution - Task Activation.
activator
   of a task    section Task Execution - Task Activation.
active partition    section Program Execution(28), see section Partitions(28), see section Partitions.
active priority    section Task Priorities.
actual    section Generic Instantiation.
actual duration    section Delay Accuracy.
actual parameter
   for a formal parameter    section Parameter Associations.
actual subtype    section Objects and Named Numbers(23), see section Formal Types(23), see section Formal Types.
   of an object    section Object Declarations.
actual type    section Formal Types.
actual_parameter_part    section Subprogram Calls.
   used    section Subprogram Calls(2), see section Subprogram Calls(3), see section Entry Calls(2), see section Syntax Summary (informative)(2), see section Subprogram Calls(3), see section Entry Calls(2), see section Syntax Summary (informative).
Acute    section The Package Characters.Latin_1.
Ada    section The Package Ada.
Ada calling convention    section Conformance Rules.
Ada.Asynchronous_Task_Control    section Asynchronous Task Control.
Ada.Calendar    section Delay Statements, Duration, and Time.
Ada.Characters    section The Package Characters.
Ada.Characters.Handling    section The Package Characters.Handling.
Ada.Characters.Latin_1    section The Package Characters.Latin_1.
Ada.Command_Line    section The Package Command_Line.
Ada.Decimal    section The Package Decimal.
Ada.Direct_IO    section The Generic Package Direct_IO.
Ada.Dynamic_Priorities    section Dynamic Priorities.
Ada.Exceptions    section The Package Exceptions.
Ada.Finalization    section User-Defined Assignment and Finalization.
Ada.Float_Text_IO    section Input-Output for Real Types.
Ada.Float_Wide_Text_IO    section Wide Text Input-Output.
Ada.Integer_Text_IO    section Input-Output for Integer Types.
Ada.Integer_Wide_Text_IO    section Wide Text Input-Output.
Ada.Interrupts    section The Package Interrupts.
Ada.Interrupts.Names    section The Package Interrupts.
Ada.Numerics    section The Numerics Packages.
Ada.Numerics.Complex_Elementary_Functions    section Complex Elementary Functions.
Ada.Numerics.Complex_Types    section Complex Types.
Ada.Numerics.Discrete_Random    section Random Number Generation.
Ada.Numerics.Elementary_Functions    section Elementary Functions.
Ada.Numerics.Float_Random    section Random Number Generation.
Ada.Numerics.Generic_Complex_Elementary_Functions    section Complex Elementary Functions.
Ada.Numerics.Generic_Complex_Types    section Complex Types.
Ada.Numerics.Generic_Elementary_Functions    section Elementary Functions.
Ada.Real_Time    section Monotonic Time.
Ada.Sequential_IO    section The Generic Package Sequential_IO.
Ada.Storage_IO    section The Generic Package Storage_IO.
Ada.Streams    section The Package Streams.
Ada.Streams.Stream_IO    section The Package Streams.Stream_IO.
Ada.Strings    section The Package Strings.
Ada.Strings.Bounded    section Bounded-Length String Handling.
Ada.Strings.Fixed    section Fixed-Length String Handling.
Ada.Strings.Maps    section The Package Strings.Maps.
Ada.Strings.Maps.Constants    section String-Handling Sets and Mappings.
Ada.Strings.Unbounded    section Unbounded-Length String Handling.
Ada.Strings.Wide_Bounded    section Wide_String Handling.
Ada.Strings.Wide_Fixed    section Wide_String Handling.
Ada.Strings.Wide_Maps    section Wide_String Handling.
Ada.Strings.Wide_Maps.Wide_Constants    section Wide_String Handling.
Ada.Strings.Wide_Unbounded    section Wide_String Handling.
Ada.Synchronous_Task_Control    section Synchronous Task Control.
Ada.Tags    section Tagged Types and Type Extensions.
Ada.Task_Attributes    section The Package Task_Attributes.
Ada.Task_Identification    section The Package Task_Identification.
Ada.Text_IO    section The Package Text_IO.
Ada.Text_IO.Complex_IO    section Complex Input-Output.
Ada.Text_IO.Editing    section The Package Text_IO.Editing.
Ada.Text_IO.Text_Streams    section The Package Text_IO.Text_Streams.
Ada.Unchecked_Conversion    section Unchecked Type Conversions.
Ada.Unchecked_Deallocation    section Unchecked Storage Deallocation.
Ada.Wide_Text_IO    section Wide Text Input-Output.
Ada.Wide_Text_IO.Complex_IO    section The Package Wide_Text_IO.Complex_IO.
Ada.Wide_Text_IO.Editing    section The Package Wide_Text_IO.Editing.
Ada.Wide_Text_IO.Text_Streams    section The Package Wide_Text_IO.Text_Streams.
Ada.IO_Exceptions    section Exceptions in Input-Output.
Ada_Application    section Interfacing with Fortran.
Ada_Employee_Record_Type    section Interfacing with COBOL.
Addition    section Type Extensions.
Address    section The Package System.
   arithmetic    section The Package System.Storage_Elements.
   comparison    section The Package System.
   null    section The Package System.
Address attribute    section Representation Attributes(11), see section Interrupt Entries(5), see section Language-Defined Attributes (informative)(11), see section Interrupt Entries(5), see section Language-Defined Attributes (informative).
Address clause    section Representation Attributes(7), see section Representation Attributes(7), see section Representation Attributes.
Address_To_Access_Conversions
   child of System    section The Package System.Address_To_Access_Conversions.
Adjacent attribute    section Attributes of Floating Point Types(48), see section Language-Defined Attributes (informative)(48), see section Language-Defined Attributes (informative).
Adjust    section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization.
adjusting the value of an object    section User-Defined Assignment and Finalization(15), see section User-Defined Assignment and Finalization(15), see section User-Defined Assignment and Finalization.
adjustment    section User-Defined Assignment and Finalization(15), see section User-Defined Assignment and Finalization(15), see section User-Defined Assignment and Finalization.
   as part of assignment    section Assignment Statements.
Adjustments_Conversions    section Interfacing with COBOL.
Adjustments_Type    section Interfacing with COBOL.
ADT (abstract data type)
   See also abstract type    section Abstract Types and Subprograms.
   See private types and private extensions    section Private Types and Private Extensions.
advice    section Structure.
Aft attribute    section Operations of Fixed Point Types(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
aggregate    section Aggregates(1), see section Aggregates(1), see section Aggregates.
   used    section Expressions(7), see section Qualified Expressions(2), see section Syntax Summary (informative)(7), see section Qualified Expressions(2), see section Syntax Summary (informative).
   See also composite type    section Types and Subtypes.
aliased    section Access Types(9), see section Glossary (informative)(9), see section Glossary (informative).
aliasing
   See distinct access paths    section Formal Parameter Modes.
Alignment    section The Package Strings.
Alignment attribute    section Representation Attributes(23), see section Language-Defined Attributes (informative)(23), see section Language-Defined Attributes (informative).
Alignment clause    section Representation Attributes(7), see section Representation Attributes(7), see section Representation Attributes.
All_Calls_Remote pragma    section Remote Call Interface Library Units(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
All_Checks    section Suppressing Checks.
Allocate    section Storage Management.
allocator    section Allocators.
   used    section Expressions(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
Alphanumeric    section Interfacing with COBOL.
alphanumeric character
   a category of Character    section The Package Characters.Handling.
Alphanumeric_Set    section String-Handling Sets and Mappings.
ambiguous    section The Context of Overload Resolution.
ampersand section Character Set(15), see section The Package Characters.Latin_1(8)
ampersand operator    section Expressions(1), see section Binary Adding Operators(1), see section Binary Adding Operators.
ancestor
   of a library unit    section Compilation Units - Library Units.
   of a type    section Derivation Classes.
   ultimate    section Derivation Classes.
ancestor subtype
   of a private_extension_declaration    section Private Types and Private Extensions.
   of a formal derived type    section Formal Private and Derived Types.
ancestor_part    section Extension Aggregates.
   used    section Extension Aggregates(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
and operator    section Expressions(1), see section Logical Operators and Short-circuit Control Forms(1), see section Logical Operators and Short-circuit Control Forms.
and then (short-circuit control form)    section Expressions,
                                         section Logical Operators and Short-circuit Control Forms.
Angle    section Formal Types.
angle threshold    section Accuracy Requirements for the Elementary Functions.
Annex
   informative    section Structure.
   normative    section Structure.
   Specialized Needs    section Structure.
anonymous access type    section Access Types.
anonymous array type    section Object Declarations.
anonymous protected type    section Object Declarations.
anonymous task type    section Object Declarations.
anonymous type    section Type Declarations.
Any_Priority    section The Package System(16), see section Task Priorities(16), see section Task Priorities.
APC    section The Package Characters.Latin_1.
apostrophe    section Character Set(15), see section The Package Characters.Latin_1(15), see section The Package Characters.Latin_1.
Append    section Bounded-Length String Handling(13), see section Bounded-Length String Handling(14), see section Bounded-Length String Handling(13), see section Bounded-Length String Handling(14), see section Bounded-Length String Handling,
          section Bounded-Length String Handling(16), see section Bounded-Length String Handling(17), see section Bounded-Length String Handling(16), see section Bounded-Length String Handling(17), see section Bounded-Length String Handling,
          section Bounded-Length String Handling(19), see section Bounded-Length String Handling(20), see section Unbounded-Length String Handling(19), see section Bounded-Length String Handling(20), see section Unbounded-Length String Handling,
          section Unbounded-Length String Handling(13), see section Unbounded-Length String Handling(13), see section Unbounded-Length String Handling.
applicable index constraint    section Array Aggregates.
application areas    section Structure.
apply
   to a loop_statement by an exit_statement    section Exit Statements.
   to a callable construct by a return_statement    section Return Statements.
   to a program unit by a program unit pragma    section Pragmas and Program Units.
arbitrary order    section Method of Description and Syntax Notation.
Arccos    section Elementary Functions(6), see section Complex Elementary Functions(6), see section Complex Elementary Functions.
Arccosh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Arccot    section Elementary Functions(6), see section Complex Elementary Functions(6), see section Complex Elementary Functions.
Arccoth    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Arcsin section Elementary Functions(6), see section Complex Elementary Functions(5)
Arcsinh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Arctan    section Elementary Functions(6), see section Complex Elementary Functions(6), see section Complex Elementary Functions.
Arctanh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Argument    section The Package Command_Line(5), see section Complex Types(5), see section Complex Types.
argument of a pragma    section Pragmas.
Argument_Count    section The Package Command_Line.
Argument_Error    section The Numerics Packages.
array    section Array Types.
array component expression    section Array Aggregates.
array indexing
   See indexed_component    section Indexed Components.
array slice    section Slices.
array type    section Array Types(1), see section Glossary (informative)(1), see section Glossary (informative).
array_aggregate    section Array Aggregates.
   used    section Aggregates(2), see section Enumeration Representation Clauses(3), see section Syntax Summary (informative)(2), see section Enumeration Representation Clauses(3), see section Syntax Summary (informative).
array_component_association    section Array Aggregates.
   used    section Array Aggregates(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
array_type_definition    section Array Types.
   used    section Type Declarations(4), see section Object Declarations(2), see section Formal Array Types(4), see section Object Declarations(2), see section Formal Array Types,
           section Syntax Summary (informative).
ASCII    section The Package Standard(36), see section ASCII(36), see section ASCII.
   package physically nested within the declaration of Standard
         section The Package Standard.
aspect of representation    section Representation Items.
   coding    section Enumeration Representation Clauses.
   controlled    section Pragma Controlled.
   convention, calling convention    section Interfacing Pragmas.
   exported    section Interfacing Pragmas.
   imported    section Interfacing Pragmas.
   layout    section Record Layout.
   packing    section Pragma Pack.
   record layout    section Record Layout.
   specifiable attributes    section Representation Attributes.
   storage place    section Record Layout.
assembly language    section Access to Machine Operations.
assign
   See assignment operation    section Assignment Statements.
assigning back of parameters    section Parameter Associations.
assignment
   user-defined    section User-Defined Assignment and Finalization.
assignment operation    section Assignment Statements(3), see section Assignment Statements(12), see section User-Defined Assignment and Finalization(3), see section Assignment Statements(12), see section User-Defined Assignment and Finalization.
   during elaboration of an object_declaration    section Object Declarations.
   during evaluation of a generic_association for a formal object
     of mode in section Formal Objects(11)
   during evaluation of a parameter_association    section Parameter Associations.
   during evaluation of an aggregate    section Aggregates.
   during evaluation of an initialized allocator    section Allocators.
   during evaluation of an uninitialized allocator    section Allocators,
         section Allocators.
   during evaluation of concatenation    section Binary Adding Operators.
   during execution of a for loop    section Loop Statements.
   during execution of a return_statement    section Return Statements.
   during execution of an assignment_statement    section Assignment Statements.
   during parameter copy back    section Parameter Associations.
assignment_statement    section Assignment Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
associated components
   of a record_component_association    section Record Aggregates.
associated discriminants
   of a named discriminant_association    section Discriminant Constraints.
   of a positional discriminant_association    section Discriminant Constraints.
associated object
   of a value of a by-reference type    section Formal Parameter Modes.
asterisk    section Character Set(15), see section The Package Characters.Latin_1(15), see section The Package Characters.Latin_1.
asynchronous
   remote procedure call    section Pragma Asynchronous.
Asynchronous pragma    section Pragma Asynchronous(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
asynchronous remote procedure call    section Remote Subprogram Calls.
asynchronous_select    section Asynchronous Transfer of Control.
   used    section Select Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Asynchronous_Task_Control
   child of Ada    section Asynchronous Task Control.
at-most-once execution    section Remote Subprogram Calls.
at_clause    section At Clauses.
   used    section Representation Items(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
atomic    section Shared Variable Control.
Atomic pragma    section Shared Variable Control(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Atomic_Components pragma    section Shared Variable Control(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
Attach_Handler    section The Package Interrupts.
Attach_Handler pragma    section Protected Procedure Handlers, L(6)
attaching
   to an interrupt    section Interrupt Support.
attribute    section Attributes(1), see section The Package Task_Attributes(2), see section Language-Defined Attributes (informative)(1), see section The Package Task_Attributes(2), see section Language-Defined Attributes (informative).
   representation    section Representation Attributes.
   specifiable    section Representation Attributes.
   specifying    section Representation Attributes.
attribute_definition_clause    section Representation Attributes.
   used    section Representation Items(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
attribute_designator    section Attributes.
   used    section Attributes(2), see section Representation Items(3), see section Representation Attributes(2), see section Representation Items(3), see section Representation Attributes,
           section Syntax Summary (informative).
Attribute_Handle    section The Package Task_Attributes.
attribute_reference    section Attributes.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
attributes
   Access    section Operations of Access Types(24), see section Operations of Access Types(32), see section Language-Defined Attributes (informative)(24), see section Operations of Access Types(32), see section Language-Defined Attributes (informative),
             section Language-Defined Attributes (informative).
   Address    section Representation Attributes(11), see section Interrupt Entries(5), see section Language-Defined Attributes (informative)(11), see section Interrupt Entries(5), see section Language-Defined Attributes (informative).
   Adjacent    section Attributes of Floating Point Types(48), see section Language-Defined Attributes (informative)(48), see section Language-Defined Attributes (informative).
   Aft    section Operations of Fixed Point Types(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
   Alignment    section Representation Attributes(23), see section Language-Defined Attributes (informative)(23), see section Language-Defined Attributes (informative).
   Base    section Scalar Types(15), see section Language-Defined Attributes (informative)(15), see section Language-Defined Attributes (informative).
   Bit_Order    section Bit Ordering(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
   Body_Version    section Consistency of a Distributed System(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
   Callable    section Task and Entry Attributes(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
   Caller    section The Package Task_Identification(14), see section Language-Defined Attributes (informative)(14), see section Language-Defined Attributes (informative).
   Ceiling    section Attributes of Floating Point Types(33), see section Language-Defined Attributes (informative)(33), see section Language-Defined Attributes (informative).
   Class    section Tagged Types and Type Extensions(14), see section Private Operations(9), see section Language-Defined Attributes (informative)(14), see section Private Operations(9), see section Language-Defined Attributes (informative),
            section Language-Defined Attributes (informative).
   Component_Size    section Representation Attributes(69), see section Language-Defined Attributes (informative)(69), see section Language-Defined Attributes (informative).
   Compose    section Attributes of Floating Point Types(24), see section Language-Defined Attributes (informative)(24), see section Language-Defined Attributes (informative).
   Constrained    section Operations of Discriminated Types(3), see section The Constrained Attribute(2), see section Language-Defined Attributes (informative)(3), see section The Constrained Attribute(2), see section Language-Defined Attributes (informative).
   Copy_Sign    section Attributes of Floating Point Types(51), see section Language-Defined Attributes (informative)(51), see section Language-Defined Attributes (informative).
   Count    section Task and Entry Attributes(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
   Definite    section Formal Private and Derived Types(23), see section Language-Defined Attributes (informative)(23), see section Language-Defined Attributes (informative).
   Delta    section Operations of Fixed Point Types(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
   Denorm    section Attributes of Floating Point Types(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
   Digits    section Operations of Floating Point Types(2), see section Operations of Fixed Point Types(7), see section Language-Defined Attributes (informative)(2), see section Operations of Fixed Point Types(7), see section Language-Defined Attributes (informative),
             section Language-Defined Attributes (informative).
   Exponent    section Attributes of Floating Point Types(18), see section Language-Defined Attributes (informative)(18), see section Language-Defined Attributes (informative).
   External_Tag    section Representation Attributes(75), see section Language-Defined Attributes (informative)(75), see section Language-Defined Attributes (informative).
   First    section Scalar Types(12), see section Operations of Array Types(3), see section Language-Defined Attributes (informative)(12), see section Operations of Array Types(3), see section Language-Defined Attributes (informative),
            section Language-Defined Attributes (informative).
   First(N)    section Operations of Array Types(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
   First_Bit    section Storage Place Attributes(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
   Floor    section Attributes of Floating Point Types(30), see section Language-Defined Attributes (informative)(30), see section Language-Defined Attributes (informative).
   Fore    section Operations of Fixed Point Types(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
   Fraction    section Attributes of Floating Point Types(21), see section Language-Defined Attributes (informative)(21), see section Language-Defined Attributes (informative).
   Identity    section The Package Exceptions(9), see section The Package Task_Identification(12), see section Language-Defined Attributes (informative)(9), see section The Package Task_Identification(12), see section Language-Defined Attributes (informative),
               section Language-Defined Attributes (informative).
   Image    section Scalar Types(35), see section Language-Defined Attributes (informative)(35), see section Language-Defined Attributes (informative).
   Input    section Stream-Oriented Attributes(22), see section Stream-Oriented Attributes(32), see section Language-Defined Attributes (informative)(22), see section Stream-Oriented Attributes(32), see section Language-Defined Attributes (informative),
            section Language-Defined Attributes (informative).
   Last    section Scalar Types(13), see section Operations of Array Types(5), see section Language-Defined Attributes (informative)(13), see section Operations of Array Types(5), see section Language-Defined Attributes (informative),
           section Language-Defined Attributes (informative).
   Last(N)    section Operations of Array Types(6), see section Language-Defined Attributes (informative)(6), see section Language-Defined Attributes (informative).
   Last_Bit    section Storage Place Attributes(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
   Leading_Part    section Attributes of Floating Point Types(54), see section Language-Defined Attributes (informative)(54), see section Language-Defined Attributes (informative).
   Length    section Operations of Array Types(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
   Length(N)    section Operations of Array Types(10), see section Language-Defined Attributes (informative)(10), see section Language-Defined Attributes (informative).
   Machine    section Attributes of Floating Point Types(60), see section Language-Defined Attributes (informative)(60), see section Language-Defined Attributes (informative).
   Machine_Emax    section Attributes of Floating Point Types(8), see section Language-Defined Attributes (informative)(8), see section Language-Defined Attributes (informative).
   Machine_Emin section Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative)(125)
   Machine_Mantissa    section Attributes of Floating Point Types(6), see section Language-Defined Attributes (informative)(6), see section Language-Defined Attributes (informative).
   Machine_Overflows    section Attributes of Floating Point Types(12), see section Attributes of Fixed Point Types(12), see section Attributes of Fixed Point Types,
                        section Language-Defined Attributes (informative)(129),     section Language-Defined Attributes (informative)(129),     section Language-Defined Attributes (informative).
   Machine_Radix    section Attributes of Floating Point Types(2), see section Attributes of Fixed Point Types(2), see section Language-Defined Attributes (informative)(2), see section Attributes of Fixed Point Types(2), see section Language-Defined Attributes (informative),
                    section Language-Defined Attributes (informative).
   Machine_Rounds    section Attributes of Floating Point Types(11), see section Attributes of Fixed Point Types(11), see section Attributes of Fixed Point Types,
                     section Language-Defined Attributes (informative)(137),     section Language-Defined Attributes (informative)(137),     section Language-Defined Attributes (informative).
   Max    section Scalar Types(19), see section Language-Defined Attributes (informative)(19), see section Language-Defined Attributes (informative).
   Max_Size_In_Storage_Elements    section The Max_Size_In_Storage_Elements Attribute(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
   Min section Scalar Types(16), see section Language-Defined Attributes (informative)(147)
   Model    section Attributes of Floating Point Types(68), see section Model-Oriented Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative)(68), see section Model-Oriented Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative).
   Model_Emin section Attributes of Floating Point Types(65), see section Model-Oriented Attributes of Floating Point Types(4), see section Language-Defined Attributes (informative)(155)
   Model_Epsilon    section Attributes of Floating Point Types(66), see section Language-Defined Attributes (informative)(66), see section Language-Defined Attributes (informative).
   Model_Mantissa    section Attributes of Floating Point Types(64), see section Model-Oriented Attributes of Floating Point Types(3), see section Language-Defined Attributes (informative)(64), see section Model-Oriented Attributes of Floating Point Types(3), see section Language-Defined Attributes (informative).
   Model_Small    section Attributes of Floating Point Types(67), see section Language-Defined Attributes (informative)(67), see section Language-Defined Attributes (informative).
   Modulus    section Integer Types(17), see section Language-Defined Attributes (informative)(17), see section Language-Defined Attributes (informative).
   Output    section Stream-Oriented Attributes(19), see section Stream-Oriented Attributes(29), see section Language-Defined Attributes (informative)(19), see section Stream-Oriented Attributes(29), see section Language-Defined Attributes (informative),
             section Language-Defined Attributes (informative).
   Partition_ID    section Partitions(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
   Pos    section Operations of Discrete Types(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
   Position    section Storage Place Attributes(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
   Pred    section Scalar Types(25), see section Language-Defined Attributes (informative)(25), see section Language-Defined Attributes (informative).
   Range    section Scalar Types(14), see section Operations of Array Types(7), see section Language-Defined Attributes (informative)(14), see section Operations of Array Types(7), see section Language-Defined Attributes (informative),
            section Language-Defined Attributes (informative).
   Range(N)    section Operations of Array Types(8), see section Language-Defined Attributes (informative)(8), see section Language-Defined Attributes (informative).
   Read    section Stream-Oriented Attributes(6), see section Stream-Oriented Attributes(14), see section Language-Defined Attributes (informative)(6), see section Stream-Oriented Attributes(14), see section Language-Defined Attributes (informative),
           section Language-Defined Attributes (informative).
   Remainder    section Attributes of Floating Point Types(45), see section Language-Defined Attributes (informative)(45), see section Language-Defined Attributes (informative).
   Round    section Operations of Fixed Point Types(12), see section Language-Defined Attributes (informative)(12), see section Language-Defined Attributes (informative).
   Rounding    section Attributes of Floating Point Types(36), see section Language-Defined Attributes (informative)(36), see section Language-Defined Attributes (informative).
   Safe_First    section Attributes of Floating Point Types(71), see section Model-Oriented Attributes of Floating Point Types(5), see section Language-Defined Attributes (informative)(71), see section Model-Oriented Attributes of Floating Point Types(5), see section Language-Defined Attributes (informative).
   Safe_Last    section Attributes of Floating Point Types(72), see section Model-Oriented Attributes of Floating Point Types(6), see section Language-Defined Attributes (informative)(72), see section Model-Oriented Attributes of Floating Point Types(6), see section Language-Defined Attributes (informative).
   Scale    section Operations of Fixed Point Types(11), see section Language-Defined Attributes (informative)(11), see section Language-Defined Attributes (informative).
   Scaling    section Attributes of Floating Point Types(27), see section Language-Defined Attributes (informative)(27), see section Language-Defined Attributes (informative).
   Signed_Zeros    section Attributes of Floating Point Types(13), see section Language-Defined Attributes (informative)(13), see section Language-Defined Attributes (informative).
   Size    section Representation Attributes(40), see section Representation Attributes(45), see section Language-Defined Attributes (informative)(40), see section Representation Attributes(45), see section Language-Defined Attributes (informative),
           section Language-Defined Attributes (informative).
   Small    section Operations of Fixed Point Types(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
   Storage_Pool    section Storage Management(13), see section Language-Defined Attributes (informative)(13), see section Language-Defined Attributes (informative).
   Storage_Size    section Representation Attributes(60), see section Storage Management(14), see section The Storage_Size Attribute(60), see section Storage Management(14), see section The Storage_Size Attribute,
                   section Language-Defined Attributes (informative)(234), see section Language-Defined Attributes (informative)(234), see section Language-Defined Attributes (informative).
   Succ    section Scalar Types(22), see section Language-Defined Attributes (informative)(22), see section Language-Defined Attributes (informative).
   Tag    section Tagged Types and Type Extensions(16), see section Tagged Types and Type Extensions(18), see section Language-Defined Attributes (informative)(16), see section Tagged Types and Type Extensions(18), see section Language-Defined Attributes (informative),
          section Language-Defined Attributes (informative).
   Terminated    section Task and Entry Attributes(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
   Truncation    section Attributes of Floating Point Types(42), see section Language-Defined Attributes (informative)(42), see section Language-Defined Attributes (informative).
   Unbiased_Rounding    section Attributes of Floating Point Types(39), see section Language-Defined Attributes (informative)(39), see section Language-Defined Attributes (informative).
   Unchecked_Access    section Unchecked Access Value Creation(3), see section Safety and Security Restrictions(18), see section Language-Defined Attributes (informative)(3), see section Safety and Security Restrictions(18), see section Language-Defined Attributes (informative).
   Val    section Operations of Discrete Types(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
   Valid    section The Valid Attribute(3), see section Safety and Security (normative)(6), see section Language-Defined Attributes (informative)(3), see section Safety and Security (normative)(6), see section Language-Defined Attributes (informative).
   Value    section Scalar Types(52), see section Language-Defined Attributes (informative)(52), see section Language-Defined Attributes (informative).
   Version    section Consistency of a Distributed System(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
   Wide_Image    section Scalar Types(28), see section Language-Defined Attributes (informative)(28), see section Language-Defined Attributes (informative).
   Wide_Value    section Scalar Types(40), see section Language-Defined Attributes (informative)(40), see section Language-Defined Attributes (informative).
   Wide_Width    section Scalar Types(38), see section Language-Defined Attributes (informative)(38), see section Language-Defined Attributes (informative).
   Width    section Scalar Types(39), see section Language-Defined Attributes (informative)(39), see section Language-Defined Attributes (informative).
   Write    section Stream-Oriented Attributes(3), see section Stream-Oriented Attributes(11), see section Language-Defined Attributes (informative)(3), see section Stream-Oriented Attributes(11), see section Language-Defined Attributes (informative),
            section Language-Defined Attributes (informative).

index

Backus-Naur Form (BNF)
   complete listing    section Syntax Summary (informative).
   cross reference    section Syntax Summary (informative).
   notation    section Method of Description and Syntax Notation.
   under Syntax heading    section Structure.
base    section Based Literals(3), see section Based Literals(3), see section Based Literals.
base 16 literal    section Based Literals.
   used    section Based Literals(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
base 2 literal    section Based Literals.
base 8 literal    section Based Literals.
Base attribute    section Scalar Types(15), see section Language-Defined Attributes (informative)(15), see section Language-Defined Attributes (informative).
base decimal precision
   of a floating point type    section Floating Point Types(9), see section Floating Point Types(9), see section Floating Point Types.
base priority    section Task Priorities.
base range
   of a decimal fixed point type    section Fixed Point Types.
   of a fixed point type    section Fixed Point Types.
   of a floating point type    section Floating Point Types(8), see section Floating Point Types(8), see section Floating Point Types.
   of a modular type    section Integer Types.
   of a scalar type    section Scalar Types.
   of a signed integer type    section Integer Types.
   of an ordinary fixed point type    section Fixed Point Types.
base subtype
   of a type    section Scalar Types.
based_literal    section Based Literals.
   used    section Numeric Literals(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
based_numeral    section Based Literals.
   used    section Based Literals(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
basic letter
   a category of Character    section The Package Characters.Handling.
basic_declaration    section Declarations.
   used    section Declarative Parts(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
basic_declarative_item    section Declarative Parts.
   used    section Declarative Parts(3), see section Package Specifications and Declarations(3), see section Syntax Summary (informative)(3), see section Package Specifications and Declarations(3), see section Syntax Summary (informative).
Basic_Map    section String-Handling Sets and Mappings.
Basic_Set    section String-Handling Sets and Mappings.
become nonlimited    section Private Operations(5), see section Limited Types(5), see section Limited Types.
BEL    section The Package Characters.Latin_1.
belong
   to a range    section Scalar Types.
   to a subtype    section Types and Subtypes.
Bias    section Generic Bodies.
bibliography    section Normative References.
big endian    section Bit Ordering.
binary    section Interfacing with COBOL.
   literal    section Based Literals.
binary adding operator    section Binary Adding Operators.
binary literal    section Based Literals.
binary operator    section Operators and Expression Evaluation.
binary_adding_operator    section Operators and Expression Evaluation.
   used    section Expressions(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Binary_Format    section Interfacing with COBOL.
Binary_Operation    section Type Extensions.
Binop_Ptr    section Access Types.
bit field
   See record_representation_clause    section Record Representation Clauses.
bit ordering    section Bit Ordering.
bit string
   See logical operators on boolean arrays    section Logical Operators and Short-circuit Control Forms.
Bit_Order    section The Package System.
Bit_Order attribute    section Bit Ordering(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
Bit_Order clause    section Representation Attributes(7), see section Bit Ordering(7), see section Bit Ordering.
Bit_Vector    section Array Types.
blank
   in text input for enumeration and numeric types   section Get and Put Procedures.
block_statement    section Block Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
blocked
   [partial]    section The Task Dispatching Model.
   a task state    section Tasks and Synchronization.
   during an entry call    section Entry Calls.
   execution of a selective_accept    section Selective Accept.
   on a delay_statement    section Delay Statements, Duration, and Time.
   on an accept_statement    section Entries and Accept Statements.
   waiting for activations to complete    section Task Execution - Task Activation.
   waiting for dependents to terminate    section Task Dependence - Termination of Tasks.
blocked interrupt    section Interrupt Support.
blocking, potentially   .see section Protected Subprograms and Protected Actions(8)
   Abort_Task    section The Package Task_Identification.
   delay_statement    section Delay Statements, Duration, and Time(34), see section Delay Accuracy(34), see section Delay Accuracy.
   remote subprogram call    section Remote Subprogram Calls.
   RPC operations    section Partition Communication Subsystem.
   Suspend_Until_True    section Synchronous Task Control.
BMP    section Character Types(2), see section Character Types(2), see section Character Types.
BNF (Backus-Naur Form)
   complete listing    section Syntax Summary (informative).
   cross reference    section Syntax Summary (informative).
   notation    section Method of Description and Syntax Notation.
   under Syntax heading    section Structure.
body    section Declarative Parts.
   used    section Declarative Parts(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
body_stub    section Subunits of Compilation Units.
   used    section Declarative Parts(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
Body_Version attribute    section Consistency of a Distributed System(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
Boolean    section Boolean Types(1), see section The Package Standard(1), see section The Package Standard.
boolean type    section Boolean Types.
Bounded
   child of Ada.Strings    section Bounded-Length String Handling.
bounded error    section Structure(31),    section Classification of Errors(8),   section Formal Parameter Modes(31),    section Classification of Errors(8),   section Formal Parameter Modes,
                 section Completion and Finalization(14),    section Protected Subprograms and Protected Actions(8),   section Abort of a Task - Abort of a Sequence of Statements(14),    section Protected Subprograms and Protected Actions(8),   section Abort of a Task - Abort of a Sequence of Statements,
                 section Program Execution(26),     section Data Validity(26),     section Data Validity,
                 section Unchecked Storage Deallocation(11), see section The Package Task_Identification(17), see section Dynamic Priorities(11), see section The Package Task_Identification(17), see section Dynamic Priorities,
                 section Partitions(10),      section Consistency of a Distributed System(6),     section Interrupt Entries(10),      section Consistency of a Distributed System(6),     section Interrupt Entries.
Bounded_String    section Bounded-Length String Handling.
bounds
   of a discrete_range    section Index Constraints and Discrete Ranges.
   of an array    section Array Types.
   of the index range of an array_aggregate    section Array Aggregates.
box
   compound delimiter    section Array Types.
broadcast signal
   See protected object    section Protected Units and Protected Objects.
   See requeue    section Requeue Statements.
Broken_Bar    section The Package Characters.Latin_1.
BS    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
Buffer    section Discriminants(33), see section Example of Tasking and Synchronization(8), see section Example of Tasking and Synchronization(33), see section Example of Tasking and Synchronization(8), see section Example of Tasking and Synchronization,
          section Formal Types.
Buffer_Size    section Integer Types(35), see section The Generic Package Storage_IO(35), see section The Generic Package Storage_IO.
Buffer_Type    section The Generic Package Storage_IO.
by copy parameter passing    section Formal Parameter Modes.
by reference parameter passing    section Formal Parameter Modes.
by-copy type    section Formal Parameter Modes.
by-reference type    section Formal Parameter Modes.
   atomic or volatile    section Shared Variable Control.
Byte    section Integer Types(36), see section Representation Attributes(80), see section Interfacing with COBOL(36), see section Representation Attributes(80), see section Interfacing with COBOL.
   See storage element    section Representation Attributes.
byte sex
   See ordering of storage elements in a word    section Bit Ordering.
Byte_Array    section Interfacing with COBOL.
Byte_Mask    section Record Representation Clauses.

index

C    section Array Aggregates(42), see section Interfacing with C(77), see section The Generic Package Interfaces.C.Pointers(42), see section Interfacing with C(77), see section The Generic Package Interfaces.C.Pointers.
   child of Interfaces    section Interfacing with C.
C interface    section Interfacing with C.
C standard    section Normative References.
C_float    section Interfacing with C.
Calendar    section Renamings of Ada 83 Library Units.
   child of Ada    section Delay Statements, Duration, and Time.
call    section Subprograms.
call on a dispatching operation    section Dispatching Operations of Tagged Types.
callable    section Task and Entry Attributes.
Callable attribute    section Task and Entry Attributes(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
callable construct    section Subprograms.
callable entity    section Subprograms.
called partition    section Remote Subprogram Calls.
Caller attribute    section The Package Task_Identification(14), see section Language-Defined Attributes (informative)(14), see section Language-Defined Attributes (informative).
calling convention    section Conformance Rules(2), see section Interfacing Pragmas(2), see section Interfacing Pragmas.
   Ada    section Conformance Rules.
   associated with a designated profile    section Access Types.
   entry    section Conformance Rules.
   Intrinsic    section Conformance Rules.
   protected    section Conformance Rules.
calling partition    section Remote Subprogram Calls.
calling stub    section Remote Subprogram Calls.
CAN    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
cancellation
   of a delay_statement    section Delay Statements, Duration, and Time.
   of an entry call    section Entry Calls.
cancellation of a remote subprogram call    section Remote Subprogram Calls.
canonical form    section Attributes of Floating Point Types.
canonical semantics    section Exceptions and Optimization.
canonical-form representation    section Attributes of Floating Point Types.
Car    section Incomplete Type Declarations(19), see section Incomplete Type Declarations(21), see section Formal Access Types(19), see section Incomplete Type Declarations(21), see section Formal Access Types,
      section Formal Access Types.
Car_Name    section Incomplete Type Declarations(20), see section Formal Access Types(20), see section Formal Access Types.
case insensitive    section Identifiers.
case_statement    section Case Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
case_statement_alternative    section Case Statements.
   used    section Case Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
cast
   See type conversion    section Type Conversions.
   See unchecked type conversion    section Unchecked Type Conversions.
catch (an exception)
   See handle    section Exceptions.
categorization pragma    section Categorization of Library Units.
   Remote_Call_Interface    section Remote Call Interface Library Units.
   Remote_Types    section Remote Types Library Units.
   Shared_Passive    section Shared Passive Library Units.
categorized library unit    section Categorization of Library Units.
catenation operator
   See concatenation operator    section Expressions(1), see section Binary Adding Operators(1), see section Binary Adding Operators.
CCH    section The Package Characters.Latin_1.
Cedilla    section The Package Characters.Latin_1.
Ceiling attribute    section Attributes of Floating Point Types(33), see section Language-Defined Attributes (informative)(33), see section Language-Defined Attributes (informative).
ceiling priority
   of a protected object    section Priority Ceiling Locking.
Ceiling_Check
   [partial]    section Protected Procedure Handlers(11), see section Priority Ceiling Locking(11), see section Priority Ceiling Locking.
Cell    section Incomplete Type Declarations(15), see section Incomplete Type Declarations(15), see section Incomplete Type Declarations.
Cent_Sign    section The Package Characters.Latin_1.
change of representation    section Change of Representation.
char    section Interfacing with C.
char_array    section Interfacing with C.
CHAR_BIT    section Interfacing with C.
Char_Ptrs    section The Generic Package Interfaces.C.Pointers.
Char_Star    section The Generic Package Interfaces.C.Pointers.
Char_IO    section Input-Output for Enumeration Types.
character    section Character Set(2), see section Character Types(2), see section The Package Standard(2), see section Character Types(2), see section The Package Standard.
   used    section Comments(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
character set    section Character Set.
character set standard
   16-bit    section Normative References.
   7-bit     section Normative References.
   8-bit     section Normative References.
   control functions    section Normative References.
character type    section Character Types(1), see section Glossary (informative)(1), see section Glossary (informative).
character_literal    section Character Literals.
   used    section Enumeration Types(4), see section Names(2), see section Selected Components(4), see section Names(2), see section Selected Components,
           section Syntax Summary (informative).
Character_Mapping    section The Package Strings.Maps.
Character_Mapping_Function    section The Package Strings.Maps.
Character_Range    section The Package Strings.Maps.
Character_Ranges    section The Package Strings.Maps.
Character_Sequence    section The Package Strings.Maps.
Character_Set    section The Package Strings.Maps(4), see section Wide_String Handling(46), see section Interfacing with Fortran(4), see section Wide_String Handling(46), see section Interfacing with Fortran.
characteristics    section Private Types and Private Extensions.
Characters
   child of Ada    section The Package Characters.
chars_ptr    section The Package Interfaces.C.Strings.
check
   language-defined    section Suppressing Checks(2), see section Exceptions and Optimization(2), see section Exceptions and Optimization.
check, language-defined
   Access_Check    section Names(13), see section Type Conversions(13), see section Type Conversions.
   Accessibility_Check    section Operations of Access Types(29), see section Type Conversions(29), see section Type Conversions,
         section Return Statements(17), see section Remote Subprogram Calls(17), see section Remote Subprogram Calls.
   Ceiling_Check    section Protected Procedure Handlers(11), see section Priority Ceiling Locking(11), see section Priority Ceiling Locking.
   Discriminant_Check    section Selected Components(15), see section Aggregates(15), see section Aggregates,
                         section Extension Aggregates(8),   section Type Conversions(8),   section Type Conversions,
                         section Type Conversions(45),    section Type Conversions(45),    section Type Conversions,
                         section Type Conversions(52),    section Qualified Expressions(52),    section Qualified Expressions,
                         section Allocators.
   Division_Check    section Integer Types(20), see section Multiplying Operators(20), see section Multiplying Operators,
                     section Elementary Functions(28), see section Attributes of Floating Point Types(28), see section Attributes of Floating Point Types,
                     section Complex Types(40), see section Complex Elementary Functions(40), see section Complex Elementary Functions,
                     section Language-Defined Attributes (informative).
   Elaboration_Check    section Declarative Parts.
   Index_Check    section Indexed Components(7),   section Slices(7), see section Array Aggregates(7),   section Slices(7), see section Array Aggregates,
                  section Array Aggregates(30), see section Binary Adding Operators(8), see section Type Conversions(30), see section Binary Adding Operators(8), see section Type Conversions,
                  section Qualified Expressions(4),     section Allocators(4),     section Allocators.
   Length_Check    section Logical Operators and Short-circuit Control Forms(8), see section Type Conversions(37), see section Type Conversions(8), see section Type Conversions(37), see section Type Conversions.
   Overflow_Check    section Integer Types(20), see section Expressions(20), see section Expressions,
                     section Case Statements(13),    section Model of Floating Point Arithmetic(13),    section Model of Floating Point Arithmetic,
                     section Model-Oriented Attributes of Floating Point Types(7),   section Model of Fixed Point Arithmetic(7),   section Model of Fixed Point Arithmetic,
                     section Accuracy Requirements for the Elementary Functions(2),   section Accuracy Requirements for Complex Arithmetic(2),   section Accuracy Requirements for Complex Arithmetic.
   Partition_Check   E.4(19)
   Range_Check    section Subtype Declarations(11), see section Scalar Types(11), see section Scalar Types,
                  section Scalar Types(27),    section Scalar Types(27),    section Scalar Types,
                  section Scalar Types(44),    section Scalar Types(44),    section Scalar Types,
                  section Scalar Types(55),    section Operations of Discrete Types(55),    section Operations of Discrete Types,
                  section Fixed Point Types(19), see section Literals(19), see section Literals,
                  section Array Aggregates(28), see section Logical Operators and Short-circuit Control Forms(28), see section Logical Operators and Short-circuit Control Forms,
                  section Highest Precedence Operators(6),   section Highest Precedence Operators(6),   section Highest Precedence Operators,
                  section Type Conversions(28),    section Type Conversions(28),    section Type Conversions,
                  section Type Conversions(46),    section Type Conversions(46),    section Type Conversions,
                  section Qualified Expressions(4),     section Stream-Oriented Attributes(4),     section Stream-Oriented Attributes,
                  section Random Number Generation(39), see section Random Number Generation(39), see section Random Number Generation,
                  section Attributes of Floating Point Types(26), see section Attributes of Floating Point Types(26), see section Attributes of Floating Point Types,
                  section Attributes of Floating Point Types(50), see section Attributes of Floating Point Types(50), see section Attributes of Floating Point Types,
                  section Attributes of Floating Point Types(59), see section Attributes of Floating Point Types(59), see section Attributes of Floating Point Types,
                  section Language-Defined Attributes (informative)(11),      section Language-Defined Attributes (informative)(11),      section Language-Defined Attributes (informative),
                  section Language-Defined Attributes (informative)(47),      section Language-Defined Attributes (informative)(47),      section Language-Defined Attributes (informative),
                  section Language-Defined Attributes (informative)(122),     section Language-Defined Attributes (informative)(122),     section Language-Defined Attributes (informative),
                  section Language-Defined Attributes (informative)(220),     section Language-Defined Attributes (informative)(220),     section Language-Defined Attributes (informative).
   Reserved_Check    section Protected Procedure Handlers.
   Storage_Check    section Exception Declarations(6),    section Representation Attributes(6),    section Representation Attributes,
                    section Storage Management(17), see section Tasking Restrictions(17), see section Tasking Restrictions.
   Tag_Check    section Dispatching Operations of Tagged Types(16), see section Type Conversions(42), see section Type Conversions(16), see section Type Conversions(42), see section Type Conversions,
                section Assignment Statements(10),    section Return Statements(10),    section Return Statements.
child
   of a library unit    section Compilation Units - Library Units.
choice parameter    section Exception Handlers.
choice_parameter_specification    section Exception Handlers.
   used    section Exception Handlers(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Circumflex    section The Package Characters.Latin_1.
class    section Glossary (informative).
   See also package    section Packages.
   See also tag    section Tagged Types and Type Extensions.
   of types    section Types and Subtypes.
Class attribute    section Tagged Types and Type Extensions(14), see section Private Operations(9), see section Language-Defined Attributes (informative)(14), see section Private Operations(9), see section Language-Defined Attributes (informative),
                   section Language-Defined Attributes (informative).
class determined for a formal type    section Formal Types.
class-wide type    section Derivation Classes(4), see section Discriminants(4), see section Discriminants.
cleanup
   See finalization    section Completion and Finalization.
clock    section Delay Statements, Duration, and Time(6), see section Delay Statements, Duration, and Time(12), see section Monotonic Time(6), see section Delay Statements, Duration, and Time(12), see section Monotonic Time.
clock jump    section Monotonic Time.
clock tick    section Monotonic Time.
Close    section Limited Types(19),   section Limited Types(20),     section The Generic Package Sequential_IO(19),   section Limited Types(20),     section The Generic Package Sequential_IO,
         section The Generic Package Direct_IO(8), see section The Package Text_IO(11), see section The Package Streams.Stream_IO(8), see section The Package Text_IO(11), see section The Package Streams.Stream_IO.
close result set    section Model of Fixed Point Arithmetic.
closed entry    section Entry Calls.
   of a protected object    section Entry Calls.
   of a task    section Entry Calls.
closed under derivation    section Derived Types and Classes(28), see section Glossary (informative)(6), see section Glossary (informative)(28), see section Glossary (informative)(6), see section Glossary (informative).
closure
   downward    section Operations of Access Types.
COBOL    section Interfacing with COBOL(104), see section Interfacing with COBOL(104), see section Interfacing with COBOL.
   child of Interfaces    section Interfacing with COBOL.
COBOL interface    section Interfacing with COBOL.
COBOL standard    section Normative References.
COBOL_Character    section Interfacing with COBOL.
COBOL_Employee_Record_Type    section Interfacing with COBOL.
COBOL_Employee_IO    section Interfacing with COBOL.
COBOL_Record    section Interfacing with COBOL.
Code    section Qualified Expressions.
code_statement    section Machine Code Insertions.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
coding
   aspect of representation    section Enumeration Representation Clauses.
Coefficient    section Floating Point Types.
Coin section Random Number Generation(58)
Col    section The Package Text_IO.
colon    section Character Set(15), see section The Package Characters.Latin_1(10), see section ASCII(15), see section The Package Characters.Latin_1(10), see section ASCII.
Color    section Type Declarations(15), see section Enumeration Types(15), see section Enumeration Types.
Column    section Type Declarations.
column number    section Text Input-Output.
Column_Ptr    section Integer Types.
comma    section Character Set(15), see section The Package Characters.Latin_1(15), see section The Package Characters.Latin_1.
Command_Line
   child of Ada    section The Package Command_Line.
Command_Name    section The Package Command_Line.
comment    section Comments.
comments, instructions for submission    section Introduction.
Commercial_At    section The Package Characters.Latin_1.
Communication_Error    section Partition Communication Subsystem.
comparison operator
   See relational operator    section Relational Operators and Membership Tests.
compatibility
   composite_constraint with an access subtype    section Access Types.
   constraint with a subtype    section Subtype Declarations.
   delta_constraint with an ordinary fixed point subtype
         section Reduced Accuracy Subtypes.
   digits_constraint with a decimal fixed point subtype
         section Fixed Point Types.
   digits_constraint with a floating point subtype    section Reduced Accuracy Subtypes.
   discriminant constraint with a subtype    section Discriminant Constraints.
   index constraint with a subtype    section Index Constraints and Discrete Ranges.
   range with a scalar subtype    section Scalar Types.
   range_constraint with a scalar subtype    section Scalar Types.
compatible
   a type, with a convention    section Interfacing Pragmas.
compilation    section Compilation Units - Library Units.
   separate    section Separate Compilation.
Compilation unit    section Separate Compilation(2), see section Compilation Units - Library Units(9), see section Glossary (informative)(2), see section Compilation Units - Library Units(9), see section Glossary (informative).
compilation units needed
   by a compilation unit    section Program Execution.
   remote call interface    section Remote Call Interface Library Units.
   shared passive library unit    section Shared Passive Library Units.
compilation_unit    section Compilation Units - Library Units.
   used    section Compilation Units - Library Units(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
compile-time error    section Structure(27), see section Classification of Errors(27), see section Classification of Errors.
compile-time semantics    section Structure.
complete context    section The Context of Overload Resolution.
completely defined    section Completions of Declarations.
completion
   abnormal    section Completion and Finalization.
   compile-time concept    section Completions of Declarations.
   normal    section Completion and Finalization.
   run-time concept    section Completion and Finalization.
completion and leaving (completed and left)    section Completion and Finalization.
completion legality
   entry_body    section Entries and Accept Statements.
      [partial]    section Incomplete Type Declarations.
Complex    section Record Types(28), see section Interfacing with Fortran(9), see section Complex Types(28), see section Interfacing with Fortran(9), see section Complex Types.
Complex_Elementary_Functions
   child of Ada.Numerics    section Complex Elementary Functions.
Complex_Types
   child of Ada.Numerics    section Complex Types.
Complex_IO
   child of Ada.Text_IO    section Complex Input-Output.
   child of Ada.Wide_Text_IO    section The Package Wide_Text_IO.Complex_IO.
component    section Types and Subtypes(2), see section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects(2), see section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects.
component subtype    section Array Types.
component_choice_list    section Record Aggregates.
   used    section Record Aggregates(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
component_clause    section Record Representation Clauses.
   used    section Record Representation Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
component_declaration    section Record Types.
   used    section Record Types(5), see section Protected Units and Protected Objects(6), see section Syntax Summary (informative)(5), see section Protected Units and Protected Objects(6), see section Syntax Summary (informative).
component_definition    section Array Types.
   used    section Array Types(3), see section Array Types(5), see section Record Types(6), see section Syntax Summary (informative)(3), see section Array Types(5), see section Record Types(6), see section Syntax Summary (informative).
component_item    section Record Types.
   used    section Record Types(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
component_list    section Record Types.
   used    section Record Types(3), see section Variant Parts and Discrete Choices(3), see section Syntax Summary (informative)(3), see section Variant Parts and Discrete Choices(3), see section Syntax Summary (informative).
Component_Size attribute    section Representation Attributes(69), see section Language-Defined Attributes (informative)(69), see section Language-Defined Attributes (informative).
Component_Size clause    section Representation Attributes(7), see section Representation Attributes(7), see section Representation Attributes.
components
   of a record type    section Record Types.
Compose attribute    section Attributes of Floating Point Types(24), see section Language-Defined Attributes (informative)(24), see section Language-Defined Attributes (informative).
Compose_From_Cartesian    section Complex Types.
Compose_From_Polar    section Complex Types.
composite type    section Types and Subtypes(2), see section Glossary (informative)(2), see section Glossary (informative).
composite_constraint    section Subtype Declarations.
   used    section Subtype Declarations(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
compound delimiter    section Lexical Elements, Separators, and Delimiters.
compound_statement    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
concatenation operator    section Expressions(1), see section Binary Adding Operators(1), see section Binary Adding Operators.
concrete subprogram
   See nonabstract subprogram    section Abstract Types and Subprograms.
concrete type
   See nonabstract type    section Abstract Types and Subprograms.
concurrent processing
   See task    section Tasks and Synchronization.
condition    section If Statements.
   used    section If Statements(2),    section Loop Statements(3),    section Exit Statements(2),    section Loop Statements(3),    section Exit Statements,
           section Entries and Accept Statements(7), see section Selective Accept(3), see section Syntax Summary (informative)(7), see section Selective Accept(3), see section Syntax Summary (informative).
   See also exception    section Exceptions.
conditional_entry_call    section Conditional Entry Calls.
   used    section Select Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
configuration
   of the partitions of a program    section Distributed Systems (normative).
configuration pragma    section Pragmas and Program Units.
   Locking_Policy    section Priority Ceiling Locking.
   Normalize_Scalars    section Pragma Normalize_Scalars.
   Queuing_Policy    section Entry Queuing Policies.
   Restrictions    section Pragma Restrictions.
   Reviewable    section Pragma Reviewable.
   Suppress    section Suppressing Checks.
   Task_Dispatching_Policy    section The Standard Task Dispatching Policy.
conformance    section Conformance Rules.
   of an implementation with the Standard    section Conformity of an Implementation with the Standard.
   See also   full conformance, mode conformance,
      subtype conformance, type conformance
Conjugate    section Complex Types(12), see section Complex Types(12), see section Complex Types.
consistency
   among compilation units    section The Compilation Process.
constant    section Objects and Named Numbers.
   See also literal    section Literals.
   See also static    section Static Expressions and Static Subtypes.
   result of a function_call    section Subprogram Calls.
constant object    section Objects and Named Numbers.
constant view    section Objects and Named Numbers.
Constants
   child of Ada.Strings.Maps    section String-Handling Sets and Mappings.
constituent
   of a construct    section Method of Description and Syntax Notation.
constrained    section Types and Subtypes.
   object    section Object Declarations(9), see section Access Types(9), see section Parameter Associations(9), see section Access Types(9), see section Parameter Associations.
   subtype    section Types and Subtypes(9),     section Derived Types and Classes(6),     section Scalar Types(9),     section Derived Types and Classes(6),     section Scalar Types,
              section Enumeration Types(10), see section Integer Types(9),   section Integer Types(10), see section Integer Types(9),   section Integer Types,
              section Floating Point Types(11), see section Fixed Point Types(13), see section Fixed Point Types(11), see section Fixed Point Types(13), see section Fixed Point Types,
              section Array Types(15),    section Array Types(16),    section Discriminants(15),    section Array Types(16),    section Discriminants,
              section Tagged Types and Type Extensions(15),    section Access Types(14),   section Language-Defined Attributes (informative)(15),    section Access Types(14),   section Language-Defined Attributes (informative).
Constrained attribute    section Operations of Discriminated Types(3), see section The Constrained Attribute(2), see section Language-Defined Attributes (informative)(3), see section The Constrained Attribute(2), see section Language-Defined Attributes (informative).
constrained by its initial value    section Object Declarations(9), see section Access Types(9), see section Access Types.
   [partial]    section Allocators.
constrained_array_definition    section Array Types.
   used    section Array Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
constraint    section Subtype Declarations.
   used    section Subtype Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
   [partial]    section Types and Subtypes.
   of a first array subtype    section Array Types.
   of an object    section Object Declarations.
Constraint_Error    section The Package Standard.
   raised by failure of run-time check
         section Subtype Declarations(12),   section Scalar Types(24),    section Scalar Types(12),   section Scalar Types(24),    section Scalar Types,
         section Scalar Types(43),     section Scalar Types(44),    section Scalar Types(43),     section Scalar Types(44),    section Scalar Types,
         section Scalar Types(55),     section Integer Types(20), see section Operations of Discrete Types(55),     section Integer Types(20), see section Operations of Discrete Types,
         section Fixed Point Types(19),   section Dispatching Operations of Tagged Types(16), see section Names(19),   section Dispatching Operations of Tagged Types(16), see section Names,
         section Indexed Components(7),    section Slices(7),   section Selected Components(7),    section Slices(7),   section Selected Components,
         section Literals(11),     section Aggregates(6),     section Extension Aggregates(11),     section Aggregates(6),     section Extension Aggregates,
         section Array Aggregates(31),   section Expressions(11),    section Operators and Expression Evaluation(31),   section Expressions(11),    section Operators and Expression Evaluation,
         section Operators and Expression Evaluation(11),     section Operators and Expression Evaluation(12),    section Logical Operators and Short-circuit Control Forms(11),     section Operators and Expression Evaluation(12),    section Logical Operators and Short-circuit Control Forms,
         section Binary Adding Operators(8),    section Multiplying Operators(22), see section Highest Precedence Operators(8),    section Multiplying Operators(22), see section Highest Precedence Operators,
         section Highest Precedence Operators(12),   section Highest Precedence Operators(13), see section Type Conversions(12),   section Highest Precedence Operators(13), see section Type Conversions,
         section Type Conversions(57),     section Type Conversions(60),    section Qualified Expressions(57),     section Type Conversions(60),    section Qualified Expressions,
         section Allocators(10),     section Assignment Statements(10),    section Case Statements(10),     section Assignment Statements(10),    section Case Statements,
         section Return Statements(9),      section Exception Declarations(4),    section The Package Exceptions(9),      section Exception Declarations(4),    section The Package Exceptions,
         section Suppressing Checks(10),    section Data Validity(9), see section Stream-Oriented Attributes(10),    section Data Validity(9), see section Stream-Oriented Attributes,
         section Fixed-Length String Handling(109), see section Wide_String Handling(47), see section Elementary Functions(109), see section Wide_String Handling(47), see section Elementary Functions,
         section Elementary Functions(34),   section Random Number Generation(39), see section Random Number Generation(34),   section Random Number Generation(39), see section Random Number Generation,
         section Attributes of Floating Point Types(26),   section Attributes of Floating Point Types(29), see section Attributes of Floating Point Types(26),   section Attributes of Floating Point Types(29), see section Attributes of Floating Point Types,
         section Attributes of Floating Point Types(50),   section Attributes of Floating Point Types(53), see section Attributes of Floating Point Types(50),   section Attributes of Floating Point Types(53), see section Attributes of Floating Point Types,
         section Attributes of Floating Point Types(62),   section The Package Command_Line(14),   section Interfacing with C(62),   section The Package Command_Line(14),   section Interfacing with C,
         section Interfacing with C(54),     section Interfacing with COBOL(58),    section Remote Subprogram Calls(54),     section Interfacing with COBOL(58),    section Remote Subprogram Calls,
         section Complex Types(40),   section Complex Elementary Functions(28), see section Model of Floating Point Arithmetic(40),   section Complex Elementary Functions(28), see section Model of Floating Point Arithmetic,
         section Model-Oriented Attributes of Floating Point Types(7),    section Model of Fixed Point Arithmetic(26), see section Accuracy Requirements for the Elementary Functions(7),    section Model of Fixed Point Arithmetic(26), see section Accuracy Requirements for the Elementary Functions,
         section Accuracy Requirements for Complex Arithmetic(4),    section Language-Defined Attributes (informative)(11),      section Language-Defined Attributes (informative)(4),    section Language-Defined Attributes (informative)(11),      section Language-Defined Attributes (informative),
         section Language-Defined Attributes (informative)(47),       section Language-Defined Attributes (informative)(114),     section Language-Defined Attributes (informative)(47),       section Language-Defined Attributes (informative)(114),     section Language-Defined Attributes (informative),
         section Language-Defined Attributes (informative)(184),      section Language-Defined Attributes (informative)(202),     section Language-Defined Attributes (informative)(184),      section Language-Defined Attributes (informative)(202),     section Language-Defined Attributes (informative),
         section Language-Defined Attributes (informative)(241),      section Language-Defined Attributes (informative)(241),      section Language-Defined Attributes (informative).
Construct    section Method of Description and Syntax Notation(16), see section Glossary (informative)(16), see section Glossary (informative).
constructor
   See initialization    section Object Declarations(19), see section User-Defined Assignment and Finalization(19), see section User-Defined Assignment and Finalization.
   See initialization expression    section Object Declarations.
   See Initialize    section User-Defined Assignment and Finalization.
   See initialized alligator    section Allocators.
Consumer    section Example of Tasking and Synchronization(5), see section Example of Tasking and Synchronization(5), see section Example of Tasking and Synchronization.
context free grammar
   complete listing    section Syntax Summary (informative).
   cross reference    section Syntax Summary (informative).
   notation    section Method of Description and Syntax Notation.
   under Syntax heading    section Structure.
context_clause    section Context Clauses - With Clauses.
   used    section Compilation Units - Library Units(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
context_item    section Context Clauses - With Clauses.
   used    section Context Clauses - With Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
contiguous representation
   [partial]    section Storage Place Attributes(5), see section The Package System.Storage_Elements(12), see section Unchecked Type Conversions(5), see section The Package System.Storage_Elements(12), see section Unchecked Type Conversions,
                section Unchecked Type Conversions(17),   section Storage Management(17),   section Storage Management.
Continue    section Asynchronous Task Control.
control character
   See also format_effector    section Character Set.
   See also other_control_function    section Character Set.
   a category of Character    section The Package Characters.Handling(22), see section The Package Characters.Latin_1(22), see section The Package Characters.Latin_1,
                              section The Package Characters.Latin_1.
Control_Set    section String-Handling Sets and Mappings.
Controlled    section User-Defined Assignment and Finalization.
   aspect of representation    section Pragma Controlled.
Controlled pragma    section Pragma Controlled(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
controlled type    section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(9), see section Glossary (informative)(2), see section User-Defined Assignment and Finalization(9), see section Glossary (informative).
Controller    section Task Units and Task Objects.
controlling formal parameter    section Dispatching Operations of Tagged Types.
controlling operand section Dispatching Operations of Tagged Types(2)
controlling result    section Dispatching Operations of Tagged Types.
controlling tag
   for a call on a dispatching operation    section Dispatching Operations of Tagged Types.
controlling tag value    section Dispatching Operations of Tagged Types.
   for the expression in an assignment_statement    section Assignment Statements.
convention    section Conformance Rules(2), see section Interfacing Pragmas(2), see section Interfacing Pragmas.
   aspect of representation    section Interfacing Pragmas.
Convention pragma    section Interfacing Pragmas(7), see section Language-Defined Pragmas (informative)(7), see section Language-Defined Pragmas (informative).
conversion    section Type Conversions(1), see section Type Conversions(1), see section Type Conversions.
   access    section Type Conversions(13), see section Type Conversions(18), see section Type Conversions(13), see section Type Conversions(18), see section Type Conversions.
   arbitrary order    section Method of Description and Syntax Notation.
   array    section Type Conversions(9), see section Type Conversions(9), see section Type Conversions.
   composite (non-array)    section Type Conversions(21), see section Type Conversions(21), see section Type Conversions.
   enumeration    section Type Conversions(21), see section Type Conversions(21), see section Type Conversions.
   numeric    section Type Conversions(8), see section Type Conversions(8), see section Type Conversions.
   unchecked    section Unchecked Type Conversions.
   value    section Type Conversions.
   view    section Type Conversions.
Conversion_Error    section Interfacing with COBOL.
convertible    section Type Conversions.
   required    section Discriminants(16), see section Discriminant Constraints(9), see section Type Conversions(16), see section Discriminant Constraints(9), see section Type Conversions,
               section Type Conversions(15), see section Parameter Associations(15), see section Parameter Associations.
Copy    section Example of Use of a Remote Access-to-Class-Wide Type(2), see section Example of Use of a Remote Access-to-Class-Wide Type(2), see section Example of Use of a Remote Access-to-Class-Wide Type.
copy back of parameters    section Parameter Associations.
copy parameter passing    section Formal Parameter Modes.
Copy_Array    section The Generic Package Interfaces.C.Pointers.
Copy_Sign attribute    section Attributes of Floating Point Types(51), see section Language-Defined Attributes (informative)(51), see section Language-Defined Attributes (informative).
Copy_Terminated_Array    section The Generic Package Interfaces.C.Pointers.
Copyright_Sign    section The Package Characters.Latin_1.
core language    section Structure.
corresponding constraint    section Derived Types and Classes.
corresponding discriminants    section Discriminants.
corresponding index
   for an array_aggregate    section Array Aggregates.
corresponding subtype    section Derived Types and Classes.
corresponding value
   of the target type of a conversion    section Type Conversions.
Cos    section Elementary Functions(5), see section Complex Elementary Functions(5), see section Complex Elementary Functions.
Cosh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Cot    section Elementary Functions(5), see section Complex Elementary Functions(5), see section Complex Elementary Functions.
Coth    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Count    section Fixed-Length String Handling(13), see section Fixed-Length String Handling(14), see section Fixed-Length String Handling(13), see section Fixed-Length String Handling(14), see section Fixed-Length String Handling,
         section Bounded-Length String Handling(48), see section Bounded-Length String Handling(49), see section Bounded-Length String Handling(48), see section Bounded-Length String Handling(49), see section Bounded-Length String Handling,
         section Unbounded-Length String Handling(43), see section Unbounded-Length String Handling(44), see section Unbounded-Length String Handling(43), see section Unbounded-Length String Handling(44), see section Unbounded-Length String Handling,
         section The Generic Package Direct_IO(4),   section Text Input-Output(10),   section The Package Text_IO(4),   section Text Input-Output(10),   section The Package Text_IO,
         section The Package Streams.Stream_IO.
Count attribute    section Task and Entry Attributes(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
Counter    section Derived Types and Classes.
cover
   a type    section Derivation Classes.
   of a choice and an exception    section Exception Handlers.
cover a value
   by a discrete_choice_list    section Variant Parts and Discrete Choices.
   by a discrete_choice    section Variant Parts and Discrete Choices.
CPU_Identifier    section Deferred Constants.
CR    section The Package Characters.Latin_1.
create    section Declarations(12),    section The Generic Package Sequential_IO(6), see section The Generic Package Direct_IO(12),    section The Generic Package Sequential_IO(6), see section The Generic Package Direct_IO,
          section The Package Text_IO(9), see section The Package Streams.Stream_IO(9), see section The Package Streams.Stream_IO.
creation
   of a protected object    section Protected Procedure Handlers.
   of a task object    section Task Priorities.
   of an object    section Objects and Named Numbers.
critical section
   See intertask communication    section Intertask Communication.
CSI    section The Package Characters.Latin_1.
Currency_Sign    section The Package Characters.Latin_1.
current column number    section Text Input-Output.
current index
   of an open direct file    section Sequential and Direct Files.
current instance
   of a generic unit    section The Context of Overload Resolution.
   of a type    section The Context of Overload Resolution.
current line number    section Text Input-Output.
current mode
   of an open file    section External Files and File Objects.
current page number    section Text Input-Output.
current size
   of an external file    section Sequential and Direct Files.
Current_Error    section The Package Text_IO(17), see section The Package Text_IO(17), see section The Package Text_IO.
Current_Handler    section The Package Interrupts.
Current_Input    section The Package Text_IO(17), see section The Package Text_IO(17), see section The Package Text_IO.
Current_Output    section The Package Text_IO(17), see section The Package Text_IO(17), see section The Package Text_IO.
Current_State    section Synchronous Task Control.
Current_Task    section The Package Task_Identification.

index

dangling references
   prevention via accessibility rules    section Operations of Access Types.
Data_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18),   section The Generic Package Storage_IO(15),   section The Generic Package Direct_IO(18),   section The Generic Package Storage_IO,
              section The Package Text_IO(85), see section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(85), see section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output.
Date    section Record Types.
Day    section Enumeration Types(14), see section Delay Statements, Duration, and Time(14), see section Delay Statements, Duration, and Time.
Day_Duration    section Delay Statements, Duration, and Time.
Day_Number    section Delay Statements, Duration, and Time.
DC1    section The Package Characters.Latin_1.
DC2    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
DC3    section The Package Characters.Latin_1.
DC4    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
DCS    section The Package Characters.Latin_1.
Deallocate    section Storage Management.
deallocation of storage    section Unchecked Storage Deallocation.
Decimal
   child of Ada    section The Package Decimal.
decimal digit
   a category of Character    section The Package Characters.Handling.
decimal fixed point type    section Fixed Point Types(1), see section Fixed Point Types(1), see section Fixed Point Types.
Decimal_Conversions    section Interfacing with COBOL.
Decimal_Digit_Set    section String-Handling Sets and Mappings.
Decimal_Element    section Interfacing with COBOL.
decimal_fixed_point_definition    section Fixed Point Types.
   used    section Fixed Point Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
decimal_literal    section Decimal Literals.
   used    section Numeric Literals(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Decimal_Output    section The Package Text_IO.Editing.
Decimal_IO    section The Package Text_IO.
Declaration    section Declarations(5), see section Declarations(6), see section Glossary (informative)(5), see section Declarations(6), see section Glossary (informative).
declarative region
   of a construct    section Declarative Region.
declarative_item    section Declarative Parts.
   used    section Declarative Parts(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
declarative_part    section Declarative Parts.
   used    section Block Statements(2), see section Subprogram Bodies(2),    section Package Bodies(2), see section Subprogram Bodies(2),    section Package Bodies,
           section Task Units and Task Objects(6), see section Entries and Accept Statements(5), see section Syntax Summary (informative)(6), see section Entries and Accept Statements(5), see section Syntax Summary (informative).
declare    section Declarations(8), see section Declarations(8), see section Declarations.
declared pure    section Elaboration Control.
Decrement    section The Generic Package Interfaces.C.Pointers.
deeper
   accessibility level    section Operations of Access Types.
   statically    section Operations of Access Types(4), see section Operations of Access Types(4), see section Operations of Access Types.
default entry queuing policy    section Entry Calls.
default treatment    section Interrupt Support.
Default_Bit_Order    section The Package System.
Default_Currency    section The Package Text_IO.Editing.
default_expression    section Discriminants.
   used    section Discriminants(5),   section Record Types(6), see section Subprogram Declarations(5),   section Record Types(6), see section Subprogram Declarations,
           section Formal Objects(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Default_Fill    section The Package Text_IO.Editing.
Default_Message_Procedure    section Access Types.
default_name    section Formal Subprograms.
   used    section Formal Subprograms(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Default_Priority    section The Package System(17), see section Task Priorities(17), see section Task Priorities.
Default_Radix_Mark    section The Package Text_IO.Editing.
Default_Separator    section The Package Text_IO.Editing.
deferred constant    section Deferred Constants.
deferred constant declaration    section Object Declarations(6), see section Deferred Constants(6), see section Deferred Constants.
defining name    section Declarations.
defining_character_literal    section Enumeration Types.
   used    section Enumeration Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
defining_designator    section Subprogram Declarations.
   used    section Subprogram Declarations(4), see section Generic Instantiation(2), see section Syntax Summary (informative)(4), see section Generic Instantiation(2), see section Syntax Summary (informative).
defining_identifier    section Declarations.
   used    section Type Declarations(3),   section Subtype Declarations(2),   section Object Declarations(3),   section Subtype Declarations(2),   section Object Declarations,
           section Enumeration Types(3),   section Incomplete Type Declarations(2), see section Loop Statements(3),   section Incomplete Type Declarations(2), see section Loop Statements,
           section Subprogram Declarations(7),     section Private Types and Private Extensions(2),     section Private Types and Private Extensions(7),     section Private Types and Private Extensions(2),     section Private Types and Private Extensions,
           section Object Renaming Declarations(2),   section Exception Renaming Declarations(2),   section Task Units and Task Objects(2),   section Exception Renaming Declarations(2),   section Task Units and Task Objects,
           section Task Units and Task Objects(3),     section Task Units and Task Objects(6),     section Protected Units and Protected Objects(3),     section Task Units and Task Objects(6),     section Protected Units and Protected Objects,
           section Protected Units and Protected Objects(3),     section Protected Units and Protected Objects(7),     section Entries and Accept Statements(3),     section Protected Units and Protected Objects(7),     section Entries and Accept Statements,
           section Entries and Accept Statements(5),   section Entries and Accept Statements(8),   section Subunits of Compilation Units(5),   section Entries and Accept Statements(8),   section Subunits of Compilation Units,
           section Subunits of Compilation Units(5), see section Subunits of Compilation Units(6), see section Exception Handlers(5), see section Subunits of Compilation Units(6), see section Exception Handlers,
           section Formal Types(2),    section Formal Packages(2),    section Syntax Summary (informative)(2),    section Formal Packages(2),    section Syntax Summary (informative).
defining_identifier_list    section Object Declarations.
   used    section Object Declarations(2), see section Number Declarations(2), see section Discriminants(2), see section Number Declarations(2), see section Discriminants,
           section Record Types(6),    section Subprogram Declarations(15),   section Exception Declarations(6),    section Subprogram Declarations(15),   section Exception Declarations,
           section Formal Objects(2),   section Syntax Summary (informative)(2),   section Syntax Summary (informative).
defining_operator_symbol    section Subprogram Declarations.
   used    section Subprogram Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
defining_program_unit_name    section Subprogram Declarations.
   used    section Subprogram Declarations(4),   section Subprogram Declarations(6),    section Package Specifications and Declarations(4),   section Subprogram Declarations(6),    section Package Specifications and Declarations,
           section Package Bodies(2),   section Package Renaming Declarations(2), see section Generic Renaming Declarations(2),   section Package Renaming Declarations(2), see section Generic Renaming Declarations,
           section Generic Instantiation(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Definite attribute    section Formal Private and Derived Types(23), see section Language-Defined Attributes (informative)(23), see section Language-Defined Attributes (informative).
definite subtype    section Objects and Named Numbers.
Definition    section Declarations(7), see section Glossary (informative)(7), see section Glossary (informative).
Deg_To_Rad    section Static Expressions and Static Subtypes.
Degree_Sign    section The Package Characters.Latin_1.
DEL    section The Package Characters.Latin_1(14), see section ASCII(14), see section ASCII.
delay_alternative    section Selective Accept.
   used    section Selective Accept(4), see section Timed Entry Calls(2), see section Syntax Summary (informative)(4), see section Timed Entry Calls(2), see section Syntax Summary (informative).
delay_relative_statement    section Delay Statements, Duration, and Time.
   used    section Delay Statements, Duration, and Time(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
delay_statement    section Delay Statements, Duration, and Time.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Selective Accept(6), see section Asynchronous Transfer of Control(4), see section Selective Accept(6), see section Asynchronous Transfer of Control,
           section Syntax Summary (informative).
delay_until_statement    section Delay Statements, Duration, and Time.
   used    section Delay Statements, Duration, and Time(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Delete    section Fixed-Length String Handling(29), see section Fixed-Length String Handling(30), see section Bounded-Length String Handling(29), see section Fixed-Length String Handling(30), see section Bounded-Length String Handling,
          section Bounded-Length String Handling(65), see section Unbounded-Length String Handling(59), see section Unbounded-Length String Handling(65), see section Unbounded-Length String Handling(59), see section Unbounded-Length String Handling,
          section The Generic Package Sequential_IO(8),   section The Generic Package Direct_IO(8),   section The Package Text_IO(8),   section The Generic Package Direct_IO(8),   section The Package Text_IO,
          section The Package Streams.Stream_IO.
delimiter    section Lexical Elements, Separators, and Delimiters.
delivery
   of an interrupt    section Interrupt Support.
delta
   of a fixed point type    section Fixed Point Types.
Delta attribute    section Operations of Fixed Point Types(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
delta_constraint    section Reduced Accuracy Subtypes.
   used    section Subtype Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
Denorm attribute    section Attributes of Floating Point Types(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
denormalized number    section Attributes of Floating Point Types.
denote    section The Context of Overload Resolution.
   informal definition    section Declarations.
   name used as a pragma argument    section The Context of Overload Resolution.
depend on a discriminant
   for a constraint or component_definition    section Discriminants.
   for a component    section Discriminants.
dependence
   elaboration    section Program Execution.
   of a task on a master    section Task Dependence - Termination of Tasks.
   of a task on another task    section Task Dependence - Termination of Tasks.
   semantic    section Compilation Units - Library Units.
depth
   accessibility level    section Operations of Access Types.
dereference    section Names.
Dereference_Error    section The Package Interfaces.C.Strings.
derivation class
   for a type    section Derivation Classes.
derived from
   directly or indirectly    section Derivation Classes.
derived type    section Derived Types and Classes(1), see section Glossary (informative)(1), see section Glossary (informative).
   [partial]    section Derived Types and Classes.
derived_type_definition    section Derived Types and Classes.
   used    section Type Declarations(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
descendant    section Compilation Units - Library Units.
   of a type    section Derivation Classes.
   relationship with scope    section Scope of Declarations.
Descriptor    section Change of Representation.
designate    section Access Types.
designated profile
   of an access-to-subprogram type    section Access Types.
designated subtype
   of a named access type    section Access Types.
   of an anonymous access type    section Access Types.
designated type
   of a named access type    section Access Types.
   of an anonymous access type    section Access Types.
designator    section Subprogram Declarations.
   used    section Subprogram Bodies(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
destructor
   See finalization    section User-Defined Assignment and Finalization(1), see section Completion and Finalization(1), see section Completion and Finalization.
Detach_Handler    section The Package Interrupts.
determined class for a formal type    section Formal Types.
determines
   a type by a subtype_mark    section Subtype Declarations.
Device    section Variant Parts and Discrete Choices.
Device_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(15),   section The Generic Package Direct_IO,
                section The Package Text_IO(85), see section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(85), see section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output.
Device_Interface    section The Package Interrupts.
Device_Priority    section The Package Interrupts.
Diaeresis    section The Package Characters.Latin_1.
Dice    section Random Number Generation.
Dice_Game    section Random Number Generation.
Die    section Random Number Generation.
digit    section Character Set.
   used    section Character Set(3),    section Identifiers(3), see section Decimal Literals(3),    section Identifiers(3), see section Decimal Literals,
           section Based Literals(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
digits
   of a decimal fixed point subtype    section Fixed Point Types,
                                       section Operations of Fixed Point Types.
Digits attribute    section Operations of Floating Point Types(2), see section Operations of Fixed Point Types(2), see section Operations of Fixed Point Types,
                    section Language-Defined Attributes (informative)(56),     section Language-Defined Attributes (informative)(56),     section Language-Defined Attributes (informative).
digits_constraint    section Fixed Point Types.
   used    section Subtype Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
dimensionality
   of an array    section Array Types.
direct access    section Sequential and Direct Files.
direct file    section Sequential and Direct Files.
direct_name    section Names.
   used    section Variant Parts and Discrete Choices(2), see section Names(2),   section Simple and Compound Statements - Sequences of Statements(2), see section Names(2),   section Simple and Compound Statements - Sequences of Statements,
           section Entries and Accept Statements(3), see section Representation Items(3), see section At Clauses(3), see section Representation Items(3), see section At Clauses,
           section Syntax Summary (informative).
Direct_IO    section Renamings of Ada 83 Library Units.
   child of Ada    section The Generic Package Direct_IO(2), see section The Generic Package Storage_IO(2), see section The Generic Package Storage_IO.
Direction    section The Package Strings.
directly specified
   of an aspect of representation of an entity    section Representation Items.
directly visible    section Visibility(2), see section Visibility(2), see section Visibility.
   within a pragma in a context_clause    section Environment-Level Visibility Rules.
   within a pragma that appears at the place of a compilation unit
         section Environment-Level Visibility Rules.
   within a use_clause in a context_clause    section Environment-Level Visibility Rules.
   within a with_clause    section Environment-Level Visibility Rules.
   within the parent_unit_name of a library unit    section Environment-Level Visibility Rules.
   within the parent_unit_name of a subunit    section Environment-Level Visibility Rules.
Discard_Names pragma    section Pragma Discard_Names(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
discontiguous representation
   partial  section Storage Place Attributes(5), see section The Package System.Storage_Elements(12), see section Unchecked Type Conversions(5), see section The Package System.Storage_Elements(12), see section Unchecked Type Conversions,
            section Unchecked Type Conversions(17),   section Storage Management(17),   section Storage Management.
discrete array type    section Relational Operators and Membership Tests.
discrete type    section Types and Subtypes(3), see section Scalar Types(1), see section Glossary (informative)(3), see section Scalar Types(1), see section Glossary (informative).
discrete_choice    section Variant Parts and Discrete Choices.
   used    section Variant Parts and Discrete Choices(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
discrete_choice_list    section Variant Parts and Discrete Choices.
   used    section Variant Parts and Discrete Choices(3), see section Array Aggregates(5), see section Case Statements(3), see section Array Aggregates(5), see section Case Statements,
           section Syntax Summary (informative).
Discrete_Random
   child of Ada.Numerics    section Random Number Generation.
discrete_range    section Index Constraints and Discrete Ranges.
   used    section Index Constraints and Discrete Ranges(2), see section Variant Parts and Discrete Choices(5), see section Slices(2), see section Variant Parts and Discrete Choices(5), see section Slices,
           section Syntax Summary (informative).
discrete_subtype_definition    section Array Types.
   used    section Array Types(5),    section Loop Statements(4), see section Entries and Accept Statements(5),    section Loop Statements(4), see section Entries and Accept Statements,
           section Entries and Accept Statements(8), see section Syntax Summary (informative)(8), see section Syntax Summary (informative).
discriminant    section Types and Subtypes(5), see section Discriminants(1), see section Glossary (informative)(5), see section Discriminants(1), see section Glossary (informative).
   of a variant_part    section Variant Parts and Discrete Choices.
discriminant_association    section Discriminant Constraints.
   used    section Discriminant Constraints(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Discriminant_Check    section Suppressing Checks.
   [partial]    section Selected Components(15), see section Aggregates(6),   section Extension Aggregates(15), see section Aggregates(6),   section Extension Aggregates,
                section Type Conversions(43),    section Type Conversions(45), see section Type Conversions(43),    section Type Conversions(45), see section Type Conversions,
                section Type Conversions(52),    section Qualified Expressions(4),   section Allocators(52),    section Qualified Expressions(4),   section Allocators.
discriminant_constraint    section Discriminant Constraints.
   used    section Subtype Declarations(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
discriminant_part    section Discriminants.
   used    section Incomplete Type Declarations(2), see section Private Types and Private Extensions(2), see section Private Types and Private Extensions(2), see section Private Types and Private Extensions(2), see section Private Types and Private Extensions,
           section Formal Types(2),    section Syntax Summary (informative)(2),    section Syntax Summary (informative).
discriminant_specification    section Discriminants.
   used    section Discriminants(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
discriminants
   known    section Discriminants.
   unknown    section Discriminants.
discriminated type    section Discriminants.
Disk_Unit    section Variant Parts and Discrete Choices.
dispatching    section Tagged Types and Type Extensions.
dispatching call
   on a dispatching operation    section Dispatching Operations of Tagged Types.
dispatching operation    section Dispatching Operations of Tagged Types(1), see section Dispatching Operations of Tagged Types(1), see section Dispatching Operations of Tagged Types.
   [partial]    section Tagged Types and Type Extensions.
dispatching point    section The Task Dispatching Model.
   [partial]    section The Task Dispatching Model(8), see section The Standard Task Dispatching Policy(8), see section The Standard Task Dispatching Policy.
dispatching policy for tasks
   [partial]    section The Task Dispatching Model.
dispatching, task    section The Task Dispatching Model.
Display_Format    section Interfacing with COBOL.
displayed magnitude (of a decimal value)    section Edited Output Generation.
disruption of an assignment    section Abort of a Task - Abort of a Sequence of Statements(21), see section Data Validity(21), see section Data Validity.
   [partial]    section Exceptions and Optimization.
distinct access paths    section Formal Parameter Modes.
distributed program    section Distributed Systems (normative).
distributed system    section Distributed Systems (normative).
distributed systems    section Systems Programming (normative).
divide    section Character Set(15), see section The Package Decimal(15), see section The Package Decimal.
divide operator    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
Dividend_Type    section The Package Decimal.
Division_Check    section Suppressing Checks.
   [partial]    section Integer Types(20), see section Multiplying Operators(20), see section Multiplying Operators,
                section Elementary Functions(28), see section Attributes of Floating Point Types(28), see section Attributes of Floating Point Types,
                section Complex Types(40), see section Complex Elementary Functions(40), see section Complex Elementary Functions,
                section Language-Defined Attributes (informative).
Division_Sign    section The Package Characters.Latin_1.
Divisor_Type    section The Package Decimal.
DLE    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
Do_APC    section Partition Communication Subsystem.
Do_RPC    section Partition Communication Subsystem.
documentation (required of an implementation)    section Conformity of an Implementation with the Standard,
                                                 section Implementation-Defined Characteristics (informative).
documentation requirements    section Structure(34), see section Conformity of an Implementation with the Standard(34), see section Conformity of an Implementation with the Standard,
                              section Storage Management(22), see section Random Number Generation(22), see section Random Number Generation,
                              section Exceptions in Input-Output(15),   section Access to Machine Operations(15),   section Access to Machine Operations,
                              section Interrupt Support(12),    section The Package Interrupts(12),    section The Package Interrupts,
                              section Preelaboration Requirements(12),    section The Package Task_Identification(12),    section The Package Task_Identification,
                              section The Package Task_Attributes(18), see section The Standard Task Dispatching Policy(18), see section The Standard Task Dispatching Policy,
                              section Preemptive Abort(3),     section Monotonic Time(3),     section Monotonic Time,
                              section Delay Accuracy(7),     section Other Optimizations and Determinism Rules(7),     section Other Optimizations and Determinism Rules,
                              section Partition Communication Subsystem(25),    section Pragma Normalize_Scalars(25),    section Pragma Normalize_Scalars,
                              section Documentation of Implementation Decisions(1),     section Pragma Inspection_Point(1),     section Pragma Inspection_Point,
                              section Safety and Security Restrictions(25),    section Interrupt Entries(25),    section Interrupt Entries.
Dollar_Sign    section The Package Characters.Latin_1.
Done    section Interrupt Entries.
dot    section Character Set.
dot selection
   See selected_component    section Selected Components.
Dot_Product    section Subprogram Declarations(39), see section Subprogram Bodies(39), see section Subprogram Bodies.
double    section Interfacing with C.
Double_Precision    section Interfacing with Fortran.
Double_Square    section Discriminants.
downward closure  section Operations of Access Types.
Dozen    section Type Conversions.
drift rate    section Monotonic Time.
Drum_Ref    section Access Types.
Drum_Unit    section Variant Parts and Discrete Choices.
Duration    section The Package Standard.
dynamic binding
   See dispatching operation    section Tagged Types and Type Extensions.
dynamic semantics    section Structure.
Dynamic_Priorities
   child of Ada    section Dynamic Priorities.
dynamically determined tag    section Dispatching Operations of Tagged Types.
dynamically enclosing
   of one execution by another    section Exception Handling.
dynamically tagged    section Dispatching Operations of Tagged Types.

index

e    section The Numerics Packages.
edited output    section Edited Output for Decimal Types.
Editing
   child of Ada.Text_IO    section The Package Text_IO.Editing.
   child of Ada.Wide_Text_IO    section The Package Wide_Text_IO.Editing.
effect
   external    section Conformity of an Implementation with the Standard.
efficiency    section Suppressing Checks(29), see section Exceptions and Optimization(29), see section Exceptions and Optimization.
Elaborate pragma    section Elaboration Control(20), see section Language-Defined Pragmas (informative)(20), see section Language-Defined Pragmas (informative).
Elaborate_All pragma    section Elaboration Control(21), see section Language-Defined Pragmas (informative)(21), see section Language-Defined Pragmas (informative).
Elaborate_Body pragma    section Elaboration Control(22), see section Language-Defined Pragmas (informative)(22), see section Language-Defined Pragmas (informative).
elaborated    section Declarative Parts.
elaboration    section Declarations(11), see section Glossary (informative)(11), see section Glossary (informative).
   abstract_subprogram_declaration    section Subprogram Declarations.
   access_definition    section Access Types.
   access_type_definition    section Access Types.
   array_type_definition    section Array Types.
   choice_parameter_specification    section Exception Handling.
   component_declaration    section Record Types.
   component_definition    section Array Types(22), see section Record Types(22), see section Record Types.
   component_list    section Record Types.
   declaration named by a pragma Import    section Interfacing Pragmas.
   declarative_part    section Declarative Parts.
   deferred constant declaration    section Deferred Constants.
   delta_constraint    section Reduced Accuracy Subtypes.
   derived_type_definition    section Derived Types and Classes.
   digits_constraint    section Fixed Point Types.
   discrete_subtype_definition    section Array Types.
   discriminant_constraint    section Discriminant Constraints.
   entry_declaration    section Entries and Accept Statements.
   enumeration_type_definition    section Enumeration Types.
   exception_declaration    section Exception Declarations.
   fixed_point_definition    section Fixed Point Types.
   floating_point_definition    section Floating Point Types.
   full type definition    section Type Declarations.
   full_type_declaration    section Type Declarations.
   generic body    section Generic Bodies.
   generic_declaration    section Generic Declarations.
   generic_instantiation    section Generic Instantiation.
   incomplete_type_declaration    section Incomplete Type Declarations.
   index_constraint    section Index Constraints and Discrete Ranges.
   integer_type_definition    section Integer Types.
   loop_parameter_specification    section Loop Statements.
   non-generic subprogram_body    section Subprogram Bodies.
   nongeneric package_body    section Package Bodies.
   number_declaration    section Number Declarations.
   object_declaration    section Object Declarations(15), see section User-Defined Assignment and Finalization(15), see section User-Defined Assignment and Finalization.
   package_body of Standard    section The Package Standard.
   package_declaration    section Package Specifications and Declarations.
   partition    section Partitions(6), see section Partition Communication Subsystem(6), see section Partition Communication Subsystem.
   pragma    section Pragmas.
   private_extension_declaration    section Private Types and Private Extensions.
   private_type_declaration    section Private Types and Private Extensions.
   protected declaration    section Protected Units and Protected Objects.
   protected_body    section Protected Units and Protected Objects.
   protected_definition    section Protected Units and Protected Objects.
   range_constraint    section Scalar Types.
   real_type_definition    section Real Types.
   record_definition    section Record Types.
   record_extension_part    section Type Extensions.
   record_type_definition    section Record Types.
   renaming_declaration    section Renaming Declarations.
   representation_clause    section Representation Items.
   single_protected_declaration    section Protected Units and Protected Objects.
   single_task_declaration    section Task Units and Task Objects.
   Storage_Size pragma    section Representation Attributes.
   subprogram_declaration    section Subprogram Declarations.
   subtype_declaration    section Subtype Declarations.
   subtype_indication    section Subtype Declarations.
   task declaration    section Task Units and Task Objects.
   task_body    section Task Units and Task Objects.
   task_definition    section Task Units and Task Objects.
   use_clause    section Use Clauses.
   variant_part    section Variant Parts and Discrete Choices.
elaboration control    section Elaboration Control.
elaboration dependence
   library_item on another    section Program Execution.
Elaboration_Check    section Suppressing Checks.
   [partial]    section Declarative Parts.
Elem    section Generic Declarations.
element    section Bounded-Length String Handling(26), see section Unbounded-Length String Handling(20), see section The Generic Package Interfaces.C.Pointers(26), see section Unbounded-Length String Handling(20), see section The Generic Package Interfaces.C.Pointers.
   of a storage pool    section Storage Management.
Element_Array    section The Generic Package Interfaces.C.Pointers.
Element_Type    section Abstract Types and Subprograms(15), see section The Generic Package Sequential_IO(2), see section The Generic Package Direct_IO(15), see section The Generic Package Sequential_IO(2), see section The Generic Package Direct_IO,
                section The Generic Package Storage_IO.
elementary type    section Types and Subtypes(2), see section Glossary (informative)(2), see section Glossary (informative).
Elementary_Functions
   child of Ada.Numerics    section Elementary Functions.
eligible
   a type, for a convention    section Interfacing Pragmas.
else part
   of a selective_accept    section Selective Accept.
EM    section The Package Characters.Latin_1.
embedded systems    section Systems Programming (normative)(1), see section Real-Time Systems (normative)(1), see section Real-Time Systems (normative).
Empty    section Abstract Types and Subprograms.
encapsulation
   See package    section Packages.
enclosing
   immediately    section Declarative Region.
end of a line    section Lexical Elements, Separators, and Delimiters.
End_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO,
             section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(26), see section Exceptions in Input-Output.
End_Of_File    section Example of Exception Handling(4),   section The Generic Package Sequential_IO(13), see section The Generic Package Direct_IO(4),   section The Generic Package Sequential_IO(13), see section The Generic Package Direct_IO,
               section The Package Text_IO(34), see section The Package Streams.Stream_IO(34), see section The Package Streams.Stream_IO.
End_Of_Line    section The Package Text_IO.
End_Of_Page    section The Package Text_IO.
endian
   big    section Bit Ordering.
   little    section Bit Ordering.
ENQ    section The Package Characters.Latin_1.
entity
   [partial]    section Declarations.
entry
   closed    section Entry Calls.
   open    section Entry Calls.
   single    section Entries and Accept Statements.
entry call    section Entry Calls.
   simple    section Entry Calls.
entry calling convention    section Conformance Rules.
entry family    section Entries and Accept Statements.
entry index subtype    section Record Types(18), see section Entries and Accept Statements(18), see section Entries and Accept Statements.
entry queue    section Entry Calls.
entry queuing policy    section Entry Calls.
   default policy    section Entry Calls.
entry_barrier    section Entries and Accept Statements.
   used    section Entries and Accept Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
entry_body    section Entries and Accept Statements.
   used    section Protected Units and Protected Objects(8), see section Syntax Summary (informative)(8), see section Syntax Summary (informative).
entry_body_formal_part    section Entries and Accept Statements.
   used    section Entries and Accept Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
entry_call_alternative    section Timed Entry Calls.
   used    section Timed Entry Calls(2), see section Conditional Entry Calls(2), see section Syntax Summary (informative)(2), see section Conditional Entry Calls(2), see section Syntax Summary (informative).
entry_call_statement    section Entry Calls.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Timed Entry Calls(3), see section Asynchronous Transfer of Control(4), see section Timed Entry Calls(3), see section Asynchronous Transfer of Control,
           section Syntax Summary (informative).
entry_declaration    section Entries and Accept Statements.
   used    section Task Units and Task Objects(5), see section Protected Units and Protected Objects(5), see section Syntax Summary (informative)(5), see section Protected Units and Protected Objects(5), see section Syntax Summary (informative).
entry_index    section Entries and Accept Statements.
   used    section Entries and Accept Statements(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
entry_index_specification    section Entries and Accept Statements.
   used    section Entries and Accept Statements(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
Enum    section Formal Types(13), see section The Package Text_IO(13), see section The Package Text_IO.
Enum_IO    section Generic Renaming Declarations.
enumeration literal    section Enumeration Types.
enumeration type    section Types and Subtypes(3), see section Enumeration Types(1), see section Glossary (informative)(3), see section Enumeration Types(1), see section Glossary (informative).
enumeration_aggregate    section Enumeration Representation Clauses.
   used    section Enumeration Representation Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
enumeration_literal_specification    section Enumeration Types.
   used    section Enumeration Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
enumeration_representation_clause    section Enumeration Representation Clauses.
   used    section Representation Items(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
enumeration_type_definition    section Enumeration Types.
   used    section Type Declarations(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Enumeration_IO    section The Package Text_IO.
environment declarative_part    section The Compilation Process.
   for the environment task of a partition    section Program Execution.
environment    section The Compilation Process.
environment task    section Program Execution.
EOF    section Exception Renaming Declarations.
EOT    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
EPA    section The Package Characters.Latin_1.
epoch    section Monotonic Time.
equal operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
equality operator    section Relational Operators and Membership Tests.
   special inheritance rule for tagged types    section Derived Types and Classes,
                                                section Relational Operators and Membership Tests.
equals sign    section Character Set.
Equals_Sign    section The Package Characters.Latin_1.
erroneous execution    section Structure(32),   section Classification of Errors(32),   section Classification of Errors,
                       section Operations of Discriminated Types(4),    section Abort of a Task - Abort of a Sequence of Statements(4),    section Abort of a Task - Abort of a Sequence of Statements,
                       section Shared Variables(11),    section Suppressing Checks(11),    section Suppressing Checks,
                       section Representation Attributes(13),    section Representation Attributes(13),    section Representation Attributes,
                       section Data Validity(8),   section Data Validity(8),   section Data Validity,
                       section Storage Management(21),   section Unchecked Storage Deallocation(21),   section Unchecked Storage Deallocation,
                       section Default Input, Output, and Error Files(22), see section Exceptions in Input-Output(22), see section Exceptions in Input-Output,
                       section The Package Interfaces.C.Strings(51),   section The Generic Package Interfaces.C.Pointers(51),   section The Generic Package Interfaces.C.Pointers,
                       section Protected Procedure Handlers(14),   section The Package Task_Identification(14),   section The Package Task_Identification,
                       section The Package Task_Attributes(14),   section Dynamic Priorities(14),   section Dynamic Priorities,
                       section Asynchronous Task Control(9),     section Safety and Security Restrictions(9),     section Safety and Security Restrictions.
error    section Exception Declarations.
   compile-time    section Structure(27), see section Classification of Errors(27), see section Classification of Errors.
   link-time    section Structure(29), see section Classification of Errors(29), see section Classification of Errors.
   run-time    section Structure(30), see section Classification of Errors(6), see section Suppressing Checks(30), see section Classification of Errors(6), see section Suppressing Checks,
               section Exceptions and Optimization.
   See also   bounded error, erroneous execution
ESA    section The Package Characters.Latin_1.
ESC    section The Package Characters.Latin_1.
Establish_RPC_Receiver    section Partition Communication Subsystem.
ETB    section The Package Characters.Latin_1.
ETX    section The Package Characters.Latin_1.
evaluation    section Declarations(11), see section Glossary (informative)(11), see section Glossary (informative).
   aggregate    section Aggregates.
   allocator    section Allocators.
   array_aggregate    section Array Aggregates.
   attribute_reference    section Attributes.
   concatenation    section Binary Adding Operators.
   dereference    section Names.
   discrete_range    section Index Constraints and Discrete Ranges.
   extension_aggregate    section Extension Aggregates.
   generic_association    section Generic Instantiation.
   generic_association for a formal object of mode in
         section Formal Objects.
   indexed_component    section Indexed Components.
   initialized allocator    section Allocators.
   membership test    section Relational Operators and Membership Tests.
   name    section Names.
   name that has a prefix    section Names.
   null literal    section Literals.
   numeric literal    section Literals.
   parameter_association    section Parameter Associations.
   prefix    section Names.
   primary that is a name    section Expressions.
   qualified_expression    section Qualified Expressions.
   range    section Scalar Types.
   range_attribute_reference    section Attributes.
   record_aggregate    section Record Aggregates.
   record_component_association_list    section Record Aggregates.
   selected_component    section Selected Components.
   short-circuit control form    section Logical Operators and Short-circuit Control Forms.
   slice    section Slices.
   string_literal    section Literals.
   uninitialized allocator    section Allocators.
   Val    section Operations of Discrete Types(7), see section Language-Defined Attributes (informative)(7), see section Language-Defined Attributes (informative).
   Value    section Scalar Types.
   value conversion    section Type Conversions.
   view conversion    section Type Conversions.
   Wide_Value    section Scalar Types.
Exception    section Exceptions(1), see section Exception Declarations(1), see section Glossary (informative)(1), see section Exception Declarations(1), see section Glossary (informative).
exception occurrence    section Exceptions.
exception_choice    section Exception Handlers.
   used    section Exception Handlers(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
exception_declaration    section Exception Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
exception_handler    section Exception Handlers.
   used    section Exception Handlers(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Exception_Identity    section The Package Exceptions.
Exception_Information    section The Package Exceptions.
Exception_Message    section The Package Exceptions.
Exception_Name    section The Package Exceptions(2), see section The Package Exceptions(2), see section The Package Exceptions.
Exception_Occurrence    section The Package Exceptions.
Exception_Occurrence_Access    section The Package Exceptions.
exception_renaming_declaration    section Exception Renaming Declarations.
   used    section Renaming Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Exception_Id    section The Package Exceptions.
Exceptions
   child of Ada    section The Package Exceptions.
Exchange    section Generic Declarations(21), see section Generic Bodies(21), see section Generic Bodies.
Exchange_Handler    section The Package Interrupts.
Exclam    section ASCII.
Exclamation    section The Package Characters.Latin_1.
execution    section Declarations(11), see section Glossary (informative)(11), see section Glossary (informative).
   abort_statement    section Abort of a Task - Abort of a Sequence of Statements.
   aborting the execution of a construct    section Abort of a Task - Abort of a Sequence of Statements.
   accept_statement    section Entries and Accept Statements.
   Ada program    section Tasks and Synchronization.
   assignment_statement    section Assignment Statements(7), see section User-Defined Assignment and Finalization(7), see section User-Defined Assignment and Finalization,
                           section Completion and Finalization.
   asynchronous_select with a delay_statement trigger
         section Asynchronous Transfer of Control.
   asynchronous_select with an entry call trigger    section Asynchronous Transfer of Control.
   block_statement    section Block Statements.
   call on a dispatching operation    section Dispatching Operations of Tagged Types.
   call on an inherited subprogram    section Derived Types and Classes.
   case_statement    section Case Statements.
   conditional_entry_call    section Conditional Entry Calls.
   delay_statement    section Delay Statements, Duration, and Time.
   dynamically enclosing    section Exception Handling.
   entry_body    section Entries and Accept Statements.
   entry_call_statement    section Entry Calls.
   exit_statement    section Exit Statements.
   goto_statement    section Goto Statements.
   handled_sequence_of_statements    section Exception Handlers.
   handler    section Exception Handling.
   if_statement    section If Statements.
   instance of Unchecked_Deallocation    section Completion and Finalization.
   loop_statement    section Loop Statements.
   loop_statement with a for iteration_scheme    section Loop Statements.
   loop_statement with a while iteration_scheme    section Loop Statements.
   null_statement    section Simple and Compound Statements - Sequences of Statements.
   partition    section Program Execution.
   pragma    section Pragmas.
   program    section Program Execution.
   protected subprogram call    section Protected Subprograms and Protected Actions.
   raise_statement with an exception_name    section Raise Statements.
   re-raise statement    section Raise Statements.
   remote subprogram call    section Remote Subprogram Calls.
   requeue protected entry    section Requeue Statements.
   requeue task entry    section Requeue Statements.
   requeue_statement    section Requeue Statements.
   return_statement    section Return Statements.
   selective_accept    section Selective Accept.
   sequence_of_statements    section Simple and Compound Statements - Sequences of Statements.
   subprogram call    section Subprogram Calls.
   subprogram_body    section Subprogram Bodies.
   task    section Task Execution - Task Activation.
   task_body    section Task Execution - Task Activation.
   timed_entry_call    section Timed Entry Calls.
execution resource
   associated with a protected object    section Protected Units and Protected Objects.
   required for a task to run    section Tasks and Synchronization.
exit_statement    section Exit Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Exp    section Elementary Functions(4), see section Interfacing Pragmas(51), see section Complex Elementary Functions(4), see section Interfacing Pragmas(51), see section Complex Elementary Functions.
expanded name    section Selected Components.
Expanded_Name    section Tagged Types and Type Extensions.
expected profile    section The Context of Overload Resolution.
   accept_statement entry_direct_name    section Entries and Accept Statements.
   Access attribute_reference prefix    section Operations of Access Types.
   attribute_definition_clause name    section Representation Attributes.
   character_literal    section Literals.
   formal subprogram actual    section Formal Subprograms.
   formal subprogram default_name    section Formal Subprograms.
   subprogram_renaming_declaration    section Subprogram Renaming Declarations.
expected type    section The Context of Overload Resolution.
   abort_statement task_name    section Abort of a Task - Abort of a Sequence of Statements.
   access attribute_reference    section Operations of Access Types.
   actual parameter    section Parameter Associations.
   aggregate    section Aggregates.
   allocator    section Allocators.
   array_aggregate    section Array Aggregates.
   array_aggregate component expression    section Array Aggregates.
   array_aggregate discrete_choice    section Array Aggregates.
   assignment_statement expression    section Assignment Statements.
   assignment_statement variable_name    section Assignment Statements.
   attribute_definition_clause expression or name    section Representation Attributes.
   attribute_designator expression    section Attributes.
   case expression    section Case Statements.
   case_statement_alternative discrete_choice    section Case Statements.
   character_literal    section Literals.
   code_statement    section Machine Code Insertions.
   component_clause expressions    section Record Representation Clauses.
   component_declaration default_expression    section Record Types.
   condition    section If Statements.
   decimal fixed point type digits    section Fixed Point Types.
   delay_relative_statement expression    section Delay Statements, Duration, and Time.
   delay_until_statement expression    section Delay Statements, Duration, and Time.
   delta_constraint expression    section Reduced Accuracy Subtypes.
   dereference name    section Names.
   discrete_subtype_definition range    section Array Types.
   discriminant default_expression    section Discriminants.
   discriminant_association expression    section Discriminant Constraints.
   entry_index    section Entries and Accept Statements.
   enumeration_representation_clause expressions    section Enumeration Representation Clauses.
   extension_aggregate    section Extension Aggregates.
   extension_aggregate ancestor expression    section Extension Aggregates.
   first_bit    section Record Representation Clauses.
   fixed point type delta    section Fixed Point Types.
   generic formal in object actual    section Formal Objects.
   generic formal object default_expression    section Formal Objects.
   index_constraint discrete_range    section Index Constraints and Discrete Ranges.
   indexed_component expression    section Indexed Components.
   Interrupt_Priority pragma argument    section Task Priorities.
   last_bit    section Record Representation Clauses.
   link name    section Interfacing Pragmas.
   membership test simple_expression    section Relational Operators and Membership Tests.
   modular_type_definition expression    section Integer Types.
   null literal    section Literals.
   number_declaration expression    section Number Declarations.
   object_declaration initialization expression    section Object Declarations.
   parameter default_expression    section Subprogram Declarations.
   position    section Record Representation Clauses.
   Priority pragma argument    section Task Priorities.
   range simple_expressions    section Scalar Types.
   range_attribute_designator expression    section Attributes.
   range_constraint range    section Scalar Types.
   real_range_specification bounds    section Floating Point Types.
   record_aggregate    section Record Aggregates.
   record_component_association expression    section Record Aggregates.
   requested decimal precision    section Floating Point Types.
   restriction parameter expression    section Pragma Restrictions.
   return expression    section Return Statements.
   short-circuit control form relation    section Logical Operators and Short-circuit Control Forms.
   signed_integer_type_definition simple_expression
         section Integer Types.
   slice discrete_range    section Slices.
   Storage_Size pragma argument    section Representation Attributes.
   string_literal    section Literals.
   type_conversion operand section Type Conversions(6)
   variant_part discrete_choice    section Variant Parts and Discrete Choices.
expiration time
   [partial]    section Delay Statements, Duration, and Time.
   for a delay_relative_statement    section Delay Statements, Duration, and Time.
   for a delay_until_statement    section Delay Statements, Duration, and Time.
explicit declaration    section Declarations(5), see section Glossary (informative)(5), see section Glossary (informative).
explicit initial value    section Object Declarations.
explicit_actual_parameter    section Subprogram Calls.
   used    section Subprogram Calls(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
explicit_dereference    section Names.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
explicit_generic_actual_parameter    section Generic Instantiation.
   used    section Generic Instantiation(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
explicitly assign    section Program Execution.
exponent    section Decimal Literals(4), see section Highest Precedence Operators(4), see section Highest Precedence Operators.
   used    section Decimal Literals(2), see section Based Literals(2), see section Syntax Summary (informative)(2), see section Based Literals(2), see section Syntax Summary (informative).
Exponent attribute    section Attributes of Floating Point Types(18), see section Language-Defined Attributes (informative)(18), see section Language-Defined Attributes (informative).
exponentiation operator    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
Export pragma    section Interfacing Pragmas(6), see section Language-Defined Pragmas (informative)(6), see section Language-Defined Pragmas (informative).
exported
   aspect of representation    section Interfacing Pragmas.
exported entity    section Interfacing Pragmas.
Expr_Ptr    section Type Extensions.
expression    section Tagged Types and Type Extensions(33), see section Expressions(1), see section Expressions(33), see section Expressions(1), see section Expressions.
   used    section Pragmas(3),    section Object Declarations(2), see section Number Declarations(3),    section Object Declarations(2), see section Number Declarations,
           section Integer Types(4), see section Floating Point Types(2), see section Fixed Point Types(4), see section Floating Point Types(2), see section Fixed Point Types,
           section Fixed Point Types(4), see section Fixed Point Types(5), see section Discriminants(4), see section Fixed Point Types(5), see section Discriminants,
           section Discriminant Constraints(3), see section Variant Parts and Discrete Choices(5), see section Indexed Components(3), see section Variant Parts and Discrete Choices(5), see section Indexed Components,
           section Attributes(3), see section Attributes(5), see section Record Aggregates(3), see section Attributes(5), see section Record Aggregates,
           section Extension Aggregates(3), see section Array Aggregates(3), see section Array Aggregates(3), see section Array Aggregates(3), see section Array Aggregates,
           section Expressions(7),    section Type Conversions(2),    section Qualified Expressions(7),    section Type Conversions(2),    section Qualified Expressions,
           section Assignment Statements(2),    section If Statements(3),    section Case Statements(2),    section If Statements(3),    section Case Statements,
           section Subprogram Calls(6),    section Return Statements(2),    section Entries and Accept Statements(6),    section Return Statements(2),    section Entries and Accept Statements,
           section Delay Statements, Duration, and Time(3),    section Delay Statements, Duration, and Time(4),    section Generic Instantiation(3),    section Delay Statements, Duration, and Time(4),    section Generic Instantiation,
           section Representation Attributes(2),   section Representation Attributes(63), see section Record Representation Clauses(2),   section Representation Attributes(63), see section Record Representation Clauses,
           section Pragma Restrictions(4), see section Interfacing Pragmas(5),    section Interfacing Pragmas(4), see section Interfacing Pragmas(5),    section Interfacing Pragmas,
           section Interfacing Pragmas(8),    section Interfacing Pragmas(10),   section Protected Procedure Handlers(8),    section Interfacing Pragmas(10),   section Protected Procedure Handlers,
           section Task Priorities(3),    section Task Priorities(5),    section Reduced Accuracy Subtypes(3),    section Task Priorities(5),    section Reduced Accuracy Subtypes,
           section At Clauses(1),    section Mod Clauses(1),    section Language-Defined Pragmas (informative)(1),    section Mod Clauses(1),    section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(13),     section Language-Defined Pragmas (informative)(14),     section Language-Defined Pragmas (informative)(13),     section Language-Defined Pragmas (informative)(14),     section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(19),     section Language-Defined Pragmas (informative)(27),     section Language-Defined Pragmas (informative)(19),     section Language-Defined Pragmas (informative)(27),     section Language-Defined Pragmas (informative),
           section Syntax Summary (informative).
extended_digit    section Based Literals.
   used    section Based Literals(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
extension
   of a private type    section Tagged Types and Type Extensions(2), see section Type Extensions(2), see section Type Extensions.
   of a record type    section Tagged Types and Type Extensions(2), see section Type Extensions(2), see section Type Extensions.
   of a type    section Tagged Types and Type Extensions(2), see section Type Extensions(2), see section Type Extensions.
extension_aggregate    section Extension Aggregates.
   used    section Aggregates(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
external call    section Intertask Communication.
external effect
   of the execution of an Ada program    section Conformity of an Implementation with the Standard.
   volatile/atomic objects    section Shared Variable Control.
external file    section External Files and File Objects.
external interaction    section Conformity of an Implementation with the Standard.
external name    section Interfacing Pragmas.
external requeue    section Intertask Communication.
External_Tag    section Tagged Types and Type Extensions.
External_Tag attribute    section Representation Attributes(75), see section Language-Defined Attributes (informative)(75), see section Language-Defined Attributes (informative).
External_Tag clause    section Representation Attributes(7), see section Representation Attributes(75), see section Language-Defined Attributes (informative)(7), see section Representation Attributes(75), see section Language-Defined Attributes (informative).
extra permission to avoid raising exceptions    section Exceptions and Optimization.
extra permission to reorder actions    section Exceptions and Optimization.

index

factor    section Expressions.
   used    section Expressions(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
failure    section The Package Command_Line.
   of a language-defined check    section Suppressing Checks.
False    section Boolean Types.
family
   entry    section Entries and Accept Statements.
Feminine_Ordinal_Indicator    section The Package Characters.Latin_1.
FF    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
Field    section The Package Text_IO.
file
   as file object    section External Files and File Objects.
file terminator    section Text Input-Output.
File_Access    section The Package Text_IO.
File_Descriptor    section Limited Types.
File_Handle    section Example of Exception Handling.
File_Mode    section The Generic Package Sequential_IO(4), see section The Generic Package Direct_IO(4), see section The Package Text_IO(4), see section The Generic Package Direct_IO(4), see section The Package Text_IO,
             section The Package Streams.Stream_IO.
File_Name    section Private Types and Private Extensions(22), see section Limited Types(18), see section Limited Types(22), see section Limited Types(18), see section Limited Types.
File_Not_Found    section Example of Exception Handling.
File_System    section Example of Exception Handling(2), see section Example of Exception Handling(2), see section Example of Exception Handling.
File_Type    section The Generic Package Sequential_IO(3), see section The Generic Package Direct_IO(3), see section The Package Text_IO(3), see section The Generic Package Direct_IO(3), see section The Package Text_IO,
             section The Package Streams.Stream_IO.
Finalization
   child of Ada    section User-Defined Assignment and Finalization.
   of a master    section Completion and Finalization.
   of a protected object    section Protected Units and Protected Objects(20), see section Protected Procedure Handlers(20), see section Protected Procedure Handlers.
   of a task object    section Interrupt Entries.
   of an object    section Completion and Finalization.
Finalize    section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(6), see section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(6), see section User-Defined Assignment and Finalization.
Find    section Example of Use of a Remote Access-to-Class-Wide Type.
Find_Token    section Fixed-Length String Handling(16), see section Bounded-Length String Handling(51), see section Unbounded-Length String Handling(16), see section Bounded-Length String Handling(51), see section Unbounded-Length String Handling.
Fine_Delta    section The Package System.
   named number in package System    section The Package System.
First attribute    section Scalar Types(12), see section Operations of Array Types(3), see section Language-Defined Attributes (informative)(12), see section Operations of Array Types(3), see section Language-Defined Attributes (informative),
                   section Language-Defined Attributes (informative).
first subtype    section Type Declarations(6), see section Derivation Classes(6), see section Derivation Classes.
First(N) attribute    section Operations of Array Types(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
first_bit    section Record Representation Clauses.
   used    section Record Representation Clauses(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
First_Bit attribute    section Storage Place Attributes(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
Fixed
   child of Ada.Strings    section Fixed-Length String Handling.
fixed point type    section Fixed Point Types.
fixed_point_definition    section Fixed Point Types.
   used    section Real Types, P(1)
Fixed_IO    section The Package Text_IO.
Flip_A_Coin section Random Number Generation(58)
Float    section Floating Point Types(12), see section Floating Point Types(14), see section The Package Standard(12), see section Floating Point Types(14), see section The Package Standard.
Float_Random
   child of Ada.Numerics    section Random Number Generation.
Float_Text_IO
   child of Ada    section Input-Output for Real Types.
Float_Type    section Elementary Functions.
Float_Wide_Text_IO
   child of Ada    section Wide Text Input-Output.
Float_IO    section The Package Text_IO.
Floating    section Interfacing with COBOL.
floating point type    section Floating Point Types.
floating_point_definition    section Floating Point Types.
   used    section Real Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Floor attribute    section Attributes of Floating Point Types(30), see section Language-Defined Attributes (informative)(30), see section Language-Defined Attributes (informative).
Flush    section The Package Text_IO(21), see section The Package Streams.Stream_IO(21), see section The Package Streams.Stream_IO.
Fore attribute    section Operations of Fixed Point Types(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
form    section The Generic Package Sequential_IO(9), see section The Generic Package Direct_IO(9), see section The Package Text_IO(9), see section The Generic Package Direct_IO(9), see section The Package Text_IO,
        section The Package Streams.Stream_IO.
   of an external file    section External Files and File Objects.
formal object, generic    section Formal Objects.
formal package, generic    section Formal Packages.
formal parameter
   of a subprogram    section Subprogram Declarations.
formal subprogram, generic    section Formal Subprograms.
formal subtype    section Formal Types.
formal type    section Formal Types.
formal_access_type_definition    section Formal Access Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_array_type_definition    section Formal Array Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_decimal_fixed_point_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_derived_type_definition    section Formal Private and Derived Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_discrete_type_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_floating_point_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_modular_type_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_object_declaration    section Formal Objects.
   used    section Generic Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
formal_ordinary_fixed_point_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_package_actual_part    section Formal Packages.
   used    section Formal Packages(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
formal_package_declaration    section Formal Packages.
   used    section Generic Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
formal_part    section Subprogram Declarations.
   used    section Subprogram Declarations(12), see section Subprogram Declarations(13), see section Syntax Summary (informative)(12), see section Subprogram Declarations(13), see section Syntax Summary (informative).
formal_private_type_definition    section Formal Private and Derived Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_signed_integer_type_definition    section Formal Scalar Types.
   used    section Formal Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
formal_subprogram_declaration    section Formal Subprograms.
   used    section Generic Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
formal_type_declaration    section Formal Types.
   used    section Generic Declarations(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
formal_type_definition    section Formal Types.
   used    section Formal Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
format_effector    section Character Set.
   used    section Character Set(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Fortran
   child of Interfaces    section Interfacing with Fortran.
Fortran interface    section Interfacing with Fortran.
FORTRAN standard    section Normative References.
Fortran_Character    section Interfacing with Fortran.
Fortran_Integer    section Interfacing with Fortran.
Fortran_Library    section Interfacing Pragmas.
Fortran_Matrix    section Interfacing with Fortran.
Fraction    section Fixed Point Types.
Fraction attribute    section Attributes of Floating Point Types(21), see section Language-Defined Attributes (informative)(21), see section Language-Defined Attributes (informative).
Fraction_One_Half    section The Package Characters.Latin_1.
Fraction_One_Quarter    section The Package Characters.Latin_1.
Fraction_Three_Quarters    section The Package Characters.Latin_1.
Free    section Unchecked Storage Deallocation(5), see section Unbounded-Length String Handling(7), see section The Package Interfaces.C.Strings(5), see section Unbounded-Length String Handling(7), see section The Package Interfaces.C.Strings.
freed
   See nonexistent    section Unchecked Storage Deallocation.
freeing storage    section Unchecked Storage Deallocation.
freezing
   by a constituent of a construct    section Freezing Rules.
   by an expression    section Freezing Rules.
   class-wide type caused by the freezing of the specific type
         section Freezing Rules.
   constituents of a full type definition    section Freezing Rules.
   designated subtype caused by an allocator    section Freezing Rules.
   entity    section Freezing Rules.
   entity caused by a body    section Freezing Rules.
   entity caused by a construct    section Freezing Rules.
   entity caused by a name    section Freezing Rules.
   entity caused by the end of an enclosing construct
         section Freezing Rules.
   first subtype caused by the freezing of the type
         section Freezing Rules.
   function call    section Freezing Rules.
   generic_instantiation    section Freezing Rules.
   nominal subtype caused by a name    section Freezing Rules.
   object_declaration    section Freezing Rules.
   specific type caused by the freezing of the class-wide type
         section Freezing Rules.
   subtype caused by a record extension    section Freezing Rules.
   subtypes of the profile of a callable entity    section Freezing Rules.
   type caused by a range    section Freezing Rules.
   type caused by an expression    section Freezing Rules.
   type caused by the freezing of a subtype    section Freezing Rules.
freezing points
   entity    section Freezing Rules.
FS    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
full conformance
   for discrete_subtype_definitions    section Conformance Rules.
   for known_discriminant_parts    section Conformance Rules.
   for expressions    section Conformance Rules.
   for profiles    section Conformance Rules.
   required    section Incomplete Type Declarations(4), see section Subprogram Bodies(4),      section Private Types and Private Extensions(4), see section Subprogram Bodies(4),      section Private Types and Private Extensions,
               section Subprogram Renaming Declarations(5),   section Entries and Accept Statements(14),   section Entries and Accept Statements(5),   section Entries and Accept Statements(14),   section Entries and Accept Statements,
               section Entries and Accept Statements(17), see section Subunits of Compilation Units(11), see section Subunits of Compilation Units(17), see section Subunits of Compilation Units(11), see section Subunits of Compilation Units.
full constant declaration    section Object Declarations.
full declaration    section Deferred Constants.
full stop    section Character Set.
full type    section Type Declarations.
full type definition    section Type Declarations.
full view
   of a type    section Private Types and Private Extensions.
Full_Stop    section The Package Characters.Latin_1.
full_type_declaration    section Type Declarations.
   used    section Type Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
function    section Subprograms.
function instance    section Generic Instantiation.
function_call    section Subprogram Calls.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).

index

gaps    section Representation Items.
garbage collection    section Pragma Controlled.
Gender    section Enumeration Types.
general access type    section Access Types(7), see section Access Types(7), see section Access Types.
general_access_modifier    section Access Types.
   used    section Access Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
generation
   of an interrupt    section Interrupt Support.
Generator    section Random Number Generation(7), see section Random Number Generation(7), see section Random Number Generation.
generic actual    section Generic Instantiation.
generic actual parameter    section Generic Instantiation.
generic actual subtype    section Formal Types.
generic actual type    section Formal Types.
generic body    section Generic Bodies.
generic contract issue    section Elaboration Control.
   [partial]    section Type Extensions(3),    section Operations of Access Types(3),    section Operations of Access Types,
                section Operations of Access Types(32), see section Type Conversions(32), see section Type Conversions,
                section Type Conversions(20),     section Visibility(20),     section Visibility,
                section Elaboration Control.
generic formal    section Generic Declarations.
generic formal object    section Formal Objects.
generic formal package    section Formal Packages.
generic formal subprogram    section Formal Subprograms.
generic formal subtype    section Formal Types.
generic formal type    section Formal Types.
generic function    section Generic Declarations.
generic package    section Generic Declarations.
generic procedure    section Generic Declarations.
generic subprogram    section Generic Declarations.
generic unit    section Generic Units(1), see section Glossary (informative)(1), see section Glossary (informative).
   See also dispatching operation    section Tagged Types and Type Extensions.
generic_actual_part    section Generic Instantiation.
   used    section Generic Instantiation(2), see section Formal Packages(3), see section Syntax Summary (informative)(2), see section Formal Packages(3), see section Syntax Summary (informative).
generic_association    section Generic Instantiation.
   used    section Generic Instantiation(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Generic_Bounded_Length    section Bounded-Length String Handling.
Generic_Complex_Elementary_Functions
   child of Ada.Numerics    section Complex Elementary Functions.
Generic_Complex_Types
   child of Ada.Numerics    section Complex Types.
generic_declaration    section Generic Declarations.
   used    section Declarations(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative)(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative).
Generic_Elementary_Functions
   child of Ada.Numerics    section Elementary Functions.
generic_formal_parameter_declaration    section Generic Declarations.
   used    section Generic Declarations(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
generic_formal_part    section Generic Declarations.
   used    section Generic Declarations(3), see section Generic Declarations(4), see section Syntax Summary (informative)(3), see section Generic Declarations(4), see section Syntax Summary (informative).
generic_instantiation    section Generic Instantiation.
   used    section Declarations(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative)(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative).
generic_package_declaration    section Generic Declarations.
   used    section Generic Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
generic_renaming_declaration    section Generic Renaming Declarations.
   used    section Renaming Declarations(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative)(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative).
generic_subprogram_declaration    section Generic Declarations.
   used    section Generic Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Get    section Compilation Units - Library Units(30), see section The Package Text_IO(41), see section The Package Text_IO(30), see section The Package Text_IO(41), see section The Package Text_IO,
       section The Package Text_IO(54), see section The Package Text_IO(55), see section The Package Text_IO(54), see section The Package Text_IO(55), see section The Package Text_IO,
       section The Package Text_IO(60), see section The Package Text_IO(65), see section The Package Text_IO(60), see section The Package Text_IO(65), see section The Package Text_IO,
       section The Package Text_IO(70), see section The Package Text_IO(72), see section The Package Text_IO(70), see section The Package Text_IO(72), see section The Package Text_IO,
       section The Package Text_IO(77), see section The Package Text_IO(81), see section The Package Text_IO(77), see section The Package Text_IO(81), see section The Package Text_IO,
       section Complex Input-Output(6),    section Complex Input-Output(6),    section Complex Input-Output.
Get_Immediate    section The Package Text_IO(44), see section The Package Text_IO(44), see section The Package Text_IO.
Get_Key    section Private Operations(15), see section Private Operations(15), see section Private Operations.
Get_Line    section The Package Text_IO.
Get_Priority    section Dynamic Priorities.
Global    section Task Dependence - Termination of Tasks.
global to    section Declarative Region.
Glossary    section Glossary (informative).
goto_statement    section Goto Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
govern a variant_part    section Variant Parts and Discrete Choices.
govern a variant    section Variant Parts and Discrete Choices.
grammar
   complete listing    section Syntax Summary (informative).
   cross reference    section Syntax Summary (informative).
   notation    section Method of Description and Syntax Notation.
   resolution of ambiguity    section The Context of Overload Resolution.
   under Syntax heading    section Structure.
graphic character
   a category of Character    section The Package Characters.Handling.
graphic_character    section Character Set.
   used    section Character Set(2), see section Character Literals(2), see section String Literals(3), see section Syntax Summary (informative)(2), see section Character Literals(2), see section String Literals(3), see section Syntax Summary (informative).
Graphic_Set    section String-Handling Sets and Mappings.
greater than operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
greater than or equal operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
greater-than sign    section Character Set.
Greater_Than_Sign    section The Package Characters.Latin_1.
GS    section The Package Characters.Latin_1.
guard    section Selective Accept.
   used    section Selective Accept(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).

index

Half_Pi    section Static Expressions and Static Subtypes.
handle
   an exception    section Exceptions(1), see section Glossary (informative)(1), see section Glossary (informative).
   an exception occurrence    section Exception Handling(1), see section Exception Handling(1), see section Exception Handling.
handled_sequence_of_statements    section Exception Handlers.
   used    section Block Statements(2), see section Subprogram Bodies(2),    section Package Bodies(2), see section Subprogram Bodies(2),    section Package Bodies,
           section Task Units and Task Objects(6), see section Entries and Accept Statements(3), see section Entries and Accept Statements(6), see section Entries and Accept Statements(3), see section Entries and Accept Statements,
           section Syntax Summary (informative).
Handler    section The Package Interrupts.
Handling
   child of Ada.Characters    section The Package Characters.Handling.
Hash_Index    section Integer Types.
head (of a queue)    section The Task Dispatching Model.
Head    section Fixed-Length String Handling(35), see section Fixed-Length String Handling(36), see section Bounded-Length String Handling(35), see section Fixed-Length String Handling(36), see section Bounded-Length String Handling,
        section Bounded-Length String Handling(71), see section Unbounded-Length String Handling(65), see section Unbounded-Length String Handling(71), see section Unbounded-Length String Handling(65), see section Unbounded-Length String Handling.
heap management
   See also alligator    section Allocators.
   user-defined    section Storage Management.
held priority    section Asynchronous Task Control.
Hello    section Object Declarations.
heterogeneous input-output    section The Package Streams.Stream_IO.
Hexa    section Enumeration Types.
hexadecimal
   literal    section Based Literals.
hexadecimal digit
   a category of Character    section The Package Characters.Handling.
hexadecimal literal    section Based Literals.
Hexadecimal_Digit_Set    section String-Handling Sets and Mappings.
hidden from all visibility    section Visibility(5), see section Visibility(5), see section Visibility.
   by lack of a with_clause    section Visibility.
   for a declaration completed by a subsequent declaration
         section Visibility.
   for overridden declaration    section Visibility.
   within the declaration itself    section Visibility.
hidden from direct visibility    section Visibility(5), see section Visibility(5), see section Visibility.
   by an inner homograph    section Visibility.
   where hidden from all visibility    section Visibility.
hiding    section Visibility.
High_Order_First    section Bit Ordering(2), see section Interfacing with COBOL(2), see section Interfacing with COBOL.
highest precedence operator    section Highest Precedence Operators.
highest_precedence_operator    section Operators and Expression Evaluation.
Hold    section Asynchronous Task Control.
homograph    section Visibility.
HT    section The Package Characters.Latin_1.
HTJ    section The Package Characters.Latin_1.
HTS    section The Package Characters.Latin_1.
Hyphen    section The Package Characters.Latin_1.
hyphen-minus    section Character Set.

index

i    section Complex Types(5), see section Complex Types(5), see section Complex Types.
identifier    section Identifiers.
   used    section Pragmas(2),    section Pragmas(3),    section Pragmas(2),    section Pragmas(3),    section Pragmas,
           section Pragmas(23),   section Declarations(4),    section Names(23),   section Declarations(4),    section Names,
           section Selected Components(3), see section Attributes(3), see section Loop Statements(3), see section Attributes(3), see section Loop Statements,
           section Block Statements(2),    section Subprogram Declarations(5),    section Package Specifications and Declarations(2),    section Subprogram Declarations(5),    section Package Specifications and Declarations,
           section Package Bodies(2),    section Task Units and Task Objects(4),    section Task Units and Task Objects(2),    section Task Units and Task Objects(4),    section Task Units and Task Objects,
           section Protected Units and Protected Objects(4),    section Protected Units and Protected Objects(7),    section Entries and Accept Statements(4),    section Protected Units and Protected Objects(7),    section Entries and Accept Statements,
           section Entries and Accept Statements(5), see section Suppressing Checks(4),   section Pragma Restrictions(5), see section Suppressing Checks(4),   section Pragma Restrictions,
           section Interfacing Pragmas(5),    section Interfacing Pragmas(6),    section Interfacing Pragmas(5),    section Interfacing Pragmas(6),    section Interfacing Pragmas,
           section The Standard Task Dispatching Policy(2), see section The Standard Task Dispatching Policy(3), see section Priority Ceiling Locking(2), see section The Standard Task Dispatching Policy(3), see section Priority Ceiling Locking,
           section Priority Ceiling Locking(4),    section Entry Queuing Policies(3),    section Entry Queuing Policies(4),    section Entry Queuing Policies(3),    section Entry Queuing Policies,
           section Language-Defined Pragmas (informative)(8),      section Language-Defined Pragmas (informative)(13),     section Language-Defined Pragmas (informative)(8),      section Language-Defined Pragmas (informative)(13),     section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(20),     section Language-Defined Pragmas (informative)(21),     section Language-Defined Pragmas (informative)(20),     section Language-Defined Pragmas (informative)(21),     section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(29),     section Language-Defined Pragmas (informative)(36),     section Language-Defined Pragmas (informative)(29),     section Language-Defined Pragmas (informative)(36),     section Language-Defined Pragmas (informative),
           section Implementation-Defined Characteristics (informative)(95),     section Implementation-Defined Characteristics (informative)(98),     section Syntax Summary (informative)(95),     section Implementation-Defined Characteristics (informative)(98),     section Syntax Summary (informative).
identifier specific to a pragma    section Pragmas.
identifier_letter    section Character Set.
   used    section Character Set(3), see section Identifiers(2), see section Identifiers(3), see section Syntax Summary (informative)(3), see section Identifiers(2), see section Identifiers(3), see section Syntax Summary (informative).
Identity    section The Package Strings.Maps(22), see section Wide_String Handling(22), see section Wide_String Handling.
Identity attribute    section The Package Exceptions(9), see section The Package Task_Identification(9), see section The Package Task_Identification,
                      section Language-Defined Attributes (informative)(84),      section Language-Defined Attributes (informative)(84),      section Language-Defined Attributes (informative).
idle task    section Asynchronous Task Control.
if_statement    section If Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
illegal
   construct    section Structure.
   partition    section Structure.
Im    section Complex Types.
image    section Random Number Generation(14), see section Random Number Generation(26), see section The Package Task_Identification(14), see section Random Number Generation(26), see section The Package Task_Identification,
         section The Package Text_IO.Editing.
   of a value    section Scalar Types(30), see section Language-Defined Attributes (informative)(30), see section Language-Defined Attributes (informative).
Image attribute    section Scalar Types(35), see section Language-Defined Attributes (informative)(35), see section Language-Defined Attributes (informative).
Imaginary    section Interfacing with Fortran(10), see section Complex Types(4), see section Complex Types(10), see section Complex Types(4), see section Complex Types.
immediate scope
   of (a view of) an entity    section Scope of Declarations.
   of a declaration    section Scope of Declarations.
immediately enclosing    section Declarative Region.
immediately visible    section Visibility(4), see section Visibility(4), see section Visibility.
immediately within section Declarative Region(13)
implementation advice    section Structure.
implementation defined    section Conformity of an Implementation with the Standard.
   summary of characteristics    section Implementation-Defined Characteristics (informative).
implementation permissions    section Structure.
implementation requirements    section Structure.
implementation-dependent
   See unspecified    section Conformity of an Implementation with the Standard.
implicit declaration    section Declarations(5), see section Glossary (informative)(5), see section Glossary (informative).
implicit initial values
   for a subtype    section Object Declarations.
implicit subtype conversion    section Type Conversions(59), see section Type Conversions(59), see section Type Conversions.
   Access attribute    section Operations of Access Types.
   access discriminant    section Discriminants.
   array bounds    section Type Conversions.
   array index    section Indexed Components.
   assignment to view conversion    section Type Conversions.
   assignment_statement    section Assignment Statements.
   bounds of a decimal fixed point type    section Fixed Point Types.
   bounds of a fixed point type    section Fixed Point Types.
   bounds of a floating point type    section Floating Point Types.
   bounds of a range    section Scalar Types(9), see section Array Types(9), see section Array Types.
   bounds of signed integer type    section Integer Types.
   choices of aggregate    section Array Aggregates.
   component defaults    section Object Declarations.
   delay expression    section Delay Statements, Duration, and Time.
   derived type discriminants    section Derived Types and Classes.
   discriminant values    section Discriminant Constraints.
   entry index    section Entries and Accept Statements.
   expressions in aggregate    section Record Aggregates.
   expressions of aggregate    section Array Aggregates.
   function return    section Return Statements.
   generic formal object of mode in section Formal Objects(11)
   inherited enumeration literal    section Derived Types and Classes.
   initialization expression    section Object Declarations.
   initialization expression of allocator    section Allocators.
   named number value    section Number Declarations.
   operand of concatenation    section Binary Adding Operators.
   parameter passing    section Parameter Associations(10), see section Parameter Associations(10), see section Parameter Associations,
                        section Parameter Associations.
   pragma Interrupt_Priority    section Task Priorities(17), see section Priority Ceiling Locking(17), see section Priority Ceiling Locking.
   pragma Priority    section Task Priorities(17), see section Priority Ceiling Locking(17), see section Priority Ceiling Locking.
   qualified_expression    section Qualified Expressions.
   reading a view conversion    section Type Conversions.
   result of inherited function    section Derived Types and Classes.
implicit_dereference    section Names.
   used    section Names(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Import pragma    section Interfacing Pragmas(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
imported
   aspect of representation    section Interfacing Pragmas.
imported entity    section Interfacing Pragmas.
in (membership test)    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
inaccessible partition    section Partitions.
inactive
   a task state    section Tasks and Synchronization.
included
   one range in another    section Scalar Types.
incomplete type    section Incomplete Type Declarations.
incomplete_type_declaration    section Incomplete Type Declarations.
   used    section Type Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Increment    section Subprogram Declarations(37), see section The Generic Package Interfaces.C.Pointers(37), see section The Generic Package Interfaces.C.Pointers.
indefinite subtype    section Objects and Named Numbers(23), see section Discriminants(23), see section Discriminants.
independent subprogram    section Exceptions and Optimization.
independently addressable    section Shared Variables.
Index    section Generic Declarations(19),   section Formal Array Types(11), see section Fixed-Length String Handling(19),   section Formal Array Types(11), see section Fixed-Length String Handling,
         section Fixed-Length String Handling(10), see section Fixed-Length String Handling(11),   section Bounded-Length String Handling(10), see section Fixed-Length String Handling(11),   section Bounded-Length String Handling,
         section Bounded-Length String Handling(45), see section Bounded-Length String Handling(46),   section Unbounded-Length String Handling(45), see section Bounded-Length String Handling(46),   section Unbounded-Length String Handling,
         section Unbounded-Length String Handling(40), see section Unbounded-Length String Handling(41),   section The Generic Package Direct_IO(40), see section Unbounded-Length String Handling(41),   section The Generic Package Direct_IO,
         section The Package Streams.Stream_IO(23), see section The Generic Package Interfaces.C.Pointers(23), see section The Generic Package Interfaces.C.Pointers.
   of an element of an open direct file    section Sequential and Direct Files.
index range    section Array Types.
index subtype    section Array Types.
index type    section Array Types.
Index_Check    section Suppressing Checks.
   [partial]    section Indexed Components(7),   section Slices(7), see section Array Aggregates(7),   section Slices(7), see section Array Aggregates,
                section Array Aggregates(30), see section Binary Adding Operators(8), see section Type Conversions(30), see section Binary Adding Operators(8), see section Type Conversions,
                section Qualified Expressions(4),     section Allocators(4),     section Allocators.
index_constraint    section Index Constraints and Discrete Ranges.
   used    section Subtype Declarations(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
Index_Non_Blank    section Fixed-Length String Handling(12), see section Bounded-Length String Handling(12), see section Bounded-Length String Handling,
                   section Unbounded-Length String Handling.
index_subtype_definition    section Array Types.
   used    section Array Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
indexed_component    section Indexed Components.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
indivisible    section Shared Variable Control.
information hiding
   See package    section Packages.
   See private types and private extensions    section Private Types and Private Extensions.
information systems    section Systems Programming (normative)(1), see section Information Systems (normative)(1), see section Information Systems (normative).
informative    section Structure.
inheritance
   See also tagged types and type extension    section Tagged Types and Type Extensions.
   See derived types and classes    section Derived Types and Classes.
inherited
   from an ancestor type    section Derivation Classes.
inherited component    section Derived Types and Classes(11), see section Derived Types and Classes(11), see section Derived Types and Classes.
inherited discriminant    section Derived Types and Classes.
inherited entry    section Derived Types and Classes.
inherited protected subprogram    section Derived Types and Classes.
inherited subprogram    section Derived Types and Classes.
initialization
   of a protected object    section Protected Units and Protected Objects(14), see section Protected Procedure Handlers(14), see section Protected Procedure Handlers,
                            section Protected Procedure Handlers.
   of a task object    section Task Units and Task Objects(12), see section Interrupt Entries(12), see section Interrupt Entries.
   of an object    section Object Declarations.
initialization expression    section Object Declarations(1), see section Object Declarations(1), see section Object Declarations.
Initialize    section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(6), see section User-Defined Assignment and Finalization(2), see section User-Defined Assignment and Finalization(6), see section User-Defined Assignment and Finalization.
Initialize_Generator    section Random Number Generation.
initialized allocator    section Allocators.
Inline pragma    section Inline Expansion of Subprograms(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Inner    section Subunits of Compilation Units(20), see section Subunits of Compilation Units(21), see section Subunits of Compilation Units(20), see section Subunits of Compilation Units(21), see section Subunits of Compilation Units,
         section Subunits of Compilation Units.
innermost dynamically enclosing    section Exception Handling.
input    section Input-Output.
Input attribute    section Stream-Oriented Attributes(22), see section Stream-Oriented Attributes(22), see section Stream-Oriented Attributes,
                   section Language-Defined Attributes (informative)(92),        section Language-Defined Attributes (informative)(92),        section Language-Defined Attributes (informative).
Input clause    section Representation Attributes(7), see section Stream-Oriented Attributes(7), see section Stream-Oriented Attributes.
input-output
   unspecified for access types    section External Files and File Objects.
Insert    section Fixed-Length String Handling(25), see section Fixed-Length String Handling(26), see section Bounded-Length String Handling(25), see section Fixed-Length String Handling(26), see section Bounded-Length String Handling,
          section Bounded-Length String Handling(61), see section Unbounded-Length String Handling(55), see section Unbounded-Length String Handling(61), see section Unbounded-Length String Handling(55), see section Unbounded-Length String Handling.
inspectable object    section Pragma Inspection_Point.
inspection point    section Pragma Inspection_Point.
Inspection_Point pragma    section Pragma Inspection_Point(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
instance
   of a generic function    section Generic Instantiation.
   of a generic package    section Generic Instantiation.
   of a generic procedure    section Generic Instantiation.
   of a generic subprogram    section Generic Instantiation.
   of a generic unit    section Generic Instantiation.
instructions for comment submission
Int    section Subtype Declarations(15), see section Formal Types(13), see section Interfacing with C(15), see section Formal Types(13), see section Interfacing with C.
Int_Plus    section Subprogram Renaming Declarations.
Int_Vectors    section Generic Instantiation.
Int_IO    section Input-Output for Integer Types.
Integer    section Integer Types(11), see section Integer Types(21), see section The Package Standard(11), see section Integer Types(21), see section The Package Standard.
integer literal    section Numeric Literals.
integer literals    section Integer Types(14), see section Integer Types(14), see section Integer Types.
integer type    section Integer Types(1), see section Glossary (informative)(1), see section Glossary (informative).
Integer_Address    section The Package System.Storage_Elements.
Integer_Text_IO
   child of Ada    section Input-Output for Integer Types.
integer_type_definition    section Integer Types.
   used    section Type Declarations(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Integer_Wide_Text_IO
   child of Ada    section Wide Text Input-Output.
Integer_IO    section The Package Text_IO.
interaction
   between tasks    section Tasks and Synchronization.
interface to assembly language    section Access to Machine Operations.
interface to C    section Interfacing with C.
interface to COBOL    section Interfacing with COBOL.
interface to Fortran    section Interfacing with Fortran.
interface to other languages    section Interface to Other Languages (normative).
Interfaces    section The Package Interfaces.
Interfaces.COBOL    section Interfacing with COBOL.
Interfaces.Fortran    section Interfacing with Fortran.
Interfaces.C    section Interfacing with C.
Interfaces.C.Pointers    section The Generic Package Interfaces.C.Pointers.
Interfaces.C.Strings    section The Package Interfaces.C.Strings.
interfacing pragma    section Interfacing Pragmas.
   Convention    section Interfacing Pragmas.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
internal call    section Intertask Communication.
internal code    section Enumeration Representation Clauses.
internal requeue    section Intertask Communication.
Internal_Tag    section Tagged Types and Type Extensions.
interpretation
   of a complete context    section The Context of Overload Resolution.
   of a constituent of a complete context    section The Context of Overload Resolution.
   overload resolution    section The Context of Overload Resolution.
interrupt    section Interrupt Support.
   example using asynchronous_select    section Asynchronous Transfer of Control,
                                        section Asynchronous Transfer of Control.
interrupt entry    section Interrupt Entries.
interrupt handler    section Interrupt Support.
Interrupt_Handler    section Interrupt Entries.
Interrupt_Handler pragma    section Protected Procedure Handlers(2), see section Language-Defined Pragmas (informative)(2), see section Language-Defined Pragmas (informative).
Interrupt_Priority    section The Package System(16), see section Task Priorities(16), see section Task Priorities.
Interrupt_Priority pragma    section Task Priorities(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
Interrupt_ID    section The Package Interrupts.
Interrupts
   child of Ada    section The Package Interrupts.
Intersection    section Abstract Types and Subprograms.
intertask communication    section Intertask Communication.
   See also task    section Tasks and Synchronization.
Intrinsic calling convention    section Conformance Rules.
invalid representation    section Data Validity.
Invert    section Interfacing with Fortran.
Inverted_Exclamation    section The Package Characters.Latin_1.
Inverted_Question    section The Package Characters.Latin_1.
IO_Exceptions    section Renamings of Ada 83 Library Units.
   child of Ada    section Exceptions in Input-Output.
IO_Package    section Limited Types(18), see section Limited Types(18), see section Limited Types.
Is_Alphanumeric    section The Package Characters.Handling.
Is_Attached    section The Package Interrupts.
Is_Basic    section The Package Characters.Handling.
Is_Callable    section The Package Task_Identification.
Is_Character    section The Package Characters.Handling.
Is_Control    section The Package Characters.Handling.
Is_Decimal_Digit    section The Package Characters.Handling.
Is_Digit    section The Package Characters.Handling.
Is_Graphic    section The Package Characters.Handling.
Is_Held    section Asynchronous Task Control.
Is_Hexadecimal_Digit    section The Package Characters.Handling.
Is_ISO_646    section The Package Characters.Handling.
Is_Letter    section The Package Characters.Handling.
Is_Lower    section The Package Characters.Handling.
Is_Open    section The Generic Package Sequential_IO(10), see section The Generic Package Direct_IO(10), see section The Package Text_IO(10), see section The Generic Package Direct_IO(10), see section The Package Text_IO,
           section The Package Streams.Stream_IO.
Is_Reserved    section The Package Interrupts.
Is_Special    section The Package Characters.Handling.
Is_String    section The Package Characters.Handling.
Is_Subset    section The Package Strings.Maps(14), see section Wide_String Handling(14), see section Wide_String Handling.
Is_Terminated    section The Package Task_Identification.
Is_Upper    section The Package Characters.Handling.
Is_In    section The Package Strings.Maps(13), see section Wide_String Handling(13), see section Wide_String Handling.
ISO 10646    section Character Types(2), see section Character Types(2), see section Character Types.
ISO 1989:1985    section Normative References.
ISO/IEC 10646-1:1993    section Normative References.
ISO/IEC 1539:1991    section Normative References.
ISO/IEC 6429:1992    section Normative References.
ISO/IEC 646:1991    section Normative References.
ISO/IEC 8859-1:1987    section Normative References.
ISO/IEC 9899:1990    section Normative References.
ISO_646    section The Package Characters.Handling.
ISO_646_Set    section String-Handling Sets and Mappings.
issue
   an entry call    section Entry Calls.
italics
   nongraphic characters    section Character Types.
   pseudo-names of anonymous types    section Type Declarations(7), see section The Package Standard(7), see section The Package Standard.
   syntax rules    section Method of Description and Syntax Notation.
   terms introduced or defined    section Definitions.
Item    section Discriminants(37),   section Generic Declarations(19), see section Generic Declarations(37),   section Generic Declarations(19), see section Generic Declarations,
        section Generic Declarations(24), see section Formal Types(12), see section Formal Array Types(24), see section Formal Types(12), see section Formal Array Types,
        section Example of a Generic Package(3),   section Example of a Generic Package(3),   section Example of a Generic Package.
Iterate    section Formal Subprograms.
iteration_scheme    section Loop Statements.
   used    section Loop Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).

index

j    section Complex Types(5), see section Complex Types(5), see section Complex Types.

index

Key    section Private Types and Private Extensions(22), see section Private Operations(22), see section Private Operations.
Key_Manager    section Private Operations(15), see section Private Operations(15), see section Private Operations.
Keyboard    section Task Units and Task Objects.
Keyboard_Driver    section Task Units and Task Objects.
Kilo    section Static Expressions and Static Subtypes.
known discriminants    section Discriminants.
known_discriminant_part    section Discriminants.
   used    section Type Declarations(3), see section Discriminants(2), see section Task Units and Task Objects(3), see section Discriminants(2), see section Task Units and Task Objects,
           section Protected Units and Protected Objects(2),    section Syntax Summary (informative)(2),    section Syntax Summary (informative).

index

L_Brace    section ASCII.
L_Bracket    section ASCII.
label    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
language
   interface to assembly    section Access to Machine Operations.
   interface to non-Ada    section Interface to Other Languages (normative).
language-defined check    section Suppressing Checks(2), see section Exceptions and Optimization(2), see section Exceptions and Optimization.
language-defined class
   [partial]    section Types and Subtypes.
   of types    section Types and Subtypes.
Language-Defined Library Units    section Predefined Language Environment (normative).
   Ada    section The Package Ada.
   Ada.Asynchronous_Task_Control    section Asynchronous Task Control.
   Ada.Calendar    section Delay Statements, Duration, and Time.
   Ada.Characters    section The Package Characters.
   Ada.Characters.Handling    section The Package Characters.Handling.
   Ada.Characters.Latin_1    section The Package Characters.Latin_1.
   Ada.Command_Line    section The Package Command_Line.
   Ada.Decimal    section The Package Decimal.
   Ada.Direct_IO    section The Generic Package Direct_IO(2), see section The Generic Package Storage_IO(2), see section The Generic Package Storage_IO.
   Ada.Dynamic_Priorities    section Dynamic Priorities.
   Ada.Exceptions    section The Package Exceptions.
   Ada.Finalization    section User-Defined Assignment and Finalization.
   Ada.Float_Text_IO    section Input-Output for Real Types.
   Ada.Float_Wide_Text_IO    section Wide Text Input-Output.
   Ada.Integer_Text_IO    section Input-Output for Integer Types.
   Ada.Integer_Wide_Text_IO    section Wide Text Input-Output.
   Ada.Interrupts    section The Package Interrupts.
   Ada.Interrupts.Names    section The Package Interrupts.
   Ada.IO_Exceptions    section Exceptions in Input-Output.
   Ada.Numerics    section The Numerics Packages.
   Ada.Numerics.Complex_Elementary_Functions    section Complex Elementary Functions.
   Ada.Numerics.Complex_Types    section Complex Types.
   Ada.Numerics.Discrete_Random    section Random Number Generation.
   Ada.Numerics.Elementary_Functions    section Elementary Functions.
   Ada.Numerics.Float_Random    section Random Number Generation.
   Ada.Numerics.Generic_Complex_Elementary_Functions
         section Complex Elementary Functions.
   Ada.Numerics.Generic_Complex_Types    section Complex Types.
   Ada.Numerics.Generic_Elementary_Functions    section Elementary Functions.
   Ada.Real_Time    section Monotonic Time.
   Ada.Sequential_IO    section The Generic Package Sequential_IO.
   Ada.Storage_IO    section The Generic Package Storage_IO.
   Ada.Streams    section The Package Streams.
   Ada.Streams.Stream_IO    section The Package Streams.Stream_IO.
   Ada.Strings    section The Package Strings.
   Ada.Strings.Bounded    section Bounded-Length String Handling.
   Ada.Strings.Fixed    section Fixed-Length String Handling.
   Ada.Strings.Maps    section The Package Strings.Maps.
   Ada.Strings.Maps.Constants    section String-Handling Sets and Mappings.
   Ada.Strings.Unbounded    section Unbounded-Length String Handling.
   Ada.Strings.Wide_Bounded    section Wide_String Handling.
   Ada.Strings.Wide_Fixed    section Wide_String Handling.
   Ada.Strings.Wide_Maps    section Wide_String Handling.
   Ada.Strings.Wide_Maps.Wide_Constants    section Wide_String Handling.
   Ada.Strings.Wide_Unbounded    section Wide_String Handling.
   Ada.Synchronous_Task_Control    section Synchronous Task Control.
   Ada.Tags    section Tagged Types and Type Extensions.
   Ada.Task_Attributes    section The Package Task_Attributes.
   Ada.Task_Identification    section The Package Task_Identification.
   Ada.Text_IO    section The Package Text_IO.
   Ada.Text_IO.Complex_IO    section Complex Input-Output.
   Ada.Text_IO.Editing    section The Package Text_IO.Editing.
   Ada.Text_IO.Text_Streams    section The Package Text_IO.Text_Streams.
   Ada.Unchecked_Conversion    section Unchecked Type Conversions.
   Ada.Unchecked_Deallocation    section Unchecked Storage Deallocation.
   Ada.Wide_Text_IO    section Wide Text Input-Output.
   Ada.Wide_Text_IO.Complex_IO    section The Package Wide_Text_IO.Complex_IO.
   Ada.Wide_Text_IO.Editing    section The Package Wide_Text_IO.Editing.
   Ada.Wide_Text_IO.Text_Streams    section The Package Wide_Text_IO.Text_Streams.
   Interfaces    section The Package Interfaces.
   Interfaces.C    section Interfacing with C.
   Interfaces.C.Pointers    section The Generic Package Interfaces.C.Pointers.
   Interfaces.C.Strings    section The Package Interfaces.C.Strings.
   Interfaces.COBOL    section Interfacing with COBOL.
   Interfaces.Fortran    section Interfacing with Fortran.
   Standard    section The Package Standard.
   System    section The Package System.
   System.Address_To_Access_Conversions    section The Package System.Address_To_Access_Conversions.
   System.Machine_Code    section Machine Code Insertions.
   System.RPC    section Partition Communication Subsystem.
   System.Storage_Elements    section The Package System.Storage_Elements.
   System.Storage_Pools    section Storage Management.
Language-Defined Types
   Address, in System    section The Package System.
   Alignment, in Ada.Strings    section The Package Strings.
   Alphanumeric, in Interfaces.COBOL    section Interfacing with COBOL.
   Attribute_Handle, in Ada.Task_Attributes    section The Package Task_Attributes.
   Binary, in Interfaces.COBOL    section Interfacing with COBOL.
   Binary_Format, in Interfaces.COBOL    section Interfacing with COBOL.
   Bit_Order, in System    section The Package System.
   Boolean, in Standard    section The Package Standard.
   Bounded_String, in Ada.Strings.Bounded.Generic_Bounded_Length
         section Bounded-Length String Handling.
   Byte, in Interfaces.COBOL    section Interfacing with COBOL.
   Byte_Array, in Interfaces.COBOL    section Interfacing with COBOL.
   C_float, in Interfaces.C    section Interfacing with C.
   char, in Interfaces.C    section Interfacing with C.
   char_array, in Interfaces.C    section Interfacing with C.
   char_array_access, in Interfaces.C    section The Package Interfaces.C.Strings.
   Character, in Standard    section The Package Standard.
   Character_Set, in Ada.Strings.Maps    section The Package Strings.Maps.
   chars_ptr, in Interfaces.C    section The Package Interfaces.C.Strings.
   chars_ptr_array, in Interfaces.C    section The Package Interfaces.C.Strings.
   COBOL_Character, in Interfaces.COBOL    section Interfacing with COBOL.
   Complex, in Ada.Numerics.Generic_Complex_Types    section Complex Types.
   Controlled, in Ada.Finalization    section User-Defined Assignment and Finalization.
   Count, in Ada.Direct_IO    section The Generic Package Direct_IO.
   Count, in Ada.Text_IO    section The Package Text_IO.
   Decimal_Element, in Interfaces.COBOL    section Interfacing with COBOL.
   Direction, in Ada.Strings    section The Package Strings.
   Display_Format, in Interfaces.COBOL    section Interfacing with COBOL.
   double, in Interfaces.C    section Interfacing with C.
   Duration, in Standard    section The Package Standard.
   Exception_Occurrence, in Ada.Exceptions    section The Package Exceptions.
   Exception_Occurrence_Access, in Ada.Exceptions    section The Package Exceptions.
   Exception_Id, in Ada.Exceptions    section The Package Exceptions.
   File_Mode, in Ada.Direct_IO    section The Generic Package Direct_IO.
   File_Mode, in Ada.Sequential_IO    section The Generic Package Sequential_IO.
   File_Mode, in Ada.Text_IO    section The Package Text_IO.
   File_Type, in Ada.Direct_IO    section The Generic Package Direct_IO.
   File_Type, in Ada.Sequential_IO    section The Generic Package Sequential_IO.
   File_Type, in Ada.Text_IO    section The Package Text_IO.
   Float, in Standard    section The Package Standard.
   Floating, in Interfaces.COBOL    section Interfacing with COBOL.
   Generator, in Ada.Numerics.Discrete_Random    section Random Number Generation.
   Generator, in Ada.Numerics.Float_Random    section Random Number Generation.
   Imaginary, in Ada.Numerics.Generic_Complex_Types    section Complex Types.
   int, in Interfaces.C    section Interfacing with C.
   Integer, in Standard    section The Package Standard.
   Integer_Address, in System.Storage_Elements    section The Package System.Storage_Elements.
   Interrupt_ID, in Ada.Interrupts    section The Package Interrupts.
   Limited_Controlled, in Ada.Finalization    section User-Defined Assignment and Finalization.
   long, in Interfaces.C    section Interfacing with C.
   Long_Binary, in Interfaces.COBOL    section Interfacing with COBOL.
   long_double, in Interfaces.C    section Interfacing with C.
   Long_Floating, in Interfaces.COBOL    section Interfacing with COBOL.
   Membership, in Ada.Strings    section The Package Strings.
   Name, in System    section The Package System.
   Numeric, in Interfaces.COBOL    section Interfacing with COBOL.
   Packed_Decimal, in Interfaces.COBOL    section Interfacing with COBOL.
   Packed_Format, in Interfaces.COBOL    section Interfacing with COBOL.
   Parameterless_Handler, in Ada.Interrupts    section The Package Interrupts.
   Partition_ID, in System.RPC    section Partition Communication Subsystem.
   Picture, in Ada.Text_IO.Editing    section The Package Text_IO.Editing.
   Picture, in Ada.Wide_Text_IO.Editing    section The Package Wide_Text_IO.Editing.
   plain_char, in Interfaces.C    section Interfacing with C.
   Pointer, in Interfaces.C.Pointers    section The Generic Package Interfaces.C.Pointers.
   ptrdiff_t, in Interfaces.C    section Interfacing with C.
   Root_Storage_Pool, in System.Storage_Pools    section Storage Management.
   Root_Stream_Type, in Ada.Streams    section The Package Streams.
   Seconds_Count, in Ada.Real_Time    section Monotonic Time.
   short, in Interfaces.C    section Interfacing with C.
   signed_char, in Interfaces.C    section Interfacing with C.
   size_t, in Interfaces.C    section Interfacing with C.
   State, in Ada.Numerics.Discrete_Random    section Random Number Generation.
   State, in Ada.Numerics.Float_Random    section Random Number Generation.
   Storage_Array, in System.Storage_Elements    section The Package System.Storage_Elements.
   Storage_Element, in System.Storage_Elements    section The Package System.Storage_Elements.
   Storage_Offset, in System.Storage_Elements    section The Package System.Storage_Elements.
   Stream_Access, in Ada.Streams.Stream_IO    section The Package Streams.Stream_IO.
   String, in Standard    section The Package Standard.
   Suspension_Object, in Ada.Synchronous_Task_Control
         section Synchronous Task Control.
   Tag, in Tags    section Tagged Types and Type Extensions.
   Task_ID, in Ada.Task_Identification    section The Package Task_Identification.
   Time, in Ada.Calendar    section Delay Statements, Duration, and Time.
   Time, in Ada.Real_Time    section Monotonic Time.
   Time_Span, in Ada.Real_Time    section Monotonic Time.
   Trim_End, in Ada.Strings    section The Package Strings.
   Truncation, in Ada.Strings    section The Package Strings.
   Type_Set, in Ada.Text_IO    section The Package Text_IO.
   Unbounded_String, in Ada.Strings.Unbounded    section Unbounded-Length String Handling.
   unsigned, in Interfaces.C    section Interfacing with C.
   unsigned_char, in Interfaces.C    section Interfacing with C.
   unsigned_long, in Interfaces.C    section Interfacing with C.
   unsigned_short, in Interfaces.C    section Interfacing with C.
   wchar_array, in Interfaces.C    section Interfacing with C.
   wchar_t, in Interfaces.C    section Interfacing with C.
   Wide_Character, in Standard    section The Package Standard.
   Wide_Character_Set, in Ada.Strings.Wide_Maps    section Wide_String Handling.
   Wide_String, in Standard    section The Package Standard.
Last attribute    section Scalar Types(13), see section Operations of Array Types(5), see section Language-Defined Attributes (informative)(13), see section Operations of Array Types(5), see section Language-Defined Attributes (informative),
                  section Language-Defined Attributes (informative).
Last(N) attribute    section Operations of Array Types(6), see section Language-Defined Attributes (informative)(6), see section Language-Defined Attributes (informative).
last_bit    section Record Representation Clauses.
   used    section Record Representation Clauses(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Last_Bit attribute    section Storage Place Attributes(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
lateness    section Delay Accuracy.
Latin-1    section Character Types.
Latin_1
   child of Ada.Characters    section The Package Characters.Latin_1.
layout
   aspect of representation    section Record Layout.
Layout_Error    section The Package Text_IO(85), see section Exceptions in Input-Output(85), see section Exceptions in Input-Output.
LC_German_Sharp_S    section The Package Characters.Latin_1.
LC_Icelandic_Eth    section The Package Characters.Latin_1.
LC_Icelandic_Thorn    section The Package Characters.Latin_1.
LC_A    section The Package Characters.Latin_1(13), see section ASCII(13), see section ASCII.
LC_A_Acute    section The Package Characters.Latin_1.
LC_A_Circumflex    section The Package Characters.Latin_1.
LC_A_Diaeresis    section The Package Characters.Latin_1.
LC_A_Grave    section The Package Characters.Latin_1.
LC_A_Ring    section The Package Characters.Latin_1.
LC_A_Tilde    section The Package Characters.Latin_1.
LC_AE_Diphthong    section The Package Characters.Latin_1.
LC_B    section The Package Characters.Latin_1.
LC_C    section The Package Characters.Latin_1.
LC_C_Cedilla    section The Package Characters.Latin_1.
LC_D    section The Package Characters.Latin_1.
LC_E    section The Package Characters.Latin_1.
LC_E_Acute    section The Package Characters.Latin_1.
LC_E_Circumflex    section The Package Characters.Latin_1.
LC_E_Diaeresis    section The Package Characters.Latin_1.
LC_E_Grave    section The Package Characters.Latin_1.
LC_F    section The Package Characters.Latin_1.
LC_G    section The Package Characters.Latin_1.
LC_H    section The Package Characters.Latin_1.
LC_I    section The Package Characters.Latin_1.
LC_I_Acute    section The Package Characters.Latin_1.
LC_I_Circumflex    section The Package Characters.Latin_1.
LC_I_Diaeresis    section The Package Characters.Latin_1.
LC_I_Grave    section The Package Characters.Latin_1.
LC_J    section The Package Characters.Latin_1.
LC_K    section The Package Characters.Latin_1.
LC_L    section The Package Characters.Latin_1.
LC_M    section The Package Characters.Latin_1.
LC_N    section The Package Characters.Latin_1.
LC_N_Tilde    section The Package Characters.Latin_1.
LC_O    section The Package Characters.Latin_1.
LC_O_Acute    section The Package Characters.Latin_1.
LC_O_Circumflex    section The Package Characters.Latin_1.
LC_O_Diaeresis    section The Package Characters.Latin_1.
LC_O_Grave    section The Package Characters.Latin_1.
LC_O_Oblique_Stroke    section The Package Characters.Latin_1.
LC_O_Tilde    section The Package Characters.Latin_1.
LC_P    section The Package Characters.Latin_1.
LC_Q    section The Package Characters.Latin_1.
LC_R    section The Package Characters.Latin_1.
LC_S    section The Package Characters.Latin_1.
LC_T    section The Package Characters.Latin_1.
LC_U    section The Package Characters.Latin_1.
LC_U_Acute    section The Package Characters.Latin_1.
LC_U_Circumflex    section The Package Characters.Latin_1.
LC_U_Diaeresis    section The Package Characters.Latin_1.
LC_U_Grave    section The Package Characters.Latin_1.
LC_V    section The Package Characters.Latin_1.
LC_W    section The Package Characters.Latin_1.
LC_X    section The Package Characters.Latin_1.
LC_Y    section The Package Characters.Latin_1.
LC_Y_Acute    section The Package Characters.Latin_1.
LC_Y_Diaeresis    section The Package Characters.Latin_1.
LC_Z    section The Package Characters.Latin_1(14), see section ASCII(14), see section ASCII.
Leading_Nonseparate    section Interfacing with COBOL.
Leading_Part attribute    section Attributes of Floating Point Types(54), see section Language-Defined Attributes (informative)(54), see section Language-Defined Attributes (informative).
Leading_Separate    section Interfacing with COBOL.
leaving    section Completion and Finalization.
left    section Completion and Finalization.
left curly bracket    section Character Set.
left parenthesis    section Character Set.
left square bracket    section Character Set.
Left_Angle_Quotation    section The Package Characters.Latin_1.
Left_Curly_Bracket    section The Package Characters.Latin_1.
Left_Parenthesis    section The Package Characters.Latin_1.
Left_Square_Bracket    section The Package Characters.Latin_1.
legal
   construct    section Structure.
   partition    section Structure.
legality rules    section Structure.
length    section Bounded-Length String Handling(9), see section Unbounded-Length String Handling(6), see section Interfacing with COBOL(9), see section Unbounded-Length String Handling(6), see section Interfacing with COBOL,
          section Interfacing with COBOL(39),   section Interfacing with COBOL(44),   section The Package Text_IO.Editing(39),   section Interfacing with COBOL(44),   section The Package Text_IO.Editing.
   of a dimension of an array    section Array Types.
   of a one-dimensional array    section Array Types.
Length attribute    section Operations of Array Types(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
Length(N) attribute    section Operations of Array Types(10), see section Language-Defined Attributes (informative)(10), see section Language-Defined Attributes (informative).
Length_Check    section Suppressing Checks.
   [partial]    section Logical Operators and Short-circuit Control Forms(8), see section Type Conversions(37), see section Type Conversions(8), see section Type Conversions(37), see section Type Conversions.
Length_Error    section Generic Declarations.
Length_Range    section Bounded-Length String Handling.
less than operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
less than or equal operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
less-than sign    section Character Set.
Less_Than_Sign    section The Package Characters.Latin_1.
letter
   a category of Character    section The Package Characters.Handling.
Letter_Set    section String-Handling Sets and Mappings.
letter_or_digit    section Identifiers.
   used    section Identifiers(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Level    section Enumeration Types.
   accessibility    section Operations of Access Types.
   library    section Operations of Access Types.
lexical element    section Lexical Elements, Separators, and Delimiters.
lexicographic order    section Relational Operators and Membership Tests.
LF    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
library    section The Compilation Process.
   informal introduction    section Program Structure and Compilation Issues.
library level    section Operations of Access Types.
library unit    section Separate Compilation(3), see section Compilation Units - Library Units(9), see section Glossary (informative)(3), see section Compilation Units - Library Units(9), see section Glossary (informative).
   informal introduction    section Program Structure and Compilation Issues.
   See also   language-defined library units
library unit pragma    section Pragmas and Program Units.
   All_Calls_Remote    section Remote Call Interface Library Units.
   categorization pragmas    section Categorization of Library Units.
   Elaborate_Body    section Elaboration Control.
   Preelaborate    section Elaboration Control.
   Pure    section Elaboration Control.
library_item    section Compilation Units - Library Units.
   used    section Compilation Units - Library Units(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
   informal introduction    section Program Structure and Compilation Issues.
library_unit_body    section Compilation Units - Library Units.
   used    section Compilation Units - Library Units(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
library_unit_declaration    section Compilation Units - Library Units.
   used    section Compilation Units - Library Units(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
library_unit_renaming_declaration    section Compilation Units - Library Units.
   used    section Compilation Units - Library Units(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
lifetime    section Operations of Access Types.
Light    section Enumeration Types.
Limit    section Object Declarations(33), see section Limited Types(33), see section Limited Types.
limited type    section Limited Types(1), see section Limited Types(3), see section Glossary (informative)(1), see section Limited Types(3), see section Glossary (informative).
   becoming nonlimited    section Private Operations(5), see section Limited Types(5), see section Limited Types.
Limited_Controlled    section User-Defined Assignment and Finalization.
line    section Lexical Elements, Separators, and Delimiters(2), see section Array Types(28), see section The Package Text_IO(2), see section Array Types(28), see section The Package Text_IO.
line terminator    section Text Input-Output.
Line_Length    section The Package Text_IO.
Line_Size    section Integer Types.
Link    section Incomplete Type Declarations(15), see section Formal Access Types(15), see section Formal Access Types.
link name    section Interfacing Pragmas.
link-time error
   See post-compilation error    section Structure(29), see section Classification of Errors(29), see section Classification of Errors.
Linker_Options pragma    section Interfacing Pragmas(8), see section Language-Defined Pragmas (informative)(8), see section Language-Defined Pragmas (informative).
linking
   See partition building    section Program Execution.
List    section Private Types and Private Extensions.
List pragma    section Pragmas(21), see section Language-Defined Pragmas (informative)(21), see section Language-Defined Pragmas (informative).
literal    section Type Extensions(13), see section Literals(13), see section Literals.
   See also aggregate    section Aggregates.
   based    section Based Literals.
   decimal    section Decimal Literals.
   numeric    section Numeric Literals.
little endian    section Bit Ordering.
load time    section Preelaboration Requirements.
Local    section Task Dependence - Termination of Tasks.
local to    section Declarative Region.
Local_Coordinate    section Derived Types and Classes.
local_name    section Representation Items.
   used    section Pragma Pack(3),    section Representation Attributes(2),    section Enumeration Representation Clauses(3),    section Representation Attributes(2),    section Enumeration Representation Clauses,
           section Record Representation Clauses(2), see section Record Representation Clauses(3), see section Pragma Controlled(2), see section Record Representation Clauses(3), see section Pragma Controlled,
           section Interfacing Pragmas(5),     section Interfacing Pragmas(6),     section Interfacing Pragmas(5),     section Interfacing Pragmas(6),     section Interfacing Pragmas,
           section Pragma Discard_Names(3),     section Shared Variable Control(3),     section Shared Variable Control(3),     section Shared Variable Control(3),     section Shared Variable Control,
           section Shared Variable Control(5),     section Shared Variable Control(6),     section Pragma Asynchronous(5),     section Shared Variable Control(6),     section Pragma Asynchronous,
           section Language-Defined Pragmas (informative)(3),       section Language-Defined Pragmas (informative)(4),       section Language-Defined Pragmas (informative)(3),       section Language-Defined Pragmas (informative)(4),       section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(7),       section Language-Defined Pragmas (informative)(8),       section Language-Defined Pragmas (informative)(7),       section Language-Defined Pragmas (informative)(8),       section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(13),      section Language-Defined Pragmas (informative)(14),      section Language-Defined Pragmas (informative)(13),      section Language-Defined Pragmas (informative)(14),      section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(38),      section Language-Defined Pragmas (informative)(39),      section Syntax Summary (informative)(38),      section Language-Defined Pragmas (informative)(39),      section Syntax Summary (informative).
localization    section Character Types(4), see section Character Types(4), see section Character Types.
Lock    section Other Optimizations and Determinism Rules(9), see section Other Optimizations and Determinism Rules(9), see section Other Optimizations and Determinism Rules.
locking policy    section Priority Ceiling Locking.
Locking_Policy pragma    section Priority Ceiling Locking(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Log    section Elementary Functions(4), see section Complex Elementary Functions(4), see section Complex Elementary Functions.
Logical    section Interfacing with Fortran.
logical operator    section Logical Operators and Short-circuit Control Forms.
   See also not operator    section Highest Precedence Operators.
logical_operator    section Operators and Expression Evaluation.
Long    section Static Expressions and Static Subtypes(43), see section Interfacing with C(43), see section Interfacing with C.
Long_Binary    section Interfacing with COBOL.
long_double    section Interfacing with C.
Long_Float    section Floating Point Types(15), see section Floating Point Types(16), see section Floating Point Types(15), see section Floating Point Types(16), see section Floating Point Types.
Long_Floating    section Interfacing with COBOL.
Long_Integer    section Integer Types(22), see section Integer Types(25), see section Integer Types(22), see section Integer Types(25), see section Integer Types.
Look_Ahead    section The Package Text_IO.
loop parameter    section Loop Statements.
loop_parameter_specification    section Loop Statements.
   used    section Loop Statements(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
loop_statement    section Loop Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
low line    section Character Set.
low-level programming    section Systems Programming (normative).
Low_Limit    section Object Declarations.
Low_Line    section The Package Characters.Latin_1.
Low_Order_First    section Bit Ordering(2), see section Interfacing with COBOL(2), see section Interfacing with COBOL.
lower bound
   of a range    section Scalar Types.
lower-case letter
   a category of Character    section The Package Characters.Handling.
lower_case_identifier_letter    section Character Set.
Lower_Case_Map    section String-Handling Sets and Mappings.
Lower_Set    section String-Handling Sets and Mappings.

index

Machine attribute    section Attributes of Floating Point Types(60), see section Language-Defined Attributes (informative)(60), see section Language-Defined Attributes (informative).
machine code insertion    section Machine Code Insertions(1), see section Access to Machine Operations(1), see section Access to Machine Operations.
machine numbers
   of a floating point type    section Floating Point Types.
Machine_Code    section Renamings of Ada 83 Library Units.
   child of System    section Machine Code Insertions.
Machine_Emax attribute    section Attributes of Floating Point Types(8), see section Language-Defined Attributes (informative)(8), see section Language-Defined Attributes (informative).
Machine_Emin attribute    section Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative)(7), see section Language-Defined Attributes (informative).
Machine_Mantissa attribute    section Attributes of Floating Point Types(6), see section Language-Defined Attributes (informative)(6), see section Language-Defined Attributes (informative).
Machine_Overflows attribute    section Attributes of Floating Point Types(12), see section Attributes of Fixed Point Types(12), see section Attributes of Fixed Point Types,
                               section Language-Defined Attributes (informative)(129),     section Language-Defined Attributes (informative)(129),     section Language-Defined Attributes (informative).
Machine_Radix attribute    section Attributes of Floating Point Types(2), see section Attributes of Fixed Point Types(2), see section Attributes of Fixed Point Types,
                           section Language-Defined Attributes (informative)(133),    section Language-Defined Attributes (informative)(133),    section Language-Defined Attributes (informative).
Machine_Radix clause    section Representation Attributes(7), see section Machine_Radix Attribute Definition Clause(7), see section Machine_Radix Attribute Definition Clause.
Machine_Rounds attribute    section Attributes of Floating Point Types(11), see section Attributes of Fixed Point Types(11), see section Attributes of Fixed Point Types,
                            section Language-Defined Attributes (informative)(137),     section Language-Defined Attributes (informative)(137),     section Language-Defined Attributes (informative).
macro
   See generic unit    section Generic Units.
Macron    section The Package Characters.Latin_1.
Main section Compilation Units - Library Units(33), see section Example of Exception Handling(10)
main subprogram
   for a partition    section Program Execution.
Major    section Enumeration Types.
Male    section Subtype Declarations.
malloc
   See allocator    section Allocators.
Maps
   child of Ada.Strings    section The Package Strings.Maps.
Mark_Release_Pool_Type    section Storage Management.
marshalling    section Remote Subprogram Calls.
Masculine_Ordinal_Indicator    section The Package Characters.Latin_1.
Mask    section Qualified Expressions.
Mass    section Floating Point Types(21), see section Formal Types(21), see section Formal Types.
master    section Completion and Finalization.
match
   a character to a pattern character    section The Package Strings.Maps.
   a character to a pattern character, with
     respect to a character mapping function    section The Package Strings.Maps.
   a string to a pattern string    section The Package Strings.Maps.
matching components    section Relational Operators and Membership Tests.
Matrix    section Array Types.
Matrix_Rec    section Discriminants.
Max    section Number Declarations.
Max attribute    section Scalar Types(19), see section Language-Defined Attributes (informative)(19), see section Language-Defined Attributes (informative).
Max_Base_Digits    section Floating Point Types(6), see section The Package System(6), see section The Package System.
   named number in package System    section The Package System.
Max_Binary_Modulus    section Integer Types(7), see section The Package System(7), see section The Package System.
   named number in package System    section The Package System.
Max_Decimal_Digits    section The Package Decimal.
Max_Delta    section The Package Decimal.
Max_Digits    section Floating Point Types(6), see section The Package System(6), see section The Package System.
   named number in package System    section The Package System.
Max_Digits_Binary    section Interfacing with COBOL.
Max_Digits_Long_Binary    section Interfacing with COBOL.
Max_Image_Width    section Random Number Generation(13), see section Random Number Generation(13), see section Random Number Generation.
Max_Int    section Integer Types(14), see section The Package System(14), see section The Package System.
   named number in package System    section The Package System.
Max_Length    section Bounded-Length String Handling.
Max_Line_Size    section Number Declarations.
Max_Mantissa    section The Package System.
   named number in package System    section The Package System.
Max_Nonbinary_Modulus    section Integer Types(7), see section The Package System(7), see section The Package System.
   named number in package System    section The Package System.
Max_Scale    section The Package Decimal.
Max_Size_In_Storage_Elements attribute    section The Max_Size_In_Storage_Elements Attribute,
                                          section Language-Defined Attributes (informative).
maximum box error
   for a component of the result of evaluating
     a complex function    section Accuracy Requirements for Complex Arithmetic.
maximum line length    section Text Input-Output.
maximum page length    section Text Input-Output.
maximum relative error
   for a component of the result of evaluating
     a complex function    section Accuracy Requirements for Complex Arithmetic.
   for the evaluation of an elementary function    section Accuracy Requirements for the Elementary Functions.
Medium    section Representation Attributes.
Mega    section Static Expressions and Static Subtypes.
Membership    section The Package Strings.
membership test    section Relational Operators and Membership Tests.
Memory_Size    section The Package System.
mentioned in a with_clause    section Context Clauses - With Clauses.
message
   See dispatching call    section Dispatching Operations of Tagged Types.
Message_Procedure    section Access Types.
method
   See dispatching subprogram    section Dispatching Operations of Tagged Types.
metrics    section Structure(35), see section Protected Procedure Handlers(15), see section The Package Task_Attributes(35), see section Protected Procedure Handlers(15), see section The Package Task_Attributes,
           section Real-Time Systems (normative)(2),       section Dynamic Priorities(13),    section Preemptive Abort(2),       section Dynamic Priorities(13),    section Preemptive Abort,
           section Monotonic Time(37),    section Delay Accuracy(9),     section Other Optimizations and Determinism Rules(37),    section Delay Accuracy(9),     section Other Optimizations and Determinism Rules.
Micro_Sign    section The Package Characters.Latin_1.
Microseconds    section Monotonic Time.
Middle_Dot    section The Package Characters.Latin_1.
Midweek    section Derived Types and Classes.
Milliseconds    section Monotonic Time.
Min attribute    section Scalar Types(16), see section Language-Defined Attributes (informative)(16), see section Language-Defined Attributes (informative).
Min_Cell    section Subprogram Declarations.
Min_Delta    section The Package Decimal.
Min_Int    section Integer Types(14), see section The Package System(14), see section The Package System.
   named number in package System    section The Package System.
Min_Scale    section The Package Decimal.
Minimum    section Subprogram Renaming Declarations.
minus    section Character Set.
minus operator    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
Mix    section Formal Array Types.
Mix_Code    section Enumeration Representation Clauses.
Mixed    section Enumeration Types.
mixed-language programs    section Interface to Other Languages (normative)(1), see section Access to Machine Operations(1), see section Access to Machine Operations.
mod operator    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
mod_clause    section Mod Clauses.
   used    section Record Representation Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
mode    section Subprogram Declarations(16),    section Renaming Declarations(7),   section Record Representation Clauses(16),    section Renaming Declarations(7),   section Record Representation Clauses,
        section The Generic Package Sequential_IO(9),   section The Generic Package Direct_IO(9), see section The Package Text_IO(9),   section The Generic Package Direct_IO(9), see section The Package Text_IO,
        section The Package Streams.Stream_IO.
   used    section Subprogram Declarations(15), see section Formal Objects(2), see section Syntax Summary (informative)(15), see section Formal Objects(2), see section Syntax Summary (informative).
mode conformance    section Conformance Rules.
   required    section Subprogram Renaming Declarations(4), see section Formal Access Types(5), see section Formal Subprograms(4), see section Formal Access Types(5), see section Formal Subprograms,
               section Formal Subprograms.
mode of operation
   nonstandard    section Classification of Errors.
   standard    section Classification of Errors.
Mode_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO,
              section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(26), see section Exceptions in Input-Output.
Mode_Mask    section Record Representation Clauses.
Model attribute    section Attributes of Floating Point Types(68), see section Model-Oriented Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative)(68), see section Model-Oriented Attributes of Floating Point Types(7), see section Language-Defined Attributes (informative).
model interval    section Model of Floating Point Arithmetic.
   associated with a value    section Model of Floating Point Arithmetic.
model number    section Model of Floating Point Arithmetic.
model-oriented attributes
   of a floating point subtype    section Attributes of Floating Point Types.
Model_Emin attribute    section Attributes of Floating Point Types(65), see section Model-Oriented Attributes of Floating Point Types(65), see section Model-Oriented Attributes of Floating Point Types,
                        section Language-Defined Attributes (informative).
Model_Epsilon attribute    section Attributes of Floating Point Types(66), see section Language-Defined Attributes (informative)(66), see section Language-Defined Attributes (informative).
Model_Mantissa attribute    section Attributes of Floating Point Types(64), see section Model-Oriented Attributes of Floating Point Types(64), see section Model-Oriented Attributes of Floating Point Types,
                            section Language-Defined Attributes (informative).
Model_Small attribute    section Attributes of Floating Point Types(67), see section Language-Defined Attributes (informative)(67), see section Language-Defined Attributes (informative).
modular type    section Integer Types.
modular_type_definition    section Integer Types.
   used    section Integer Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Modular_IO    section The Package Text_IO.
module
   See package    section Packages.
modulus    section Complex Types.
   of a modular type    section Integer Types.
Modulus attribute    section Integer Types(17), see section Language-Defined Attributes (informative)(17), see section Language-Defined Attributes (informative).
Money    section Fixed Point Types(28), see section Machine_Radix Attribute Definition Clause(28), see section Machine_Radix Attribute Definition Clause.
Month    section Delay Statements, Duration, and Time.
Month_Number    section Delay Statements, Duration, and Time.
Move    section Fixed-Length String Handling.
multi-dimensional array    section Array Types.
Multiplication_Sign    section The Package Characters.Latin_1.
multiply    section Character Set.
multiply operator    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
multiplying operator    section Multiplying Operators.
multiplying_operator    section Operators and Expression Evaluation.
   used    section Expressions(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
MW    section The Package Characters.Latin_1.
My_Read    section Representation Attributes.
My_Write    section Subprogram Renaming Declarations(14), see section Stream-Oriented Attributes(14), see section Stream-Oriented Attributes.

index

n-dimensional array_aggregate    section Array Aggregates.
NAK    section The Package Characters.Latin_1.
name    section Names(2),    section The Package System(4),   section Unchecked Storage Deallocation(2),    section The Package System(4),   section Unchecked Storage Deallocation,
        section The Generic Package Sequential_IO(9), see section The Generic Package Direct_IO(9), see section The Package Text_IO(9), see section The Generic Package Direct_IO(9), see section The Package Text_IO,
        section The Package Streams.Stream_IO.
   used    section Pragmas(3),      section Subtype Declarations(4),    section Names(3),      section Subtype Declarations(4),    section Names,
           section Names(5),      section Names(6),      section Expressions(5),      section Names(6),      section Expressions,
           section Type Conversions(2),      section Assignment Statements(2),      section Exit Statements(2),      section Assignment Statements(2),      section Exit Statements,
           section Goto Statements(2),      section Inline Expansion of Subprograms(3),    section Subprogram Calls(2),      section Inline Expansion of Subprograms(3),    section Subprogram Calls,
           section Subprogram Calls(3),      section Subprogram Calls(6),      section Use Clauses(3),      section Subprogram Calls(6),      section Use Clauses,
           section Object Renaming Declarations(2),    section Exception Renaming Declarations(2),    section Package Renaming Declarations(2),    section Exception Renaming Declarations(2),    section Package Renaming Declarations,
           section Subprogram Renaming Declarations(2),    section Generic Renaming Declarations(2),    section Entry Calls(2),    section Generic Renaming Declarations(2),    section Entry Calls,
           section Requeue Statements(2),    section Abort of a Task - Abort of a Sequence of Statements(2),      section Compilation Units - Library Units(2),    section Abort of a Task - Abort of a Sequence of Statements(2),      section Compilation Units - Library Units,
           section Context Clauses - With Clauses(4),   section Elaboration Control(3),   section Elaboration Control(4),   section Elaboration Control(3),   section Elaboration Control,
           section Elaboration Control(20), see section Elaboration Control(21), see section Elaboration Control(20), see section Elaboration Control(21), see section Elaboration Control,
           section Exception Handlers(5),     section Raise Statements(2),     section Suppressing Checks(5),     section Raise Statements(2),     section Suppressing Checks,
           section Generic Instantiation(2),     section Generic Instantiation(5),     section Formal Subprograms(2),     section Generic Instantiation(5),     section Formal Subprograms,
           section Formal Packages(2),     section Representation Items(3),     section Representation Attributes(2),     section Representation Items(3),     section Representation Attributes,
           section Protected Procedure Handlers(2),    section Protected Procedure Handlers(4),    section Shared Passive Library Units(2),    section Protected Procedure Handlers(4),    section Shared Passive Library Units,
           section Remote Types Library Units(3),    section Remote Call Interface Library Units(3),    section Remote Call Interface Library Units(3),    section Remote Call Interface Library Units(3),    section Remote Call Interface Library Units,
           section Pragma Inspection_Point(3),    section Language-Defined Pragmas (informative)(2),        section Language-Defined Pragmas (informative)(3),    section Language-Defined Pragmas (informative)(2),        section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(10),       section Language-Defined Pragmas (informative)(11),       section Language-Defined Pragmas (informative)(10),       section Language-Defined Pragmas (informative)(11),       section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(15),       section Language-Defined Pragmas (informative)(16),       section Language-Defined Pragmas (informative)(15),       section Language-Defined Pragmas (informative)(16),       section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(26),       section Language-Defined Pragmas (informative)(28),       section Language-Defined Pragmas (informative)(26),       section Language-Defined Pragmas (informative)(28),       section Language-Defined Pragmas (informative),
           section Language-Defined Pragmas (informative)(31),       section Language-Defined Pragmas (informative)(34),       section Language-Defined Pragmas (informative)(31),       section Language-Defined Pragmas (informative)(34),       section Language-Defined Pragmas (informative),
           section Syntax Summary (informative).
   [partial]    section Declarations.
   of (a view of) an entity    section Declarations.
   of a pragma    section Pragmas.
   of an external file    section External Files and File Objects.
name resolution rules    section Structure.
Name_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO,
              section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(26), see section Exceptions in Input-Output.
Name_Server    section Example of Use of a Remote Access-to-Class-Wide Type.
named association    section Subprogram Calls(7), see section Generic Instantiation(7), see section Generic Instantiation.
named component association    section Record Aggregates.
named discriminant association    section Discriminant Constraints.
named entry index    section Entries and Accept Statements.
named number    section Objects and Named Numbers.
named type    section Type Declarations.
named_array_aggregate    section Array Aggregates.
   used    section Array Aggregates(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Names
   child of Ada.Interrupts    section The Package Interrupts.
names of special_characters    section Character Set.
Nanoseconds    section Monotonic Time.
Native_Binary    section Interfacing with COBOL.
Natural    section Integer Types(12), see section Integer Types(13), see section The Package Standard(12), see section Integer Types(13), see section The Package Standard.
NBH    section The Package Characters.Latin_1.
needed
   of a compilation unit by another    section Program Execution.
   remote call interface    section Remote Call Interface Library Units.
   shared passive library unit    section Shared Passive Library Units.
needed component
   extension_aggregate record_component_association_list
         section Extension Aggregates.
   record_aggregate record_component_association_list
         section Record Aggregates.
NEL    section The Package Characters.Latin_1.
new
   See allocator    section Allocators.
New_Char_Array    section The Package Interfaces.C.Strings.
New_Line    section The Package Text_IO.
New_Page    section The Package Text_IO.
New_String    section The Package Interfaces.C.Strings.
New_Tape    section Example of Use of a Remote Access-to-Class-Wide Type.
Next    section Subprogram Renaming Declarations.
Next_Action    section Task Units and Task Objects.
Next_Frame    section Subprogram Declarations.
Next_Lexeme    section Task Units and Task Objects.
Next_Work_Item    section Task Units and Task Objects.
Ninety_Six    section String Types.
No_Break_Space    section The Package Characters.Latin_1.
Node    section Formal Access Types.
nominal subtype    section Objects and Named Numbers(23), see section Object Declarations(23), see section Object Declarations.
   associated with a type_conversion    section Type Conversions.
   associated with a dereference    section Names.
   associated with an indexed_component    section Indexed Components.
   of a component    section Array Types.
   of a formal parameter    section Subprogram Declarations.
   of a generic formal object    section Formal Objects.
   of a record component    section Record Types.
   of the result of a function_call    section Subprogram Calls.
non-normative
   See informative    section Structure.
nondispatching call
   on a dispatching operation    section Dispatching Operations of Tagged Types.
nonexistent    section Unchecked Storage Deallocation(10), see section Unchecked Storage Deallocation(10), see section Unchecked Storage Deallocation.
nongraphic character    section Scalar Types.
nonlimited type    section Limited Types.
   becoming nonlimited    section Private Operations(5), see section Limited Types(5), see section Limited Types.
nonstandard integer type    section Integer Types.
nonstandard mode    section Classification of Errors.
nonstandard real type    section Real Types.
normal completion    section Completion and Finalization.
normal library unit    section Categorization of Library Units.
normal state of an object    section Exceptions and Optimization(6), see section Data Validity(6), see section Data Validity.
   [partial]    section Abort of a Task - Abort of a Sequence of Statements(21), see section Exceptions in Input-Output(21), see section Exceptions in Input-Output.
Normalize_Scalars pragma    section Pragma Normalize_Scalars(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
normalized exponent    section Attributes of Floating Point Types.
normalized number    section Attributes of Floating Point Types.
normative    section Structure.
not equal operator    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
not in (membership test)    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
not operator    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
Not_Sign    section The Package Characters.Latin_1.
notes    section Structure.
notwithstanding    section Environment-Level Visibility Rules(2), see section Interfacing Pragmas(22), see section Interfacing Pragmas(2), see section Interfacing Pragmas(22), see section Interfacing Pragmas,
                   section Protected Procedure Handlers(19), see section Shared Passive Library Units(19), see section Shared Passive Library Units,
         section Shared Passive Library Units(11), see section Remote Call Interface Library Units(18), see section Reduced Accuracy Subtypes(11), see section Remote Call Interface Library Units(18), see section Reduced Accuracy Subtypes.
NUL    section The Package Characters.Latin_1(5), see section Interfacing with C(20), see section ASCII(5), see section Interfacing with C(20), see section ASCII.
null access value    section Literals.
null array    section Index Constraints and Discrete Ranges.
null constraint    section Types and Subtypes.
null pointer
   See null access value    section Literals.
null range    section Scalar Types.
null record    section Record Types.
null slice    section Slices.
null string literal    section String Literals.
null value
   of an access type    section Access Types.
Null_Address    section The Package System.
   constant in System    section The Package System.
Null_Bounded_String    section Bounded-Length String Handling.
Null_Key    section Private Operations(15), see section Deferred Constants(15), see section Deferred Constants.
Null_Occurrence    section The Package Exceptions.
Null_Ptr    section The Package Interfaces.C.Strings.
Null_Set    section The Package Strings.Maps(5), see section Wide_String Handling(5), see section Wide_String Handling.
null_statement    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Null_Task_ID    section The Package Task_Identification.
Null_Unbounded_String    section Unbounded-Length String Handling.
Null_Id    section The Package Exceptions.
Num    section The Package Text_IO(52), see section The Package Text_IO(57), see section The Package Text_IO(52), see section The Package Text_IO(57), see section The Package Text_IO,
       section The Package Text_IO(68), see section The Package Text_IO(73), see section Interfacing with COBOL(68), see section The Package Text_IO(73), see section Interfacing with COBOL,
         section The Package Text_IO.Editing.
number sign    section Character Set.
Number_Base    section The Package Text_IO(6), see section Input-Output for Integer Types(6), see section Input-Output for Integer Types.
number_declaration    section Number Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Number_Sign    section The Package Characters.Latin_1.
numeral    section Decimal Literals.
   used    section Decimal Literals(2), see section Decimal Literals(4), see section Based Literals(2), see section Decimal Literals(4), see section Based Literals,
           section Syntax Summary (informative).
Numeric    section Interfacing with COBOL.
numeric type    section Scalar Types.
Numeric_Error    section Numeric_Error.
numeric_literal    section Numeric Literals.
   used    section Expressions(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
Numerics    section Numerics (normative).
   child of Ada    section The Numerics Packages.

index

object    section Objects and Named Numbers(2), see section The Package System.Address_To_Access_Conversions(2), see section Unchecked Storage Deallocation(2), see section The Package System.Address_To_Access_Conversions(2), see section Unchecked Storage Deallocation,
          section Glossary (informative).
   [partial]    section Types and Subtypes.
object-oriented programming (OOP)
   See dispatching operations of tagged types    section Dispatching Operations of Tagged Types.
   See tagged types and type extensions    section Tagged Types and Type Extensions.
object_declaration    section Object Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Object_Pointer    section The Package System.Address_To_Access_Conversions.
object_renaming_declaration    section Object Renaming Declarations.
   used    section Renaming Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
obsolescent feature    section Obsolescent Features (normative).
occur immediately within section Declarative Region(13)
occurrence
   of an interrupt    section Interrupt Support.
octal
   literal    section Based Literals.
octal literal    section Based Literals.
On_Stacks    section Example of a Generic Package.
On_Vectors    section Generic Declarations(24), see section Generic Bodies(24), see section Generic Bodies.
one's complement
   modular types    section Integer Types.
one-dimensional array    section Array Types.
only as a completion
   entry_body    section Entries and Accept Statements.
OOP (object-oriented programming)
   See dispatching operations of tagged types    section Dispatching Operations of Tagged Types.
   See tagged types and type extensions    section Tagged Types and Type Extensions.
opaque type
   See private types and private extensions    section Private Types and Private Extensions.
Open    section Limited Types(19),     section Limited Types(20),   section Example of Exception Handling(19),     section Limited Types(20),   section Example of Exception Handling,
        section Example of Exception Handling(6),   section The Generic Package Sequential_IO(7), see section The Generic Package Direct_IO(6),   section The Generic Package Sequential_IO(7), see section The Generic Package Direct_IO,
        section The Package Text_IO(10), see section The Package Streams.Stream_IO(10), see section The Package Streams.Stream_IO.
open alternative    section Selective Accept.
open entry    section Entry Calls.
   of a protected object    section Entry Calls.
   of a task    section Entry Calls.
operand
   of a type_conversion    section Type Conversions.
   of a qualified_expression    section Qualified Expressions.
operand interval    section Model of Floating Point Arithmetic.
operand type
   of a type_conversion    section Type Conversions.
operates on a type    section Classification of Operations.
operator    section Overloading of Operators.
   &    section Expressions(1), see section Binary Adding Operators(1), see section Binary Adding Operators.
   *    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   **    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
   +    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
   =    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   -    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
   /    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   /=    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   <    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   <=    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   >    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   >=    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   abs    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
   ampersand section Expressions(1), see section Binary Adding Operators(3)
   and section Expressions(1), see section Logical Operators and Short-circuit Control Forms(2)
   binary    section Operators and Expression Evaluation.
   binary adding    section Binary Adding Operators.
   concatenation    section Expressions(1), see section Binary Adding Operators(1), see section Binary Adding Operators.
   divide    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   equal    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   equality    section Relational Operators and Membership Tests.
   exponentiation    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
   greater than    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   greater than or equal    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   highest precedence    section Highest Precedence Operators.
   less than    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   less than or equal    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   logical    section Logical Operators and Short-circuit Control Forms.
   minus    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
   mod    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   multiply    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   multiplying    section Multiplying Operators.
   not    section Expressions(1), see section Highest Precedence Operators(1), see section Highest Precedence Operators.
   not equal    section Expressions(1), see section Relational Operators and Membership Tests(1), see section Relational Operators and Membership Tests.
   or    section Expressions(1), see section Logical Operators and Short-circuit Control Forms(1), see section Logical Operators and Short-circuit Control Forms.
   ordering    section Relational Operators and Membership Tests.
   plus    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
   predefined    section Operators and Expression Evaluation.
   relational    section Relational Operators and Membership Tests.
   rem    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   times    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
   unary    section Operators and Expression Evaluation.
   unary adding    section Unary Adding Operators.
   user-defined    section Overloading of Operators.
   xor    section Expressions(1), see section Logical Operators and Short-circuit Control Forms(1), see section Logical Operators and Short-circuit Control Forms.
operator precedence    section Operators and Expression Evaluation.
operator_symbol    section Subprogram Declarations.
   used    section Names(3),   section Selected Components(3), see section Subprogram Declarations(3),   section Selected Components(3), see section Subprogram Declarations,
           section Subprogram Declarations(11), see section Syntax Summary (informative)(11), see section Syntax Summary (informative).
optimization    section Suppressing Checks(29), see section Exceptions and Optimization(29), see section Exceptions and Optimization.
Optimize pragma    section Pragmas(23), see section Language-Defined Pragmas (informative)(23), see section Language-Defined Pragmas (informative).
Option    section Formal Array Types.
or else (short-circuit control form)    section Expressions,
                                        section Logical Operators and Short-circuit Control Forms.
or operator    section Expressions(1), see section Logical Operators and Short-circuit Control Forms(1), see section Logical Operators and Short-circuit Control Forms.
ordering operator    section Relational Operators and Membership Tests.
ordinary fixed point type    section Fixed Point Types(1), see section Fixed Point Types(1), see section Fixed Point Types.
ordinary_fixed_point_definition    section Fixed Point Types.
   used    section Fixed Point Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Origin section Type Extensions(12)
OSC    section The Package Characters.Latin_1.
other_control_function    section Character Set.
   used    section Character Set(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Other_Procedure    section Access Types.
output    section Input-Output.
Output attribute    section Stream-Oriented Attributes(19), see section Stream-Oriented Attributes(19), see section Stream-Oriented Attributes,
                    section Language-Defined Attributes (informative)(165),       section Language-Defined Attributes (informative)(165),       section Language-Defined Attributes (informative).
Output clause    section Representation Attributes(7), see section Stream-Oriented Attributes(7), see section Stream-Oriented Attributes.
overall interpretation
   of a complete context    section The Context of Overload Resolution.
Overflow_Check    section Suppressing Checks.
   [partial]    section Integer Types(20), see section Expressions(11),   section Case Statements(20), see section Expressions(11),   section Case Statements,
                section Model of Floating Point Arithmetic(11), see section Model-Oriented Attributes of Floating Point Types(7), see section Model of Fixed Point Arithmetic(11), see section Model-Oriented Attributes of Floating Point Types(7), see section Model of Fixed Point Arithmetic,
                section Accuracy Requirements for the Elementary Functions(2),   section Accuracy Requirements for Complex Arithmetic(2),   section Accuracy Requirements for Complex Arithmetic.
overload resolution    section The Context of Overload Resolution.
overloadable    section Visibility.
overloaded    section Visibility.
   enumeration literal    section Enumeration Types.
overloading rules    section Structure(26), see section The Context of Overload Resolution(26), see section The Context of Overload Resolution.
override    section Visibility(9), see section Generic Instantiation(9), see section Generic Instantiation.
   a primitive subprogram    section Classification of Operations.
Overwrite    section Fixed-Length String Handling(27), see section Fixed-Length String Handling(28), see section Bounded-Length String Handling(27), see section Fixed-Length String Handling(28), see section Bounded-Length String Handling,
             section Bounded-Length String Handling(63), see section Unbounded-Length String Handling(57), see section Unbounded-Length String Handling(63), see section Unbounded-Length String Handling(57), see section Unbounded-Length String Handling.

index

P    section Task Execution - Task Activation(11), see section Formal Array Types(11), see section Formal Access Types(11), see section Formal Array Types(11), see section Formal Access Types.
Pack pragma    section Pragma Pack(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Package    section Packages(1), see section Glossary (informative)(1), see section Glossary (informative).
package instance    section Generic Instantiation.
package_body    section Package Bodies.
   used    section Declarative Parts(6), see section Compilation Units - Library Units(7), see section Syntax Summary (informative)(6), see section Compilation Units - Library Units(7), see section Syntax Summary (informative).
package_body_stub    section Subunits of Compilation Units.
   used    section Subunits of Compilation Units(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
package_declaration    section Package Specifications and Declarations.
   used    section Declarations(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative)(3), see section Compilation Units - Library Units(5), see section Syntax Summary (informative).
package_renaming_declaration    section Package Renaming Declarations.
   used    section Renaming Declarations(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative)(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative).
package_specification    section Package Specifications and Declarations.
   used    section Package Specifications and Declarations(2), see section Generic Declarations(4), see section Syntax Summary (informative)(2), see section Generic Declarations(4), see section Syntax Summary (informative).
packed    section Pragma Pack.
Packed_Decimal    section Interfacing with COBOL.
Packed_Descriptor    section Change of Representation.
Packed_Format    section Interfacing with COBOL.
Packed_Signed    section Interfacing with COBOL.
Packed_Unsigned    section Interfacing with COBOL.
packing
   aspect of representation    section Pragma Pack.
padding bits    section Representation Items.
Page    section Representation Attributes(80), see section The Package Text_IO(80), see section The Package Text_IO.
Page pragma    section Pragmas(22), see section Language-Defined Pragmas (informative)(22), see section Language-Defined Pragmas (informative).
page terminator    section Text Input-Output.
Page_Length    section The Package Text_IO.
Page_Num    section Integer Types.
Painted_Point    section Type Extensions.
Pair    section Subprogram Calls.
parallel processing
   See task    section Tasks and Synchronization.
Parallel_Simulation    section Random Number Generation.
parameter
   See also discriminant    section Discriminants.
   See also loop parameter    section Loop Statements.
   See formal parameter    section Subprogram Declarations.
   See generic formal parameter    section Generic Units.
parameter assigning back    section Parameter Associations.
parameter copy back    section Parameter Associations.
parameter mode    section Subprogram Declarations.
parameter passing    section Parameter Associations.
parameter_and_result_profile    section Subprogram Declarations.
   used    section Access Types(5), see section Subprogram Declarations(4), see section Syntax Summary (informative)(5), see section Subprogram Declarations(4), see section Syntax Summary (informative).
parameter_association    section Subprogram Calls.
   used    section Subprogram Calls(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
parameter_profile    section Subprogram Declarations.
   used    section Access Types(5),   section Subprogram Declarations(4),    section Entries and Accept Statements(5),   section Subprogram Declarations(4),    section Entries and Accept Statements,
           section Entries and Accept Statements(3), see section Entries and Accept Statements(6), see section Syntax Summary (informative)(3), see section Entries and Accept Statements(6), see section Syntax Summary (informative).
parameter_specification    section Subprogram Declarations.
   used    section Subprogram Declarations(14), see section Syntax Summary (informative)(14), see section Syntax Summary (informative).
Parameterless_Handler    section The Package Interrupts.
Params_Stream_Type    section Partition Communication Subsystem.
Parent    section Subunits of Compilation Units(20), see section Subunits of Compilation Units(21), see section Subunits of Compilation Units(20), see section Subunits of Compilation Units(21), see section Subunits of Compilation Units.
parent body
   of a subunit    section Subunits of Compilation Units.
parent declaration
   of a library_item    section Compilation Units - Library Units.
   of a library unit    section Compilation Units - Library Units.
parent subtype    section Derived Types and Classes.
parent type    section Derived Types and Classes.
parent unit
   of a library unit    section Compilation Units - Library Units.
parent_unit_name    section Compilation Units - Library Units.
   used    section Subprogram Declarations(5), see section Subprogram Declarations(7),     section Package Specifications and Declarations(5), see section Subprogram Declarations(7),     section Package Specifications and Declarations,
           section Package Bodies(2), see section Subunits of Compilation Units(7), see section Syntax Summary (informative)(2), see section Subunits of Compilation Units(7), see section Syntax Summary (informative).
Parser    section Task Units and Task Objects.
part
   of an object or value    section Types and Subtypes.
partial view
   of a type    section Private Types and Private Extensions.
partition    section Program Execution(2), see section Glossary (informative)(2), see section Glossary (informative).
partition building    section Program Execution.
partition communication subsystem (PCS)    section Partition Communication Subsystem.
Partition_Check
   [partial]    section Remote Subprogram Calls.
Partition_ID    section Partition Communication Subsystem.
Partition_ID attribute    section Partitions(9), see section Language-Defined Attributes (informative)(9), see section Language-Defined Attributes (informative).
pass by copy    section Formal Parameter Modes.
pass by reference    section Formal Parameter Modes.
passive partition    section Partitions.
PCS (partition communication subsystem)    section Partition Communication Subsystem.
pending interrupt occurrence    section Interrupt Support.
per-object constraint    section Record Types.
per-object expression    section Record Types.
Percent    section ASCII.
Percent_Sign    section The Package Characters.Latin_1.
perfect result set    section Model of Fixed Point Arithmetic.
periodic task
   See delay_until_statement    section Delay Statements, Duration, and Time.
   example    section Delay Statements, Duration, and Time.
Peripheral    section Variant Parts and Discrete Choices.
Peripheral_Ref    section Access Types.
Person    section Incomplete Type Declarations(19), see section Incomplete Type Declarations(19), see section Incomplete Type Declarations.
Person_Name    section Incomplete Type Declarations.
Pi    section The Numerics Packages.
Pic_String    section The Package Text_IO.Editing.
Picture    section The Package Text_IO.Editing.
picture String
   for edited output    section Picture String Formation.
Picture_Error    section The Package Text_IO.Editing.
Pilcrow_Sign    section The Package Characters.Latin_1.
plain_char    section Interfacing with C.
PLD    section The Package Characters.Latin_1.
PLU    section The Package Characters.Latin_1.
plus operator    section Expressions(1), see section Binary Adding Operators(1), see section Unary Adding Operators(1), see section Binary Adding Operators(1), see section Unary Adding Operators.
plus sign    section Character Set.
Plus_Minus_Sign    section The Package Characters.Latin_1.
Plus_Sign    section The Package Characters.Latin_1.
PM    section The Package Characters.Latin_1.
point    section General(2.15), see section Tagged Types and Type Extensions(2.15), see section Tagged Types and Type Extensions.
pointer    section The Generic Package Interfaces.C.Pointers.
   See access value    section Access Types.
   See type System.Address    section The Package System.
pointer type
   See access type    section Access Types.
Pointer_Error    section The Generic Package Interfaces.C.Pointers.
Pointers
   child of Interfaces.C    section The Generic Package Interfaces.C.Pointers.
polymorphism    section Tagged Types and Type Extensions(1), see section Dispatching Operations of Tagged Types(1), see section Dispatching Operations of Tagged Types.
pool element    section Access Types(7), see section Storage Management(7), see section Storage Management.
pool type    section Storage Management.
pool-specific access type    section Access Types(7), see section Access Types(7), see section Access Types.
Pop    section Example of a Generic Package(3), see section Example of a Generic Package(7), see section Example of a Generic Package(3), see section Example of a Generic Package(7), see section Example of a Generic Package.
Pos attribute    section Operations of Discrete Types(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
position    section Record Representation Clauses.
   used    section Record Representation Clauses(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Position attribute    section Storage Place Attributes(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
position number    section Scalar Types.
   of an enumeration value    section Enumeration Types.
   of an integer value    section Integer Types.
positional association    section Subprogram Calls(7), see section Generic Instantiation(7), see section Generic Instantiation.
positional component association    section Record Aggregates.
positional discriminant association    section Discriminant Constraints.
positional_array_aggregate    section Array Aggregates.
   used    section Array Aggregates(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Positive    section Integer Types(12), see section Integer Types(13), see section String Types(12), see section Integer Types(13), see section String Types,
            section The Package Standard.
Positive_Count    section The Generic Package Direct_IO(4),   section Text Input-Output(4),   section Text Input-Output,
                  section The Package Text_IO(5), see section The Package Streams.Stream_IO(5), see section The Package Streams.Stream_IO.
possible interpretation    section The Context of Overload Resolution.
   for direct_names    section Visibility.
   for selector_names    section Visibility.
post-compilation error    section Structure.
post-compilation rules    section Structure(29), see section Subunits of Compilation Units(29), see section Subunits of Compilation Units,
                          section Pragmas and Program Units(8), see section Program Execution(8), see section Program Execution,
                          section Generic Instantiation(19),   section Pragma Restrictions(19),   section Pragma Restrictions,
                          section The Standard Task Dispatching Policy(4),   section Priority Ceiling Locking(4),   section Priority Ceiling Locking,
                          section Entry Queuing Policies(5),     section Distributed Systems (normative)(5),     section Distributed Systems (normative),
                          section Partitions(2),     section Shared Passive Library Units(2),     section Shared Passive Library Units,
                          section Remote Call Interface Library Units(17), see section Pragma Normalize_Scalars(17), see section Pragma Normalize_Scalars,
                          section Pragma Reviewable.
potentially blocking operation    section Protected Subprograms and Protected Actions.
   Abort_Task    section The Package Task_Identification.
   delay_statement    section Delay Statements, Duration, and Time(34), see section Delay Accuracy(34), see section Delay Accuracy.
   remote subprogram call    section Remote Subprogram Calls.
   RPC operations    section Partition Communication Subsystem.
   Suspend_Until_True    section Synchronous Task Control.
potentially use-visible    section Use Clauses.
Pound_Sign    section The Package Characters.Latin_1.
Power_16    section Number Declarations.
Pragma    section Pragmas(1), see section Pragmas(2), see section Language-Defined Pragmas (informative)(1), see section Glossary (informative)(1), see section Pragmas(2), see section Language-Defined Pragmas (informative)(1), see section Glossary (informative).
pragma argument    section Pragmas.
pragma name    section Pragmas.
pragma, categorization    section Categorization of Library Units.
   Remote_Call_Interface    section Remote Call Interface Library Units.
   Remote_Types    section Remote Types Library Units.
   Shared_Passive    section Shared Passive Library Units.
pragma, configuration    section Pragmas and Program Units.
   Locking_Policy    section Priority Ceiling Locking.
   Normalize_Scalars    section Pragma Normalize_Scalars.
   Queuing_Policy    section Entry Queuing Policies.
   Restrictions    section Pragma Restrictions.
   Reviewable    section Pragma Reviewable.
   Suppress    section Suppressing Checks.
   Task_Dispatching_Policy    section The Standard Task Dispatching Policy.
pragma, identifier specific to    section Pragmas.
pragma, interfacing
   Convention    section Interfacing Pragmas.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
   Linker_Options    section Interfacing Pragmas.
pragma, library unit    section Pragmas and Program Units.
   All_Calls_Remote    section Remote Call Interface Library Units.
   categorization pragmas    section Categorization of Library Units.
   Elaborate_Body    section Elaboration Control.
   Preelaborate    section Elaboration Control.
   Pure    section Elaboration Control.
pragma, program unit    section Pragmas and Program Units.
   Convention    section Interfacing Pragmas.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
   Inline    section Inline Expansion of Subprograms.
   library unit pragmas    section Pragmas and Program Units.
pragma, representation    section Representation Items.
   Asynchronous    section Pragma Asynchronous.
   Atomic    section Shared Variable Control.
   Atomic_Components    section Shared Variable Control.
   Controlled    section Pragma Controlled.
   Convention    section Interfacing Pragmas.
   Discard_Names    section Pragma Discard_Names.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
   Pack    section Pragma Pack.
   Volatile    section Shared Variable Control.
   Volatile_Components    section Shared Variable Control.
pragma_argument_association    section Pragmas.
   used    section Pragmas(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
pragmas
   All_Calls_Remote    section Remote Call Interface Library Units(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
   Asynchronous    section Pragma Asynchronous(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Atomic    section Shared Variable Control(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Atomic_Components    section Shared Variable Control(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
   Attach_Handler    section Protected Procedure Handlers(4), see section Language-Defined Pragmas (informative)(4), see section Language-Defined Pragmas (informative).
   Controlled    section Pragma Controlled(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Convention    section Interfacing Pragmas(7), see section Language-Defined Pragmas (informative)(7), see section Language-Defined Pragmas (informative).
   Discard_Names    section Pragma Discard_Names(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Elaborate    section Elaboration Control(20), see section Language-Defined Pragmas (informative)(20), see section Language-Defined Pragmas (informative).
   Elaborate_All    section Elaboration Control(21), see section Language-Defined Pragmas (informative)(21), see section Language-Defined Pragmas (informative).
   Elaborate_Body    section Elaboration Control(22), see section Language-Defined Pragmas (informative)(22), see section Language-Defined Pragmas (informative).
   Export    section Interfacing Pragmas(6), see section Language-Defined Pragmas (informative)(6), see section Language-Defined Pragmas (informative).
   Import    section Interfacing Pragmas(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
   Inline    section Inline Expansion of Subprograms(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Inspection_Point    section Pragma Inspection_Point(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Interrupt_Handler    section Protected Procedure Handlers(2), see section Language-Defined Pragmas (informative)(2), see section Language-Defined Pragmas (informative).
   Interrupt_Priority    section Task Priorities(5), see section Language-Defined Pragmas (informative)(5), see section Language-Defined Pragmas (informative).
   Linker_Options    section Interfacing Pragmas(8), see section Language-Defined Pragmas (informative)(8), see section Language-Defined Pragmas (informative).
   List    section Pragmas(21), see section Language-Defined Pragmas (informative)(21), see section Language-Defined Pragmas (informative).
   Locking_Policy    section Priority Ceiling Locking(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Normalize_Scalars    section Pragma Normalize_Scalars(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Optimize    section Pragmas(23), see section Language-Defined Pragmas (informative)(23), see section Language-Defined Pragmas (informative).
   Pack    section Pragma Pack(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Page    section Pragmas(22), see section Language-Defined Pragmas (informative)(22), see section Language-Defined Pragmas (informative).
   Preelaborate    section Elaboration Control(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Priority    section Task Priorities(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Pure    section Elaboration Control(14), see section Language-Defined Pragmas (informative)(14), see section Language-Defined Pragmas (informative).
   Queuing_Policy    section Entry Queuing Policies(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Remote_Call_Interface    section Remote Call Interface Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Remote_Types    section Remote Types Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Restrictions    section Pragma Restrictions(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Reviewable    section Pragma Reviewable(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Shared_Passive    section Shared Passive Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
   Storage_Size    section Representation Attributes(63), see section Language-Defined Pragmas (informative)(63), see section Language-Defined Pragmas (informative).
   Suppress    section Suppressing Checks(4), see section Language-Defined Pragmas (informative)(4), see section Language-Defined Pragmas (informative).
   Task_Dispatching_Policy    section The Standard Task Dispatching Policy(2), see section Language-Defined Pragmas (informative)(2), see section Language-Defined Pragmas (informative).
   Volatile    section Shared Variable Control(4), see section Language-Defined Pragmas (informative)(4), see section Language-Defined Pragmas (informative).
   Volatile_Components    section Shared Variable Control(6), see section Language-Defined Pragmas (informative)(6), see section Language-Defined Pragmas (informative).
precedence of operators    section Operators and Expression Evaluation.
Pred attribute    section Scalar Types(25), see section Language-Defined Attributes (informative)(25), see section Language-Defined Attributes (informative).
predefined environment    section Predefined Language Environment (normative).
predefined exception    section Exception Declarations.
predefined library unit
   See   language-defined library units
predefined operation
   of a type    section Classification of Operations.
predefined operations
   of a discrete type    section Operations of Discrete Types.
   of a fixed point type    section Operations of Fixed Point Types.
   of a floating point type    section Operations of Floating Point Types.
   of a record type    section Record Types.
   of an access type    section Operations of Access Types.
   of an array type    section Operations of Array Types.
predefined operator    section Operators and Expression Evaluation.
   [partial]    section Type Declarations.
predefined type    section Type Declarations.
   See   language-defined types
preelaborable
   of an elaborable construct    section Elaboration Control.
Preelaborate pragma    section Elaboration Control(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
preelaborated    section Elaboration Control.
   [partial]    section Elaboration Control(11), see section Shared Passive Library Units(11), see section Shared Passive Library Units.
preempted task    section The Task Dispatching Model.
preemptible resource    section The Task Dispatching Model.
preference
   for root numeric operators and ranges    section The Context of Overload Resolution.
preference control
   See requeue    section Requeue Statements.
prefix    section Names.
   used    section Indexed Components(2), see section Slices(2), see section Selected Components(2), see section Slices(2), see section Selected Components,
           section Attributes(2), see section Attributes(4), see section Subprogram Calls(2), see section Attributes(4), see section Subprogram Calls,
           section Subprogram Calls(3),    section Syntax Summary (informative)(3),    section Syntax Summary (informative).
prescribed result
   for the evaluation of a complex arithmetic operation
         section Complex Types.
   for the evaluation of a complex elementary function
         section Complex Elementary Functions.
   for the evaluation of an elementary function    section Elementary Functions.
primary    section Expressions.
   used    section Expressions(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
primitive function    section Attributes of Floating Point Types.
primitive operation
   [partial]    section Types and Subtypes.
primitive operations    section Glossary (informative).
   of a type    section Classification of Operations.
primitive operator
   of a type    section Classification of Operations.
primitive subprograms
   of a type    section Classification of Operations.
Print_Header    section Subprogram Declarations.
Priority    section The Package System(16), see section Task Priorities(10), see section Task Priorities(16), see section Task Priorities(10), see section Task Priorities.
priority inheritance    section Task Priorities.
priority inversion    section The Standard Task Dispatching Policy.
priority of an entry call    section Entry Queuing Policies.
Priority pragma    section Task Priorities(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
private declaration of a library unit    section Compilation Units - Library Units.
private descendant
   of a library unit    section Compilation Units - Library Units.
private extension    section Types and Subtypes(4), see section Tagged Types and Type Extensions(2), see section Type Extensions(4), see section Tagged Types and Type Extensions(2), see section Type Extensions,
                     section Glossary (informative).
   [partial]    section Private Types and Private Extensions.
private library unit    section Compilation Units - Library Units.
private operations    section Private Operations.
private part    section Scope of Declarations.
   of a package    section Package Specifications and Declarations.
   of a protected unit    section Protected Units and Protected Objects.
   of a task unit    section Task Units and Task Objects.
private type    section Types and Subtypes(4), see section Glossary (informative)(4), see section Glossary (informative).
   [partial]    section Private Types and Private Extensions.
private types and private extensions    section Private Types and Private Extensions.
private_extension_declaration    section Private Types and Private Extensions.
   used    section Type Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
private_type_declaration    section Private Types and Private Extensions.
   used    section Type Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Probability    section Floating Point Types.
procedure    section Subprograms.
procedure instance    section Generic Instantiation.
procedure_call_statement    section Subprogram Calls.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
processing node    section Distributed Systems (normative).
Producer    section Example of Tasking and Synchronization(2), see section Example of Tasking and Synchronization(2), see section Example of Tasking and Synchronization.
profile    section Subprogram Declarations.
   associated with a dereference    section Names.
   fully conformant    section Conformance Rules.
   mode conformant    section Conformance Rules.
   subtype conformant    section Conformance Rules.
   type conformant    section Conformance Rules.
profile resolution rule
   name with a given expected profile    section The Context of Overload Resolution.
Prog    section Interfacing with COBOL.
program    section Program Execution(1), see section Glossary (informative)(1), see section Glossary (informative).
program execution    section Program Execution.
program library
   See library    section Program Structure and Compilation Issues(2), see section The Compilation Process(2), see section The Compilation Process.
Program unit    section Separate Compilation(1), see section Glossary (informative)(1), see section Glossary (informative).
program unit pragma    section Pragmas and Program Units.
   Convention    section Interfacing Pragmas.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
   Inline    section Inline Expansion of Subprograms.
   library unit pragmas    section Pragmas and Program Units.
Program_Error    section The Package Standard.
   raised by failure of run-time check
         section Conformity of an Implementation with the Standard(20),    section Classification of Errors(8),     section Classification of Errors(20),    section Classification of Errors(8),     section Classification of Errors,
         section Operations of Discrete Types(8),     section Operations of Access Types(29),   section Declarative Parts(8),     section Operations of Access Types(29),   section Declarative Parts,
         section Type Conversions(57),      section Formal Parameter Modes(12),      section Subprogram Calls(57),      section Formal Parameter Modes(12),      section Subprogram Calls,
         section Return Statements(20),      section Completion and Finalization(15),    section Completion and Finalization(20),      section Completion and Finalization(15),    section Completion and Finalization,
         section Completion and Finalization(17),    section Completion and Finalization(18),    section Protected Units and Protected Objects(17),    section Completion and Finalization(18),    section Protected Units and Protected Objects,
         section Protected Subprograms and Protected Actions(17),    section Entry Calls(7),     section Selective Accept(17),    section Entry Calls(7),     section Selective Accept,
         section Abort of a Task - Abort of a Sequence of Statements(20),      section Program Execution(26),     section Exception Declarations(20),      section Program Execution(26),     section Exception Declarations,
         section Suppressing Checks(19),     section The Package System.Storage_Elements(16),   section Data Validity(19),     section The Package System.Storage_Elements(16),   section Data Validity,
         section Unchecked Storage Deallocation(13), see section Unchecked Storage Deallocation(14), see section External Files and File Objects(13), see section Unchecked Storage Deallocation(14), see section External Files and File Objects,
         section Protected Procedure Handlers(10),    section Protected Procedure Handlers(11),    section The Package Interrupts(10),    section Protected Procedure Handlers(11),    section The Package Interrupts,
         section The Package Interrupts(20),    section The Package Interrupts(21),    section The Package Interrupts(20),    section The Package Interrupts(21),    section The Package Interrupts,
         section The Package Task_Identification(15),    section The Package Task_Identification(17),    section The Package Task_Attributes(15),    section The Package Task_Identification(17),    section The Package Task_Attributes,
         section Priority Ceiling Locking(13),      section Dynamic Priorities(9),       section Dynamic Priorities(13),      section Dynamic Priorities(9),       section Dynamic Priorities,
         section Synchronous Task Control(10),     section Asynchronous Task Control(8),      section Partitions(10),     section Asynchronous Task Control(8),      section Partitions,
         section Consistency of a Distributed System(6),       section Remote Subprogram Calls(18),      section Interrupt Entries(6),       section Remote Subprogram Calls(18),      section Interrupt Entries.
Program_Status_Word    section Record Representation Clauses.
propagate    section Exception Handling.
   an exception occurrence by an execution, to a dynamically
        enclosing execution    section Exception Handling.
proper_body    section Declarative Parts.
   used    section Declarative Parts(5), see section Subunits of Compilation Units(7), see section Syntax Summary (informative)(5), see section Subunits of Compilation Units(7), see section Syntax Summary (informative).
protected action    section Protected Subprograms and Protected Actions.
   complete    section Protected Subprograms and Protected Actions.
   start    section Protected Subprograms and Protected Actions.
protected calling convention    section Conformance Rules.
protected declaration    section Protected Units and Protected Objects.
protected entry    section Protected Units and Protected Objects.
protected function    section Protected Subprograms and Protected Actions.
protected object    section Tasks and Synchronization(3), see section Protected Units and Protected Objects(3), see section Protected Units and Protected Objects.
protected operation    section Protected Units and Protected Objects.
protected procedure    section Protected Subprograms and Protected Actions.
protected subprogram    section Protected Units and Protected Objects(1), see section Protected Subprograms and Protected Actions(1), see section Protected Subprograms and Protected Actions.
Protected type    section Glossary (informative).
protected unit    section Protected Units and Protected Objects.
protected_body    section Protected Units and Protected Objects.
   used    section Declarative Parts(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
protected_body_stub    section Subunits of Compilation Units.
   used    section Subunits of Compilation Units(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
protected_definition    section Protected Units and Protected Objects.
   used    section Protected Units and Protected Objects(2), see section Protected Units and Protected Objects(3), see section Syntax Summary (informative)(2), see section Protected Units and Protected Objects(3), see section Syntax Summary (informative).
protected_element_declaration    section Protected Units and Protected Objects.
   used    section Protected Units and Protected Objects(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
protected_operation_declaration    section Protected Units and Protected Objects.
   used    section Protected Units and Protected Objects(4), see section Protected Units and Protected Objects(6), see section Syntax Summary (informative)(4), see section Protected Units and Protected Objects(6), see section Syntax Summary (informative).
protected_operation_item    section Protected Units and Protected Objects.
   used    section Protected Units and Protected Objects(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
protected_type_declaration    section Protected Units and Protected Objects.
   used    section Type Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
ptrdiff_t    section Interfacing with C.
PU1    section The Package Characters.Latin_1.
PU2    section The Package Characters.Latin_1.
public declaration of a library unit    section Compilation Units - Library Units.
public descendant
   of a library unit    section Compilation Units - Library Units.
public library unit    section Compilation Units - Library Units.
pure    section Elaboration Control.
Pure pragma    section Elaboration Control(14), see section Language-Defined Pragmas (informative)(14), see section Language-Defined Pragmas (informative).
Push    section Subprogram Bodies(9), see section Example of a Generic Package(3), see section Example of a Generic Package(6), see section Example of a Generic Package(9), see section Example of a Generic Package(3), see section Example of a Generic Package(6), see section Example of a Generic Package.
Put    section Subprogram Calls(26),     section Compilation Units - Library Units(30), see section The Package Text_IO(26),     section Compilation Units - Library Units(30), see section The Package Text_IO,
       section The Package Text_IO(48), see section The Package Text_IO(55), see section The Package Text_IO(48), see section The Package Text_IO(55), see section The Package Text_IO,
       section The Package Text_IO(66), see section The Package Text_IO(67), see section The Package Text_IO(66), see section The Package Text_IO(67), see section The Package Text_IO,
       section The Package Text_IO(72), see section The Package Text_IO(76), see section The Package Text_IO(72), see section The Package Text_IO(76), see section The Package Text_IO,
       section The Package Text_IO(82), see section The Package Text_IO(83), see section The Package Text_IO.Editing(82), see section The Package Text_IO(83), see section The Package Text_IO.Editing,
       section The Package Text_IO.Editing(15),   section The Package Text_IO.Editing(16),   section Complex Input-Output(15),   section The Package Text_IO.Editing(16),   section Complex Input-Output,
       section Complex Input-Output.
Put_Item    section Formal Subprograms.
Put_Line    section The Package Text_IO.
Put_List    section Formal Subprograms.

Index

qualified_expression    section Qualified Expressions.
   used    section Expressions(7), see section Allocators(2), see section Machine Code Insertions(2), see section Syntax Summary (informative)(7), see section Allocators(2), see section Machine Code Insertions(2), see section Syntax Summary (informative).
Query    section ASCII.
Question    section String Types(7), see section The Package Characters.Latin_1(7), see section The Package Characters.Latin_1.
queuing policy    section Entry Queuing Policies(1), see section Entry Queuing Policies(1), see section Entry Queuing Policies.
Queuing_Policy pragma    section Entry Queuing Policies(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Quotation    section The Package Characters.Latin_1.
quotation mark    section Character Set.
quoted string
   See string_literal    section String Literals.
Quotient_Type    section The Package Decimal.

index

R    section Formal Array Types(15), see section Formal Access Types(15), see section Formal Access Types.
R_Brace    section ASCII.
R_Bracket    section ASCII.
Rad_To_Deg    section Static Expressions and Static Subtypes.
Rainbow    section Subtype Declarations(15), see section Enumeration Types(15), see section Enumeration Types.
raise
   an exception    section Exceptions(1), see section Raise Statements(4), see section Glossary (informative)(1), see section Raise Statements(4), see section Glossary (informative).
   an exception occurrence    section Exception Handling.
Raise_Exception    section The Package Exceptions.
raise_statement    section Raise Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Random    section Subprogram Declarations(38), see section Random Number Generation(8), see section Random Number Generation(38), see section Random Number Generation(8), see section Random Number Generation.
random number    section Random Number Generation.
Random_Coin section Random Number Generation(58)
Random_Die    section Random Number Generation.
range    section Scalar Types(3), see section Scalar Types(3), see section Scalar Types.
   used    section Scalar Types(2), see section Array Types(6), see section Index Constraints and Discrete Ranges(2), see section Array Types(6), see section Index Constraints and Discrete Ranges,
           section Expressions(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
   of a scalar subtype    section Scalar Types.
Range attribute    section Scalar Types(14), see section Operations of Array Types(14), see section Operations of Array Types,
                   section Language-Defined Attributes (informative)(187),   section Language-Defined Attributes (informative)(187),   section Language-Defined Attributes (informative).
Range(N) attribute    section Operations of Array Types(8), see section Language-Defined Attributes (informative)(8), see section Language-Defined Attributes (informative).
range_attribute_designator    section Attributes.
   used    section Attributes(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
range_attribute_reference    section Attributes.
   used    section Scalar Types(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Range_Check    section Suppressing Checks.
   [partial]    section Subtype Declarations(11), see section Scalar Types(24),      section Scalar Types(11), see section Scalar Types(24),      section Scalar Types,
                section Scalar Types(43),    section Scalar Types(44),      section Scalar Types(43),    section Scalar Types(44),      section Scalar Types,
                section Scalar Types(55),    section Operations of Discrete Types(7),     section Fixed Point Types(55),    section Operations of Discrete Types(7),     section Fixed Point Types,
                section Literals(11),    section Array Aggregates(28),    section Logical Operators and Short-circuit Control Forms(11),    section Array Aggregates(28),    section Logical Operators and Short-circuit Control Forms,
                section Highest Precedence Operators(6),   section Highest Precedence Operators(13),    section Type Conversions(6),   section Highest Precedence Operators(13),    section Type Conversions,
                section Type Conversions(38),    section Type Conversions(46),      section Type Conversions(38),    section Type Conversions(46),      section Type Conversions,
                section Qualified Expressions(4),     section Stream-Oriented Attributes(35), see section Random Number Generation(4),     section Stream-Oriented Attributes(35), see section Random Number Generation,
                section Random Number Generation(40), see section Attributes of Floating Point Types(26),    section Attributes of Floating Point Types(40), see section Attributes of Floating Point Types(26),    section Attributes of Floating Point Types,
                section Attributes of Floating Point Types(50), see section Attributes of Floating Point Types(53),    section Attributes of Floating Point Types(50), see section Attributes of Floating Point Types(53),    section Attributes of Floating Point Types,
                section Attributes of Floating Point Types(62), see section Language-Defined Attributes (informative)(11),        section Language-Defined Attributes (informative)(62), see section Language-Defined Attributes (informative)(11),        section Language-Defined Attributes (informative),
                section Language-Defined Attributes (informative)(47),      section Language-Defined Attributes (informative)(114),       section Language-Defined Attributes (informative)(47),      section Language-Defined Attributes (informative)(114),       section Language-Defined Attributes (informative),
                section Language-Defined Attributes (informative)(184),     section Language-Defined Attributes (informative)(220),       section Language-Defined Attributes (informative)(184),     section Language-Defined Attributes (informative)(220),       section Language-Defined Attributes (informative).
range_constraint    section Scalar Types.
   used    section Subtype Declarations(6), see section Fixed Point Types(6), see section Fixed Point Types,
           section Reduced Accuracy Subtypes(2),    section Syntax Summary (informative)(2),    section Syntax Summary (informative).
Rank    section Formal Types(16), see section Interfacing with Fortran(16), see section Interfacing with Fortran.
Rational    section Package Specifications and Declarations.
Rational_Numbers    section Package Specifications and Declarations(12), see section Package Bodies(10), see section Compilation Units - Library Units(12), see section Package Bodies(10), see section Compilation Units - Library Units.
Rational_Numbers.Reduce    section Compilation Units - Library Units.
Rational_Numbers.IO    section Compilation Units - Library Units.
Rational_IO    section Compilation Units - Library Units.
RCI
   generic    section Remote Call Interface Library Units.
   library unit    section Remote Call Interface Library Units.
   package    section Remote Call Interface Library Units.
Re    section Complex Types.
re-raise statement    section Raise Statements.
read    section Limited Types(19),     section Limited Types(20),     section Task Units and Task Objects(19),     section Limited Types(20),     section Task Units and Task Objects,
        section Entries and Accept Statements(33),   section Example of Tasking and Synchronization(8),     section Example of Tasking and Synchronization(33),   section Example of Tasking and Synchronization(8),     section Example of Tasking and Synchronization,
        section Example of Exception Handling(4),   section Example of Exception Handling(7),   section The Package Streams(4),   section Example of Exception Handling(7),   section The Package Streams,
        section The Generic Package Sequential_IO(12),   section The Generic Package Direct_IO(12),   section The Generic Package Storage_IO(12),   section The Generic Package Direct_IO(12),   section The Generic Package Storage_IO,
        section The Package Streams.Stream_IO(15), see section The Package Streams.Stream_IO(16), see section Other Optimizations and Determinism Rules(15), see section The Package Streams.Stream_IO(16), see section Other Optimizations and Determinism Rules,
        section Other Optimizations and Determinism Rules(10),    section Partition Communication Subsystem(10),    section Partition Communication Subsystem.
   the value of an object    section Objects and Named Numbers.
Read attribute    section Stream-Oriented Attributes(6), see section Stream-Oriented Attributes(6), see section Stream-Oriented Attributes,
                  section Language-Defined Attributes (informative)(191),      section Language-Defined Attributes (informative)(191),      section Language-Defined Attributes (informative).
Read clause    section Representation Attributes(7), see section Stream-Oriented Attributes(7), see section Stream-Oriented Attributes.
ready
   a task state    section Tasks and Synchronization.
ready queue    section The Task Dispatching Model.
ready task    section The Task Dispatching Model.
Real    section Floating Point Types(21), see section Interfacing with Fortran(6), see section Complex Types(21), see section Interfacing with Fortran(6), see section Complex Types.
real literal    section Numeric Literals.
real literals    section Real Types.
real time    section Monotonic Time.
real type    section Types and Subtypes(3), see section Real Types(1), see section Glossary (informative)(3), see section Real Types(1), see section Glossary (informative).
real-time systems    section Systems Programming (normative)(1), see section Real-Time Systems (normative)(1), see section Real-Time Systems (normative).
Real_Plus    section Subprogram Renaming Declarations.
real_range_specification    section Floating Point Types.
   used    section Floating Point Types(2), see section Fixed Point Types(2), see section Fixed Point Types,
           section Fixed Point Types(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Real_Time
   child of Ada    section Monotonic Time.
real_type_definition    section Real Types.
   used    section Type Declarations(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Real_IO    section Input-Output for Real Types.
receiving stub    section Remote Subprogram Calls.
reclamation of storage    section Unchecked Storage Deallocation.
recommended level of support    section Representation Items.
   enumeration_representation_clause    section Enumeration Representation Clauses.
   record_representation_clause    section Record Representation Clauses.
   Address attribute    section Representation Attributes.
   Alignment attribute for objects    section Representation Attributes.
   Alignment attribute for subtypes    section Representation Attributes.
   bit ordering    section Bit Ordering.
   Component_Size attribute    section Representation Attributes.
   pragma Pack    section Pragma Pack.
   required in Systems Programming Annex    section Required Representation Support.
   Size attribute    section Representation Attributes(42), see section Representation Attributes(42), see section Representation Attributes.
   unchecked conversion    section Unchecked Type Conversions.
   with respect to nonstatic expressions    section Representation Items.
record    section Record Types.
record extension    section Derived Types and Classes(5), see section Type Extensions(1), see section Glossary (informative)(5), see section Type Extensions(1), see section Glossary (informative).
record layout
   aspect of representation    section Record Layout.
record type    section Record Types(1), see section Glossary (informative)(1), see section Glossary (informative).
record_aggregate    section Record Aggregates.
   used    section Aggregates(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
record_component_association    section Record Aggregates.
   used    section Record Aggregates(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
record_component_association_list    section Record Aggregates.
   used    section Record Aggregates(2), see section Extension Aggregates(2), see section Syntax Summary (informative)(2), see section Extension Aggregates(2), see section Syntax Summary (informative).
record_definition    section Record Types.
   used    section Record Types(2), see section Type Extensions(2), see section Syntax Summary (informative)(2), see section Type Extensions(2), see section Syntax Summary (informative).
record_extension_part    section Type Extensions.
   used    section Derived Types and Classes(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
record_representation_clause    section Record Representation Clauses.
   used    section Representation Items(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
record_type_definition    section Record Types.
   used    section Type Declarations(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Red_Blue    section Subtype Declarations.
Reference    section The Package Interrupts(10), see section The Package Task_Attributes(10), see section The Package Task_Attributes.
reference parameter passing    section Formal Parameter Modes.
references    section Normative References.
Register    section Example of Use of a Remote Access-to-Class-Wide Type.
Registered_Trade_Mark_Sign    section The Package Characters.Latin_1.
Reinitialize    section The Package Task_Attributes.
relation    section Expressions.
   used    section Expressions(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
relational operator    section Relational Operators and Membership Tests.
relational_operator    section Operators and Expression Evaluation.
   used    section Expressions(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
relaxed mode    section Numeric Performance Requirements.
Release    section Protected Units and Protected Objects(27), see section Protected Units and Protected Objects(27), see section Protected Units and Protected Objects.
   execution resource associated with protected object
         section Protected Subprograms and Protected Actions.
rem operator    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
Remainder attribute    section Attributes of Floating Point Types(45), see section Language-Defined Attributes (informative)(45), see section Language-Defined Attributes (informative).
Remainder_Type    section The Package Decimal.
remote access    section Partitions.
remote access type    section Remote Types Library Units.
remote access-to-class-wide type    section Remote Types Library Units.
remote access-to-subprogram type    section Remote Types Library Units.
remote call interface    section Categorization of Library Units(4), see section Remote Call Interface Library Units(4), see section Remote Call Interface Library Units.
remote procedure call
   asynchronous    section Pragma Asynchronous.
remote subprogram    section Remote Call Interface Library Units.
remote subprogram binding    section Remote Subprogram Calls.
remote subprogram call    section Remote Subprogram Calls.
remote types library unit    section Categorization of Library Units(4), see section Remote Types Library Units(4), see section Remote Types Library Units.
Remote_Call_Interface pragma    section Remote Call Interface Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Remote_Types pragma    section Remote Types Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Remove    section Example of Use of a Remote Access-to-Class-Wide Type.
renamed entity    section Renaming Declarations.
renamed view    section Renaming Declarations.
renaming-as-body    section Subprogram Renaming Declarations.
renaming-as-declaration    section Subprogram Renaming Declarations.
renaming_declaration    section Renaming Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
rendezvous    section Entries and Accept Statements.
Replace_Element    section Bounded-Length String Handling(27), see section Unbounded-Length String Handling(27), see section Unbounded-Length String Handling.
Replace_Slice    section Fixed-Length String Handling(23), see section Fixed-Length String Handling(23), see section Fixed-Length String Handling,
                 section Bounded-Length String Handling(58), see section Bounded-Length String Handling(58), see section Bounded-Length String Handling,
                 section Unbounded-Length String Handling(53), see section Unbounded-Length String Handling(53), see section Unbounded-Length String Handling.
Replicate    section Bounded-Length String Handling(78), see section Bounded-Length String Handling(79), see section Bounded-Length String Handling(78), see section Bounded-Length String Handling(79), see section Bounded-Length String Handling.
representation
   change of    section Change of Representation.
representation aspect    section Representation Items.
representation attribute    section Representation Attributes.
representation item    section Representation Items.
representation of an object    section Representation Items.
representation pragma    section Representation Items.
   Asynchronous    section Pragma Asynchronous.
   Atomic    section Shared Variable Control.
   Atomic_Components    section Shared Variable Control.
   Controlled    section Pragma Controlled.
   Convention    section Interfacing Pragmas.
   Discard_Names    section Pragma Discard_Names.
   Export    section Interfacing Pragmas.
   Import    section Interfacing Pragmas.
   Pack    section Pragma Pack.
   Volatile    section Shared Variable Control.
   Volatile_Components    section Shared Variable Control.
representation-oriented attributes
   of a fixed point subtype    section Attributes of Fixed Point Types.
   of a floating point subtype    section Attributes of Floating Point Types.
representation_clause    section Representation Items.
   used    section Record Types(5), see section Declarative Parts(4), see section Task Units and Task Objects(5), see section Declarative Parts(4), see section Task Units and Task Objects,
           section Protected Units and Protected Objects(5), see section Protected Units and Protected Objects(8),   section Syntax Summary (informative)(5), see section Protected Units and Protected Objects(8),   section Syntax Summary (informative).
represented in canonical form    section Attributes of Floating Point Types.
Request    section Task Units and Task Objects(26), see section Entries and Accept Statements(26), see section Entries and Accept Statements.
requested decimal precision
   of a floating point type    section Floating Point Types.
requeue    section Requeue Statements.
requeue-with-abort    section Requeue Statements.
requeue_statement    section Requeue Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
requires a completion    section Completions of Declarations(1), see section Completions of Declarations(1), see section Completions of Declarations.
   incomplete_type_declaration    section Incomplete Type Declarations.
   protected_declaration    section Protected Units and Protected Objects.
   task_declaration    section Task Units and Task Objects.
   generic_package_declaration    section Package Specifications and Declarations.
   generic_subprogram_declaration    section Subprogram Declarations.
   package_declaration    section Package Specifications and Declarations.
   subprogram_declaration    section Subprogram Declarations.
   declaration of a partial view    section Private Types and Private Extensions.
   declaration to which a pragma Elaborate_Body applies
         section Elaboration Control.
   deferred constant declaration    section Deferred Constants.
   protected entry_declaration    section Entries and Accept Statements.
Reraise_Occurrence    section The Package Exceptions.
reserved interrupt    section Interrupt Support.
reserved word    section Reserved Words.
Reserved_128    section The Package Characters.Latin_1.
Reserved_129    section The Package Characters.Latin_1.
Reserved_132    section The Package Characters.Latin_1.
Reserved_153    section The Package Characters.Latin_1.
Reserved_Check
   [partial]    section Protected Procedure Handlers.
Reset    section Random Number Generation(9),   section Random Number Generation(12), see section Random Number Generation(9),   section Random Number Generation(12), see section Random Number Generation,
         section Random Number Generation(24), see section The Generic Package Sequential_IO(8),   section The Generic Package Direct_IO(24), see section The Generic Package Sequential_IO(8),   section The Generic Package Direct_IO,
         section The Package Text_IO(11), see section The Package Streams.Stream_IO(11), see section The Package Streams.Stream_IO.
resolution rules    section Structure.
resolve
   overload resolution    section The Context of Overload Resolution.
Resource    section Protected Units and Protected Objects(27), see section Protected Units and Protected Objects(27), see section Protected Units and Protected Objects.
restriction    section Pragma Restrictions.
   used    section Pragma Restrictions(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Restrictions
   Immediate_Reclamation    section Safety and Security Restrictions.
   Max_Asynchronous_Select_Nesting    section Tasking Restrictions.
   Max_Protected_Entries    section Tasking Restrictions.
   Max_Select_Alternatives    section Tasking Restrictions.
   Max_Storage_At_Blocking    section Tasking Restrictions.
   Max_Task_Entries    section Tasking Restrictions.
   Max_Tasks    section Tasking Restrictions.
   No_Abort_Statements    section Tasking Restrictions.
   No_Access_Subprograms    section Safety and Security Restrictions.
   No_Allocators    section Safety and Security Restrictions.
   No_Asynchronous_Control    section Tasking Restrictions.
   No_Delay    section Safety and Security Restrictions.
   No_Dispatch    section Safety and Security Restrictions.
   No_Dynamic_Priorities    section Tasking Restrictions.
   No_Exceptions    section Safety and Security Restrictions.
   No_Fixed_Point    section Safety and Security Restrictions.
   No_Floating_Point    section Safety and Security Restrictions.
   No_Implicit_Heap_Allocations    section Tasking Restrictions.
   No_Local_Allocators    section Safety and Security Restrictions.
   No_Nested_Finalization    section Tasking Restrictions.
   No_Protected_Types    section Safety and Security Restrictions.
   No_Recursion    section Safety and Security Restrictions.
   No_Reentrancy    section Safety and Security Restrictions.
   No_Task_Allocators    section Tasking Restrictions.
   No_Task_Hierarchy    section Tasking Restrictions.
   No_Terminate_Alternatives    section Tasking Restrictions.
   No_Unchecked_Access    section Safety and Security Restrictions.
   No_Unchecked_Conversion    section Safety and Security Restrictions.
   No_Unchecked_Deallocation    section Safety and Security Restrictions.
   No_IO    section Safety and Security Restrictions.
Restrictions pragma    section Pragma Restrictions(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
result interval
   for a component of the result of evaluating
     a complex function    section Accuracy Requirements for Complex Arithmetic.
   for the evaluation of a predefined arithmetic
     operation    section Model of Floating Point Arithmetic.
   for the evaluation of an elementary function    section Accuracy Requirements for the Elementary Functions.
result subtype
   of a function    section Return Statements.
Result_Subtype    section Random Number Generation.
return expression    section Return Statements.
return-by-reference type    section Return Statements.
return_statement    section Return Statements.
   used    section Simple and Compound Statements - Sequences of Statements(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Reverse_Solidus    section The Package Characters.Latin_1.
Reviewable pragma    section Pragma Reviewable(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Rewind    section Example of Use of a Remote Access-to-Class-Wide Type(2), see section Example of Use of a Remote Access-to-Class-Wide Type(2), see section Example of Use of a Remote Access-to-Class-Wide Type.
RI    section The Package Characters.Latin_1.
right curly bracket    section Character Set.
right parenthesis    section Character Set.
right square bracket    section Character Set.
Right_Angle_Quotation    section The Package Characters.Latin_1.
Right_Curly_Bracket    section The Package Characters.Latin_1.
Right_Indent    section Subprogram Declarations.
Right_Parenthesis    section The Package Characters.Latin_1.
Right_Square_Bracket    section The Package Characters.Latin_1.
Roman    section Array Types.
Roman_Digit    section Character Types.
root library unit    section Compilation Units - Library Units.
root type
   of a class    section Derivation Classes.
root_integer    section Integer Types.
   [partial]    section Derivation Classes.
root_real    section Real Types.
   [partial]    section Derivation Classes.
Root_Storage_Pool    section Storage Management.
Root_Stream_Type    section The Package Streams.
rooted at a type    section Derivation Classes.
Rosso    section Subprogram Renaming Declarations.
Rot    section Subprogram Renaming Declarations.
rotate    section The Package Interfaces.
Rotate_Left    section The Package Interfaces.
Rotate_Right    section The Package Interfaces.
Rouge    section Subprogram Renaming Declarations.
Round attribute    section Operations of Fixed Point Types(12), see section Language-Defined Attributes (informative)(12), see section Language-Defined Attributes (informative).
Rounding attribute    section Attributes of Floating Point Types(36), see section Language-Defined Attributes (informative)(36), see section Language-Defined Attributes (informative).
Row    section Generic Declarations.
RPC
   child of System    section Partition Communication Subsystem.
RPC-receiver    section Partition Communication Subsystem.
RPC_Receiver    section Partition Communication Subsystem.
RS    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
run-time check
   See language-defined check    section Suppressing Checks.
run-time error    section Structure(30), see section Classification of Errors(30), see section Classification of Errors,
                  section Suppressing Checks(2),    section Exceptions and Optimization(2),    section Exceptions and Optimization.
run-time polymorphism    section Dispatching Operations of Tagged Types.
run-time semantics    section Structure.
run-time type
   See tag    section Tagged Types and Type Extensions.
running a program
   See program execution    section Program Execution.
running task    section The Task Dispatching Model.

index

S'Adjacent    section Attributes of Floating Point Types(49), see section Language-Defined Attributes (informative)(49), see section Language-Defined Attributes (informative).
S'Ceiling    section Attributes of Floating Point Types(34), see section Language-Defined Attributes (informative)(34), see section Language-Defined Attributes (informative).
S'Class'Input    section Stream-Oriented Attributes(33), see section Language-Defined Attributes (informative)(33), see section Language-Defined Attributes (informative).
S'Class'Output    section Stream-Oriented Attributes(30), see section Language-Defined Attributes (informative)(30), see section Language-Defined Attributes (informative).
S'Class'Read    section Stream-Oriented Attributes(15), see section Language-Defined Attributes (informative)(15), see section Language-Defined Attributes (informative).
S'Class'Write    section Stream-Oriented Attributes(12), see section Language-Defined Attributes (informative)(12), see section Language-Defined Attributes (informative).
S'Compose    section Attributes of Floating Point Types(25), see section Language-Defined Attributes (informative)(25), see section Language-Defined Attributes (informative).
S'Copy_Sign    section Attributes of Floating Point Types(52), see section Language-Defined Attributes (informative)(52), see section Language-Defined Attributes (informative).
S'Exponent    section Attributes of Floating Point Types(19), see section Language-Defined Attributes (informative)(19), see section Language-Defined Attributes (informative).
S'Floor    section Attributes of Floating Point Types(31), see section Language-Defined Attributes (informative)(31), see section Language-Defined Attributes (informative).
S'Fraction    section Attributes of Floating Point Types(22), see section Language-Defined Attributes (informative)(22), see section Language-Defined Attributes (informative).
S'Input    section Stream-Oriented Attributes(23), see section Language-Defined Attributes (informative)(23), see section Language-Defined Attributes (informative).
S'Leading_Part    section Attributes of Floating Point Types(55), see section Language-Defined Attributes (informative)(55), see section Language-Defined Attributes (informative).
S'Machine    section Attributes of Floating Point Types(61), see section Language-Defined Attributes (informative)(61), see section Language-Defined Attributes (informative).
S'Model    section Attributes of Floating Point Types(69), see section Language-Defined Attributes (informative)(69), see section Language-Defined Attributes (informative).
S'Output    section Stream-Oriented Attributes(20), see section Language-Defined Attributes (informative)(20), see section Language-Defined Attributes (informative).
S'Read    section Stream-Oriented Attributes(7), see section Language-Defined Attributes (informative)(7), see section Language-Defined Attributes (informative).
S'Remainder    section Attributes of Floating Point Types(46), see section Language-Defined Attributes (informative)(46), see section Language-Defined Attributes (informative).
S'Rounding    section Attributes of Floating Point Types(37), see section Language-Defined Attributes (informative)(37), see section Language-Defined Attributes (informative).
S'Scaling    section Attributes of Floating Point Types(28), see section Language-Defined Attributes (informative)(28), see section Language-Defined Attributes (informative).
S'Truncation    section Attributes of Floating Point Types(43), see section Language-Defined Attributes (informative)(43), see section Language-Defined Attributes (informative).
S'Unbiased_Rounding    section Attributes of Floating Point Types(40), see section Language-Defined Attributes (informative)(40), see section Language-Defined Attributes (informative).
S'Write    section Stream-Oriented Attributes(4), see section Language-Defined Attributes (informative)(4), see section Language-Defined Attributes (informative).
safe range
   of a floating point type    section Floating Point Types(9), see section Floating Point Types(9), see section Floating Point Types.
Safe_First attribute    section Attributes of Floating Point Types(71), see section Model-Oriented Attributes of Floating Point Types(71), see section Model-Oriented Attributes of Floating Point Types,
                        section Language-Defined Attributes (informative).
Safe_Last attribute    section Attributes of Floating Point Types(72), see section Model-Oriented Attributes of Floating Point Types(72), see section Model-Oriented Attributes of Floating Point Types,
                       section Language-Defined Attributes (informative).
safety-critical systems    section Safety and Security (normative).
Salary    section Fixed Point Types.
Salary_Conversions    section Interfacing with COBOL(108), see section Interfacing with COBOL(108), see section Interfacing with COBOL.
Salary_Type    section Interfacing with COBOL(105), see section Interfacing with COBOL(105), see section Interfacing with COBOL.
Same_Denominator    section Package Bodies.
satisfies
   a discriminant constraint    section Discriminant Constraints.
   a range constraint    section Scalar Types.
   an index constraint    section Index Constraints and Discrete Ranges.
   for an access value    section Access Types.
Save    section Random Number Generation(12), see section Random Number Generation(12), see section Random Number Generation.
Save_Occurrence    section The Package Exceptions.
scalar type    section Types and Subtypes(3), see section Scalar Types(1), see section Glossary (informative)(3), see section Scalar Types(1), see section Glossary (informative).
scalar_constraint    section Subtype Declarations.
   used    section Subtype Declarations(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
scale
   of a decimal fixed point subtype    section Operations of Fixed Point Types,
                                       section Language-Defined Attributes (informative).
Scale attribute    section Operations of Fixed Point Types(11), see section Language-Defined Attributes (informative)(11), see section Language-Defined Attributes (informative).
Scaling attribute    section Attributes of Floating Point Types(27), see section Language-Defined Attributes (informative)(27), see section Language-Defined Attributes (informative).
SCHAR_MAX    section Interfacing with C.
SCHAR_MIN    section Interfacing with C.
Schedule    section Array Types.
scope
   informal definition    section Declarations.
   of (a view of) an entity    section Scope of Declarations.
   of a use_clause    section Use Clauses.
   of a with_clause    section Context Clauses - With Clauses.
   of a declaration    section Scope of Declarations.
Seconds    section Delay Statements, Duration, and Time.
Seconds_Count    section Monotonic Time.
Section_Sign    section The Package Characters.Latin_1.
secure systems    section Safety and Security (normative).
Seize    section Protected Units and Protected Objects(27), see section Protected Units and Protected Objects(28), see section Entries and Accept Statements(27), see section Protected Units and Protected Objects(28), see section Entries and Accept Statements.
select an entry call
   from an entry queue    section Entry Calls(13), see section Entry Calls(13), see section Entry Calls.
   immediately    section Entry Calls.
select_alternative    section Selective Accept.
   used    section Selective Accept(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
select_statement    section Select Statements.
   used    section Simple and Compound Statements - Sequences of Statements(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
selected_component    section Selected Components.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
selection
   of an entry caller    section Entries and Accept Statements.
selective_accept    section Selective Accept.
   used    section Select Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
selector_name    section Selected Components.
   used    section Discriminant Constraints(3), see section Selected Components(2), see section Record Aggregates(3), see section Selected Components(2), see section Record Aggregates,
           section Subprogram Calls(5),    section Generic Instantiation(4),   section Syntax Summary (informative)(5),    section Generic Instantiation(4),   section Syntax Summary (informative).
semantic dependence
   of one compilation unit upon another    section Compilation Units - Library Units.
semicolon    section Character Set(15), see section The Package Characters.Latin_1(15), see section The Package Characters.Latin_1.
separate compilation    section Separate Compilation.
separator    section Lexical Elements, Separators, and Delimiters.
Sequence    section Type Conversions.
sequence of characters
   of a string_literal    section String Literals.
sequence_of_statements    section Simple and Compound Statements - Sequences of Statements.
   used    section If Statements(2),    section Case Statements(3),    section Loop Statements(2),    section Case Statements(3),    section Loop Statements,
           section Selective Accept(2), see section Selective Accept(5), see section Selective Accept(2), see section Selective Accept(5), see section Selective Accept,
           section Timed Entry Calls(3), see section Conditional Entry Calls(2), see section Asynchronous Transfer of Control(3), see section Conditional Entry Calls(2), see section Asynchronous Transfer of Control,
           section Asynchronous Transfer of Control(5), see section Exception Handlers(2),   section Exception Handlers(5), see section Exception Handlers(2),   section Exception Handlers,
           section Syntax Summary (informative).
sequential
   actions    section Shared Variables(11), see section Shared Variable Control(11), see section Shared Variable Control.
sequential access    section Sequential and Direct Files.
sequential file    section Sequential and Direct Files.
Sequential_IO    section Renamings of Ada 83 Library Units.
   child of Ada    section The Generic Package Sequential_IO.
Server    section Task Units and Task Objects(23), see section Selective Accept(23), see section Selective Accept.
service
   an entry queue    section Entry Calls.
Set    section Abstract Types and Subprograms(15), see section Subprogram Calls(15), see section Subprogram Calls,
       section Other Optimizations and Determinism Rules(9),    section Other Optimizations and Determinism Rules(9),    section Other Optimizations and Determinism Rules.
Set_Col    section The Package Text_IO.
Set_Component    section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects.
Set_Error    section The Package Text_IO.
Set_False    section Synchronous Task Control.
Set_Index    section The Generic Package Direct_IO(14), see section The Package Streams.Stream_IO(14), see section The Package Streams.Stream_IO.
Set_Input    section The Package Text_IO.
Set_Line    section The Package Text_IO.
Set_Line_Length    section The Package Text_IO.
Set_Mask    section Machine Code Insertions(13), see section Machine Code Insertions(13), see section Machine Code Insertions.
Set_Mode    section The Package Streams.Stream_IO.
Set_Output    section The Package Text_IO.
Set_Page_Length    section The Package Text_IO.
Set_Priority    section Dynamic Priorities.
Set_True    section Synchronous Task Control.
Set_Value    section The Package Task_Attributes.
Set_Im    section Complex Types.
Set_Re    section Complex Types.
Sets    section Abstract Types and Subprograms.
shared passive library unit    section Categorization of Library Units(4), see section Shared Passive Library Units(4), see section Shared Passive Library Units.
shared variable
   protection of    section Shared Variables.
Shared_Array    section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects(31), see section Protected Units and Protected Objects.
Shared_Passive pragma    section Shared Passive Library Units(3), see section Language-Defined Pragmas (informative)(3), see section Language-Defined Pragmas (informative).
Sharp    section ASCII.
shift    section The Package Interfaces.
Shift_Left    section The Package Interfaces.
Shift_Right    section The Package Interfaces.
Shift_Right_Arithmetic    section The Package Interfaces.
Short    section Representation Attributes(82), see section Interfacing with C(82), see section Interfacing with C.
short-circuit control form    section Logical Operators and Short-circuit Control Forms.
Short_Float    section Floating Point Types.
Short_Integer    section Integer Types.
Shut_Down    section Task Units and Task Objects.
SI    section The Package Characters.Latin_1.
Sigma    section Generic Declarations(24), see section Generic Bodies(24), see section Generic Bodies.
signal (an exception)
   See raise    section Exceptions.
signal
   See interrupt    section Interrupt Support.
   as defined between actions    section Shared Variables.
signal handling
   example    section Asynchronous Transfer of Control.
signed integer type    section Integer Types.
signed_char    section Interfacing with C.
signed_integer_type_definition    section Integer Types.
   used    section Integer Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Signed_Zeros attribute    section Attributes of Floating Point Types(13), see section Language-Defined Attributes (informative)(13), see section Language-Defined Attributes (informative).
simple entry call    section Entry Calls.
simple_expression    section Expressions.
   used    section Scalar Types(3), see section Integer Types(3),   section Floating Point Types(3), see section Integer Types(3),   section Floating Point Types,
           section Expressions(3), see section Record Representation Clauses(5), see section Record Representation Clauses(3), see section Record Representation Clauses(5), see section Record Representation Clauses,
           section Syntax Summary (informative).
simple_statement    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Sin section Elementary Functions(5), see section Complex Elementary Functions(4)
single
   class expected type    section The Context of Overload Resolution.
single entry    section Entries and Accept Statements.
Single_Precision_Complex_Types    section Interfacing with Fortran.
single_protected_declaration    section Protected Units and Protected Objects.
   used    section Object Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
single_task_declaration    section Task Units and Task Objects.
   used    section Object Declarations(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
Singular    section Exception Declarations.
Sinh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
size    section The Generic Package Direct_IO(15), see section The Package Streams.Stream_IO(15), see section The Package Streams.Stream_IO.
   of an object    section Representation Items.
Size attribute    section Representation Attributes(40), see section Representation Attributes(40), see section Representation Attributes,
                  section Language-Defined Attributes (informative)(223),    section Language-Defined Attributes (informative)(223),    section Language-Defined Attributes (informative).
Size clause    section Representation Attributes(7), see section Representation Attributes(41), see section Representation Attributes(7), see section Representation Attributes(41), see section Representation Attributes.
size_t    section Interfacing with C.
Skip_Line    section The Package Text_IO.
Skip_Page    section The Package Text_IO.
slice    section Slices(2), see section Bounded-Length String Handling(28), see section Unbounded-Length String Handling(2), see section Bounded-Length String Handling(28), see section Unbounded-Length String Handling.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
small
   of a fixed point type    section Fixed Point Types.
Small attribute    section Operations of Fixed Point Types(2), see section Language-Defined Attributes (informative)(2), see section Language-Defined Attributes (informative).
Small clause    section Operations of Fixed Point Types(2), see section Representation Attributes(2), see section Representation Attributes.
Small_Int    section Subtype Declarations(15), see section Integer Types(15), see section Integer Types.
SO    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
Soft_Hyphen    section The Package Characters.Latin_1.
SOH    section The Package Characters.Latin_1.
solidus    section Character Set(15), see section The Package Characters.Latin_1(15), see section The Package Characters.Latin_1.
Source    section Unchecked Type Conversions.
SPA    section The Package Characters.Latin_1.
Space    section The Package Characters.Latin_1(8), see section The Package Strings(8), see section The Package Strings.
space_character    section Character Set.
   used    section Character Set(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
special graphic character
   a category of Character    section The Package Characters.Handling.
special_character    section Character Set.
   used    section Character Set(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
   names    section Character Set.
Special_Key    section Derived Types and Classes.
Special_Set    section String-Handling Sets and Mappings.
Specialized Needs Annexes    section Structure.
specifiable (of an attribute and for an entity)    section Representation Attributes.
specifiable
   of Address for entries    section Interrupt Entries.
   of Address for stand-alone objects and for program units
         section Representation Attributes.
   of Alignment for first subtypes and objects    section Representation Attributes.
   of Bit_Order for record types and record extensions
         section Bit Ordering.
   of Component_Size for array types    section Representation Attributes.
   of External_Tag for a tagged type    section Representation Attributes(75), see section Language-Defined Attributes (informative)(75), see section Language-Defined Attributes (informative).
   of Input for a type    section Stream-Oriented Attributes.
   of Machine_Radix for decimal first subtypes    section Machine_Radix Attribute Definition Clause.
   of Output for a type    section Stream-Oriented Attributes.
   of Read for a type    section Stream-Oriented Attributes.
   of Size for first subtypes    section Representation Attributes.
   of Size for stand-alone objects    section Representation Attributes.
   of Small for fixed point types    section Operations of Fixed Point Types.
   of Storage_Pool for a non-derived access-to-object type
         section Storage Management.
   of Storage_Size for a task first subtype    section The Storage_Size Attribute.
   of Storage_Size for a non-derived access-to-object type
         section Storage Management.
   of Write for a type    section Stream-Oriented Attributes.
specific type    section Derivation Classes.
specified (not!)    section Conformity of an Implementation with the Standard.
specified
   of an aspect of representation of an entity    section Representation Items.
specified discriminant    section Discriminants.
Spin section Conditional Entry Calls(6)
Split    section Delay Statements, Duration, and Time(14), see section Monotonic Time(14), see section Monotonic Time.
Sqrt    section Elementary Functions(4), see section Interfacing Pragmas(4), see section Interfacing Pragmas, G.1.2(3)
Square    section Subtype Declarations(15), see section Discriminants(35), see section Generic Instantiation(15), see section Discriminants(35), see section Generic Instantiation.
Squaring    section Generic Declarations(22), see section Generic Bodies(22), see section Generic Bodies.
SS2    section The Package Characters.Latin_1.
SS3    section The Package Characters.Latin_1.
SSA    section The Package Characters.Latin_1.
ST    section The Package Characters.Latin_1.
Stack    section Example of a Generic Package(3), see section Example of a Generic Package(4), see section Example of a Generic Package(3), see section Example of a Generic Package(4), see section Example of a Generic Package.
Stack_Bool    section Example of a Generic Package.
Stack_Int    section Example of a Generic Package.
Stack_Real    section Example of a Generic Package.
stand-alone constant    section Object Declarations.
   corresponding to a formal object of mode in section Formal Objects(10)
stand-alone object    section Object Declarations.
stand-alone variable    section Object Declarations.
Standard    section The Package Standard.
standard error file    section Text Input-Output.
standard input file    section Text Input-Output.
standard mode    section Classification of Errors.
standard output file    section Text Input-Output.
standard storage pool    section Storage Management.
Standard_Error    section The Package Text_IO(16), see section The Package Text_IO(16), see section The Package Text_IO.
Standard_Input    section The Package Text_IO(16), see section The Package Text_IO(16), see section The Package Text_IO.
Standard_Output    section The Package Text_IO(16), see section The Package Text_IO(16), see section The Package Text_IO.
State    section Variant Parts and Discrete Choices(24), see section Record Representation Clauses(24), see section Record Representation Clauses,
         section Random Number Generation(11), see section Random Number Generation(11), see section Random Number Generation.
State_Mask    section Record Representation Clauses.
statement    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
statement_identifier    section Simple and Compound Statements - Sequences of Statements.
   used    section Simple and Compound Statements - Sequences of Statements(7), see section Loop Statements(2), see section Block Statements(2), see section Syntax Summary (informative)(7), see section Loop Statements(2), see section Block Statements(2), see section Syntax Summary (informative).
static    section Static Expressions and Static Subtypes.
   constant    section Static Expressions and Static Subtypes.
   constraint    section Static Expressions and Static Subtypes.
   delta constraint    section Static Expressions and Static Subtypes.
   digits constraint    section Static Expressions and Static Subtypes.
   discrete_range    section Static Expressions and Static Subtypes.
   discriminant constraint    section Static Expressions and Static Subtypes.
   expression    section Static Expressions and Static Subtypes.
   function    section Static Expressions and Static Subtypes.
   index constraint    section Static Expressions and Static Subtypes.
   range    section Static Expressions and Static Subtypes.
   range constraint    section Static Expressions and Static Subtypes.
   scalar subtype    section Static Expressions and Static Subtypes.
   string subtype    section Static Expressions and Static Subtypes.
   subtype    section Static Expressions and Static Subtypes(26), see section Formal Objects(26), see section Formal Objects.
static semantics    section Structure.
statically
   constrained    section Static Expressions and Static Subtypes.
   denote    section Static Expressions and Static Subtypes.
statically compatible
   for a constraint and a scalar subtype    section Statically Matching Constraints and Subtypes.
   for a constraint and an access or composite subtype
         section Statically Matching Constraints and Subtypes.
   for two subtypes    section Statically Matching Constraints and Subtypes.
statically deeper    section Operations of Access Types(4), see section Operations of Access Types(4), see section Operations of Access Types.
statically determined tag    section Dispatching Operations of Tagged Types.
   [partial]    section Dispatching Operations of Tagged Types(15), see section Dispatching Operations of Tagged Types(15), see section Dispatching Operations of Tagged Types.
statically matching
   effect on subtype-specific aspects    section Representation Items.
   for constraints    section Statically Matching Constraints and Subtypes.
   for ranges    section Statically Matching Constraints and Subtypes.
   for subtypes    section Statically Matching Constraints and Subtypes.
   required    section Dispatching Operations of Tagged Types(10), see section Operations of Access Types(27), see section Type Conversions(10), see section Operations of Access Types(27), see section Type Conversions,
               section Type Conversions(16),    section Conformance Rules(16),   section Conformance Rules(16),    section Conformance Rules(16),   section Conformance Rules,
               section Conformance Rules(23), see section Private Types and Private Extensions(13),     section Formal Private and Derived Types(23), see section Private Types and Private Extensions(13),     section Formal Private and Derived Types,
               section Formal Array Types(6), see section Formal Array Types(7),   section Formal Access Types(6), see section Formal Array Types(7),   section Formal Access Types,
               section Formal Packages.
statically tagged    section Dispatching Operations of Tagged Types.
Status_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO,
                section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(26), see section Exceptions in Input-Output.
storage deallocation
   unchecked    section Unchecked Storage Deallocation.
storage element    section Representation Attributes.
storage management
   user-defined    section Storage Management.
storage node    section Distributed Systems (normative).
storage place
   of a component    section Record Layout.
storage place attributes
   of a component    section Storage Place Attributes.
storage pool    section Access Types.
storage pool element    section Storage Management.
storage pool type    section Storage Management.
Storage_Array    section The Package System.Storage_Elements.
Storage_Check    section Suppressing Checks.
   [partial]    section Exception Declarations(6),    section Representation Attributes(6),    section Representation Attributes,
                section Storage Management(17), see section Tasking Restrictions(17), see section Tasking Restrictions.
Storage_Count    section The Package System.Storage_Elements.
   subtype in package System.Storage_Elements    section The Package System.Storage_Elements.
Storage_Element    section The Package System.Storage_Elements.
Storage_Elements
   child of System    section The Package System.Storage_Elements.
Storage_Error    section The Package Standard.
   raised by failure of run-time check
         section Allocators(14),    section Exception Declarations(4),   section Exception Declarations(14),    section Exception Declarations(4),   section Exception Declarations,
         section Suppressing Checks(23),   section Representation Attributes(67), see section Storage Management(23),   section Representation Attributes(67), see section Storage Management,
         section Storage Management(18), see section External Files and File Objects(14),   section Tasking Restrictions(18), see section External Files and File Objects(14),   section Tasking Restrictions.
Storage_Offset    section The Package System.Storage_Elements.
Storage_Pool attribute    section Storage Management(13), see section Language-Defined Attributes (informative)(13), see section Language-Defined Attributes (informative).
Storage_Pool clause    section Representation Attributes(7), see section Storage Management(7), see section Storage Management.
Storage_Pools
   child of System    section Storage Management.
Storage_Size    section Storage Management.
Storage_Size attribute    section Representation Attributes(60), see section Storage Management(60), see section Storage Management,
                          section The Storage_Size Attribute(2),    section Language-Defined Attributes (informative)(2),    section Language-Defined Attributes (informative),
                          section Language-Defined Attributes (informative).
Storage_Size clause    section Representation Attributes(7), see section Storage Management(7), see section Storage Management.
   See also pragma Storage_Size    section Representation Attributes.
Storage_Size pragma    section Representation Attributes(63), see section Language-Defined Pragmas (informative)(63), see section Language-Defined Pragmas (informative).
Storage_Unit    section The Package System.
   named number in package System    section The Package System.
Storage_IO
   child of Ada    section The Generic Package Storage_IO.
Strcpy    section Interfacing with C(78), see section The Generic Package Interfaces.C.Pointers(78), see section The Generic Package Interfaces.C.Pointers.
stream    section Streams(1),   section The Package Streams.Stream_IO(1),   section The Package Streams.Stream_IO,
          section The Package Text_IO.Text_Streams(4), see section The Package Wide_Text_IO.Text_Streams(4), see section The Package Wide_Text_IO.Text_Streams.
stream type    section Streams.
Stream_Access    section The Package Streams.Stream_IO(4), see section The Package Text_IO.Text_Streams(3), see section The Package Wide_Text_IO.Text_Streams(4), see section The Package Text_IO.Text_Streams(3), see section The Package Wide_Text_IO.Text_Streams.
Stream_Element    section The Package Streams.
Stream_Element_Array    section The Package Streams.
Stream_Element_Count    section The Package Streams.
Stream_Element_Offset    section The Package Streams.
Stream_IO
   child of Ada.Streams    section The Package Streams.Stream_IO.
Streams
   child of Ada    section The Package Streams.
strict mode    section Numeric Performance Requirements.
String    section String Types(4), see section The Package Standard(4), see section The Package Standard.
string type    section String Types.
String_Access    section Unbounded-Length String Handling.
string_element    section String Literals.
   used    section String Literals(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
string_literal    section String Literals.
   used    section Expressions(7), see section Subprogram Declarations(9), see section Syntax Summary (informative)(7), see section Subprogram Declarations(9), see section Syntax Summary (informative).
Strings
   child of Ada    section The Package Strings.
   child of Interfaces.C    section The Package Interfaces.C.Strings.
Strlen    section The Package Interfaces.C.Strings.
structure
   See record type    section Record Types.
STS    section The Package Characters.Latin_1.
STX    section The Package Characters.Latin_1(5), see section ASCII(5), see section ASCII.
SUB    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
subaggregate
   of an array_aggregate    section Array Aggregates.
subcomponent    section Types and Subtypes.
subprogram    section Subprograms.
   abstract    section Abstract Types and Subprograms.
subprogram call    section Subprogram Calls.
subprogram instance    section Generic Instantiation.
subprogram_body    section Subprogram Bodies.
   used    section Declarative Parts(6),    section Protected Units and Protected Objects(6),    section Protected Units and Protected Objects,
           section Compilation Units - Library Units(7), see section Syntax Summary (informative)(7), see section Syntax Summary (informative).
subprogram_body_stub    section Subunits of Compilation Units.
   used    section Subunits of Compilation Units(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
subprogram_declaration    section Subprogram Declarations.
   used    section Declarations(3),     section Protected Units and Protected Objects(5), see section Protected Units and Protected Objects(3),     section Protected Units and Protected Objects(5), see section Protected Units and Protected Objects,
           section Compilation Units - Library Units(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
subprogram_default    section Formal Subprograms.
   used    section Formal Subprograms(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
subprogram_renaming_declaration    section Subprogram Renaming Declarations.
   used    section Renaming Declarations(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative)(2), see section Compilation Units - Library Units(6), see section Syntax Summary (informative).
subprogram_specification    section Subprogram Declarations.
   used    section Subprogram Declarations(2),    section Subprogram Declarations(3),     section Subprogram Bodies(2),    section Subprogram Declarations(3),     section Subprogram Bodies,
           section Subprogram Renaming Declarations(2), see section Subunits of Compilation Units(3), see section Generic Declarations(2), see section Subunits of Compilation Units(3), see section Generic Declarations,
           section Formal Subprograms(2),   section Syntax Summary (informative)(2),   section Syntax Summary (informative).
subsystem    section Separate Compilation(3), see section Glossary (informative)(3), see section Glossary (informative).
Subtraction    section Type Extensions.
subtype (of an object)
   See actual subtype of an object    section Objects and Named Numbers(23), see section Object Declarations(23), see section Object Declarations.
subtype    section Types and Subtypes(8), see section Glossary (informative)(8), see section Glossary (informative).
subtype conformance    section Conformance Rules.
   [partial]    section Operations of Access Types(34), see section Requeue Statements(34), see section Requeue Statements.
   required    section Dispatching Operations of Tagged Types(10), see section Operations of Access Types(32), see section Type Conversions(10), see section Operations of Access Types(32), see section Type Conversions,
               section Subprogram Renaming Declarations(5),   section Requeue Statements(5),    section Representation Attributes(5),   section Requeue Statements(5),    section Representation Attributes.
subtype conversion
   See also implicit subtype conversion    section Type Conversions.
   See type conversion    section Type Conversions.
subtype-specific
   of a representation item    section Representation Items.
   of an aspect    section Representation Items.
subtype_declaration    section Subtype Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
subtype_indication    section Subtype Declarations.
   used    section Subtype Declarations(2), see section Object Declarations(2), see section Derived Types and Classes(2), see section Object Declarations(2), see section Derived Types and Classes,
           section Array Types(6),    section Array Types(7),    section Index Constraints and Discrete Ranges(6),    section Array Types(7),    section Index Constraints and Discrete Ranges,
           section Access Types(3),   section Allocators(2),    section Private Types and Private Extensions(3),   section Allocators(2),    section Private Types and Private Extensions,
           section Syntax Summary (informative).
subtype_mark    section Subtype Declarations.
   used    section Subtype Declarations(3), see section Array Types(4),    section Discriminants(3), see section Array Types(4),    section Discriminants,
           section Access Types(6),   section Extension Aggregates(3), see section Expressions(6),   section Extension Aggregates(3), see section Expressions,
           section Type Conversions(2),    section Qualified Expressions(2),    section Subprogram Declarations(2),    section Qualified Expressions(2),    section Subprogram Declarations,
           section Subprogram Declarations(15),   section Use Clauses(4),    section Object Renaming Declarations(15),   section Use Clauses(4),    section Object Renaming Declarations,
           section Generic Instantiation(5),   section Formal Objects(2),   section Formal Private and Derived Types(5),   section Formal Objects(2),   section Formal Private and Derived Types,
           section Syntax Summary (informative).
subtypes
   of a profile    section Subprogram Declarations.
subunit    section Subunits of Compilation Units(7), see section Subunits of Compilation Units(7), see section Subunits of Compilation Units.
   used    section Compilation Units - Library Units(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Succ attribute    section Scalar Types(22), see section Language-Defined Attributes (informative)(22), see section Language-Defined Attributes (informative).
Suit    section Enumeration Types.
Sum    section Generic Declarations(24), see section Generic Bodies(24), see section Generic Bodies.
super
   See view conversion    section Type Conversions.
Superscript_One    section The Package Characters.Latin_1.
Superscript_Three    section The Package Characters.Latin_1.
Superscript_Two    section The Package Characters.Latin_1.
Suppress pragma    section Suppressing Checks(4), see section Language-Defined Pragmas (informative)(4), see section Language-Defined Pragmas (informative).
suppressed check    section Suppressing Checks.
Suspend_Until_True    section Synchronous Task Control.
Suspension_Object    section Synchronous Task Control.
Swap    section Generic Instantiation.
Switch    section Subprogram Declarations.
SYN    section The Package Characters.Latin_1(6), see section ASCII(6), see section ASCII.
synchronization    section Tasks and Synchronization.
Synchronous_Task_Control
   child of Ada    section Synchronous Task Control.
syntactic category    section Method of Description and Syntax Notation.
syntax
   complete listing    section Syntax Summary (informative).
   cross reference    section Syntax Summary (informative).
   notation    section Method of Description and Syntax Notation.
   under Syntax heading    section Structure.
System    section The Package System.
System.Address_To_Access_Conversions    section The Package System.Address_To_Access_Conversions.
System.Machine_Code    section Machine Code Insertions.
System.RPC    section Partition Communication Subsystem.
System.Storage_Elements    section The Package System.Storage_Elements.
System.Storage_Pools    section Storage Management.
System_Name    section The Package System.
systems programming    section Systems Programming (normative).

index

T    section Storage Management.
Table    section Type Declarations(15),   section Array Types(28), see section Formal Types(15),   section Array Types(28), see section Formal Types,
         section Formal Array Types(11), see section Example of a Generic Package(5), see section Example of a Generic Package(11), see section Example of a Generic Package(5), see section Example of a Generic Package.
Tag    section Tagged Types and Type Extensions.
Tag attribute    section Tagged Types and Type Extensions(16), see section Tagged Types and Type Extensions(16), see section Tagged Types and Type Extensions,
                 section Language-Defined Attributes (informative)(242),   section Language-Defined Attributes (informative)(242),   section Language-Defined Attributes (informative).
tag indeterminate    section Dispatching Operations of Tagged Types.
tag of an object    section Tagged Types and Type Extensions.
   class-wide object    section Tagged Types and Type Extensions.
   object created by an allocator    section Tagged Types and Type Extensions.
   preserved by type conversion and parameter passing
         section Tagged Types and Type Extensions.
   returned by a function    section Tagged Types and Type Extensions(23), see section Tagged Types and Type Extensions(23), see section Tagged Types and Type Extensions.
   stand-alone object, component, or aggregate    section Tagged Types and Type Extensions.
Tag_Check    section Suppressing Checks.
   [partial]    section Dispatching Operations of Tagged Types(16), see section Type Conversions(42), see section Type Conversions(16), see section Type Conversions(42), see section Type Conversions,
                section Assignment Statements(10),    section Return Statements(10),    section Return Statements.
Tag_Error    section Tagged Types and Type Extensions.
tagged type    section Tagged Types and Type Extensions(2), see section Glossary (informative)(2), see section Glossary (informative).
Tags
   child of Ada    section Tagged Types and Type Extensions.
tail (of a queue)    section The Task Dispatching Model.
Tail    section Fixed-Length String Handling(37), see section Fixed-Length String Handling(38), see section Bounded-Length String Handling(37), see section Fixed-Length String Handling(38), see section Bounded-Length String Handling,
        section Bounded-Length String Handling(73), see section Unbounded-Length String Handling(67), see section Unbounded-Length String Handling(73), see section Unbounded-Length String Handling(67), see section Unbounded-Length String Handling.
Take    section Abstract Types and Subprograms.
Tan    section Elementary Functions(5), see section Complex Elementary Functions(5), see section Complex Elementary Functions.
Tanh    section Elementary Functions(7), see section Complex Elementary Functions(7), see section Complex Elementary Functions.
Tape    section Example of Use of a Remote Access-to-Class-Wide Type.
Tape_Client    section Example of Use of a Remote Access-to-Class-Wide Type.
Tape_Driver    section Example of Use of a Remote Access-to-Class-Wide Type(4), see section Example of Use of a Remote Access-to-Class-Wide Type(4), see section Example of Use of a Remote Access-to-Class-Wide Type.
Tape_Ptr    section Example of Use of a Remote Access-to-Class-Wide Type.
Tapes    section Example of Use of a Remote Access-to-Class-Wide Type.
target    section Unchecked Type Conversions.
   of an assignment_statement    section Assignment Statements.
   of an assignment operation    section Assignment Statements.
target entry
   of a requeue_statement    section Requeue Statements.
target object
   of a requeue_statement    section Intertask Communication.
   of a call on an entry or a protected subprogram    section Intertask Communication.
target statement
   of a goto_statement    section Goto Statements.
target subtype
   of a type_conversion    section Type Conversions.
task    section Tasks and Synchronization.
   activation    section Task Execution - Task Activation.
   completion    section Task Dependence - Termination of Tasks.
   dependence    section Task Dependence - Termination of Tasks.
   execution    section Task Execution - Task Activation.
   termination    section Task Dependence - Termination of Tasks.
task declaration    section Task Units and Task Objects.
task dispatching    section The Task Dispatching Model.
task dispatching point    section The Task Dispatching Model.
   [partial]    section The Task Dispatching Model(8), see section The Standard Task Dispatching Policy(8), see section The Standard Task Dispatching Policy.
task dispatching policy    section The Standard Task Dispatching Policy.
   [partial]    section The Task Dispatching Model.
task priority    section Task Priorities.
task state
   abnormal    section Abort of a Task - Abort of a Sequence of Statements.
   blocked    section Tasks and Synchronization.
   callable    section Task and Entry Attributes.
   held    section Asynchronous Task Control.
   inactive    section Tasks and Synchronization.
   ready    section Tasks and Synchronization.
   terminated    section Tasks and Synchronization.
Task type    section Glossary (informative).
task unit    section Tasks and Synchronization.
Task_Attributes
   child of Ada    section The Package Task_Attributes.
task_body    section Task Units and Task Objects.
   used    section Declarative Parts(6), see section Syntax Summary (informative)(6), see section Syntax Summary (informative).
task_body_stub    section Subunits of Compilation Units.
   used    section Subunits of Compilation Units(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
task_definition    section Task Units and Task Objects.
   used    section Task Units and Task Objects(2), see section Task Units and Task Objects(3), see section Syntax Summary (informative)(2), see section Task Units and Task Objects(3), see section Syntax Summary (informative).
Task_Dispatching_Policy pragma    section The Standard Task Dispatching Policy(2), see section Language-Defined Pragmas (informative)(2), see section Language-Defined Pragmas (informative).
Task_Identification
   child of Ada    section The Package Task_Identification.
task_item    section Task Units and Task Objects.
   used    section Task Units and Task Objects(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
task_type_declaration    section Task Units and Task Objects.
   used    section Type Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Task_ID    section The Package Task_Identification.
Tasking_Error    section The Package Standard.
   raised by failure of run-time check
         section Task Execution - Task Activation(5),       section Entry Calls(21),    section Exception Declarations(5),       section Entry Calls(21),    section Exception Declarations,
         section Unchecked Storage Deallocation(13), see section Unchecked Storage Deallocation(14), see section The Package Task_Attributes(13), see section Unchecked Storage Deallocation(14), see section The Package Task_Attributes,
         section Dynamic Priorities(8),       section Asynchronous Task Control(8),       section Asynchronous Task Control.
template    section Generic Units.
   See generic unit    section Generic Units.
   for a formal package    section Formal Packages.
term    section Expressions.
   used    section Expressions, P(1)
terminal interrupt
   example    section Asynchronous Transfer of Control.
terminate_alternative    section Selective Accept.
   used    section Selective Accept(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
terminated
   a task state    section Tasks and Synchronization.
Terminated attribute    section Task and Entry Attributes(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
termination
   of a partition    section Partitions.
Terminator_Error    section Interfacing with C.
Test    section Interfacing with C.
Test_Call    section Interfacing with COBOL.
Test_External_Formats    section Interfacing with COBOL.
Test_Pointers    section The Generic Package Interfaces.C.Pointers.
tested type
   of a membership test    section Relational Operators and Membership Tests.
text of a program    section Lexical Elements, Separators, and Delimiters.
Text_Streams
   child of Ada.Text_IO    section The Package Text_IO.Text_Streams(3), see section The Package Wide_Text_IO.Text_Streams(3), see section The Package Wide_Text_IO.Text_Streams.
Text_IO    section Renamings of Ada 83 Library Units.
   child of Ada    section The Package Text_IO.
throw (an exception)
   See raise    section Exceptions.
tick    section Character Set(15), see section The Package System(10), see section Monotonic Time(15), see section The Package System(10), see section Monotonic Time.
   named number in package System    section The Package System.
Tilde    section The Package Characters.Latin_1.
Time    section Delay Statements, Duration, and Time(10), see section Monotonic Time(10), see section Monotonic Time.
time base    section Delay Statements, Duration, and Time.
time limit
   example    section Asynchronous Transfer of Control.
time type    section Delay Statements, Duration, and Time.
Time-dependent Reset procedure
   of the random number generator    section Random Number Generation.
time-out
   See asynchronous_select    section Asynchronous Transfer of Control.
   See selective_accept    section Selective Accept.
   See timed_entry_call    section Timed Entry Calls.
   example    section Asynchronous Transfer of Control.
Time_Error    section Delay Statements, Duration, and Time.
Time_First    section Monotonic Time.
Time_Last    section Monotonic Time.
Time_Span    section Monotonic Time.
Time_Span_First    section Monotonic Time.
Time_Span_Last    section Monotonic Time.
Time_Span_Unit    section Monotonic Time.
Time_Span_Zero    section Monotonic Time.
Time_Unit    section Monotonic Time.
Time_Of    section Delay Statements, Duration, and Time(15), see section Monotonic Time(15), see section Monotonic Time.
timed_entry_call    section Timed Entry Calls.
   used    section Select Statements(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
timer interrupt
   example    section Asynchronous Transfer of Control.
times operator    section Expressions(1), see section Multiplying Operators(1), see section Multiplying Operators.
timing
   See delay_statement    section Delay Statements, Duration, and Time.
TM    section Package Renaming Declarations.
To_Ada    section Interfacing with C(22), see section Interfacing with C(26), see section Interfacing with C(22), see section Interfacing with C(26), see section Interfacing with C,
          section Interfacing with C(32), see section Interfacing with C(37), see section Interfacing with C(32), see section Interfacing with C(37), see section Interfacing with C,
          section Interfacing with COBOL(17), see section Interfacing with COBOL(19), see section Interfacing with Fortran(17), see section Interfacing with COBOL(19), see section Interfacing with Fortran,
          section Interfacing with Fortran(14), see section Interfacing with Fortran(14), see section Interfacing with Fortran.
To_Address    section The Package System.Storage_Elements(10), see section The Package System.Address_To_Access_Conversions(10), see section The Package System.Address_To_Access_Conversions.
To_Basic    section The Package Characters.Handling(6), see section The Package Characters.Handling(6), see section The Package Characters.Handling.
To_Binary    section Interfacing with COBOL(45), see section Interfacing with COBOL(45), see section Interfacing with COBOL.
To_Bounded_String    section Bounded-Length String Handling.
To_Character    section The Package Characters.Handling.
To_COBOL    section Interfacing with COBOL(17), see section Interfacing with COBOL(17), see section Interfacing with COBOL.
To_Decimal    section Interfacing with COBOL(35), see section Interfacing with COBOL(35), see section Interfacing with COBOL,
              section Interfacing with COBOL(44), see section Interfacing with COBOL(44), see section Interfacing with COBOL.
To_Display    section Interfacing with COBOL.
To_Domain section The Package Strings.Maps(24), see section Wide_String Handling(24)
To_Duration    section Monotonic Time.
To_Fortran    section Interfacing with Fortran(13), see section Interfacing with Fortran(14), see section Interfacing with Fortran(13), see section Interfacing with Fortran(14), see section Interfacing with Fortran.
To_Integer    section The Package System.Storage_Elements.
To_ISO_646    section The Package Characters.Handling(11), see section The Package Characters.Handling(11), see section The Package Characters.Handling.
To_Long_Binary    section Interfacing with COBOL.
To_Lower    section The Package Characters.Handling(6), see section The Package Characters.Handling(6), see section The Package Characters.Handling.
To_Mapping    section The Package Strings.Maps(23), see section Wide_String Handling(23), see section Wide_String Handling.
To_Packed    section Interfacing with COBOL.
To_Picture    section The Package Text_IO.Editing.
To_Pointer    section The Package System.Address_To_Access_Conversions.
To_Range    section The Package Strings.Maps(24), see section Wide_String Handling(24), see section Wide_String Handling.
To_Ranges    section The Package Strings.Maps(10), see section Wide_String Handling(10), see section Wide_String Handling.
To_Sequence    section The Package Strings.Maps(19), see section Wide_String Handling(19), see section Wide_String Handling.
To_Set    section The Package Strings.Maps(8),   section The Package Strings.Maps(9), see section The Package Strings.Maps(8),   section The Package Strings.Maps(9), see section The Package Strings.Maps,
          section The Package Strings.Maps(18), see section Wide_String Handling(8), see section Wide_String Handling(18), see section Wide_String Handling(8), see section Wide_String Handling,
          section Wide_String Handling(17), see section Wide_String Handling(17), see section Wide_String Handling.
To_String    section The Package Characters.Handling(16), see section Bounded-Length String Handling(12), see section Unbounded-Length String Handling(16), see section Bounded-Length String Handling(12), see section Unbounded-Length String Handling.
To_Time_Span    section Monotonic Time.
To_Unbounded_String    section Unbounded-Length String Handling(9), see section Unbounded-Length String Handling(9), see section Unbounded-Length String Handling.
To_Upper    section The Package Characters.Handling(6), see section The Package Characters.Handling(6), see section The Package Characters.Handling.
To_Wide_Character    section The Package Characters.Handling.
To_Wide_String    section The Package Characters.Handling.
To_C    section Interfacing with C(21), see section Interfacing with C(25), see section Interfacing with C(21), see section Interfacing with C(25), see section Interfacing with C,
        section Interfacing with C(32), see section Interfacing with C(36), see section Interfacing with C(32), see section Interfacing with C(36), see section Interfacing with C.
token
   See lexical element    section Lexical Elements, Separators, and Delimiters.
Tolerance    section Object Declarations.
Trailing_Nonseparate    section Interfacing with COBOL.
Trailing_Separate    section Interfacing with COBOL.
transfer of control    section Simple and Compound Statements - Sequences of Statements.
Translate    section Fixed-Length String Handling(18), see section Fixed-Length String Handling(19), see section Fixed-Length String Handling(18), see section Fixed-Length String Handling(19), see section Fixed-Length String Handling,
             section Fixed-Length String Handling(21), see section Bounded-Length String Handling(53), see section Bounded-Length String Handling(21), see section Bounded-Length String Handling(53), see section Bounded-Length String Handling,
             section Bounded-Length String Handling(55), see section Bounded-Length String Handling(56), see section Unbounded-Length String Handling(55), see section Bounded-Length String Handling(56), see section Unbounded-Length String Handling,
             section Unbounded-Length String Handling(49), see section Unbounded-Length String Handling(50), see section Unbounded-Length String Handling(49), see section Unbounded-Length String Handling(50), see section Unbounded-Length String Handling.
Traverse_Tree    section Subprogram Declarations.
triggering_alternative    section Asynchronous Transfer of Control.
   used    section Asynchronous Transfer of Control(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
triggering_statement    section Asynchronous Transfer of Control.
   used    section Asynchronous Transfer of Control(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Trim    section Fixed-Length String Handling(31), see section Fixed-Length String Handling(32), see section Fixed-Length String Handling(31), see section Fixed-Length String Handling(32), see section Fixed-Length String Handling,
        section Fixed-Length String Handling(34), see section Bounded-Length String Handling(67), see section Bounded-Length String Handling(34), see section Bounded-Length String Handling(67), see section Bounded-Length String Handling,
        section Bounded-Length String Handling(69), see section Unbounded-Length String Handling(61), see section Unbounded-Length String Handling(69), see section Unbounded-Length String Handling(61), see section Unbounded-Length String Handling,
        section Unbounded-Length String Handling(63), see section Unbounded-Length String Handling(63), see section Unbounded-Length String Handling.
Trim_End    section The Package Strings.
True    section Boolean Types.
Truncation    section The Package Strings.
Truncation attribute    section Attributes of Floating Point Types(42), see section Language-Defined Attributes (informative)(42), see section Language-Defined Attributes (informative).
two's complement
   modular types    section Integer Types.
Two_Pi    section Number Declarations.
type    section Types and Subtypes(1), see section Glossary (informative)(1), see section Glossary (informative).
   See also tag    section Tagged Types and Type Extensions.
   abstract    section Abstract Types and Subprograms.
   See also   language-defined types
type conformance    section Conformance Rules.
   [partial]    section Derived Types and Classes(17), see section Visibility(17), see section Visibility,
                section Visibility(26), see section The Compilation Process(26), see section The Compilation Process.
   required    section Completions of Declarations(5), see section Attributes(5), see section Attributes,
               section The Context of Overload Resolution(26),    section Requeue Statements(26),    section Requeue Statements.
type conversion    section Type Conversions.
   See also qualified_expression    section Qualified Expressions.
   access    section Type Conversions(13), see section Type Conversions(18), see section Type Conversions(13), see section Type Conversions(18), see section Type Conversions.
   arbitrary order    section Method of Description and Syntax Notation.
   array    section Type Conversions(9), see section Type Conversions(9), see section Type Conversions.
   composite (non-array)    section Type Conversions(21), see section Type Conversions(21), see section Type Conversions.
   enumeration    section Type Conversions(21), see section Type Conversions(21), see section Type Conversions.
   numeric    section Type Conversions(8), see section Type Conversions(8), see section Type Conversions.
   unchecked    section Unchecked Type Conversions.
type conversion, implicit
   See implicit subtype conversion    section Type Conversions.
type extension    section Tagged Types and Type Extensions(2), see section Type Extensions(2), see section Type Extensions.
type of a discrete_range    section Index Constraints and Discrete Ranges.
type of a range    section Scalar Types.
type parameter
   See discriminant    section Discriminants.
type profile
   See profile, type conformant    section Conformance Rules.
type resolution rules    section The Context of Overload Resolution.
   if any type in a specified class of types is expected
         section The Context of Overload Resolution.
   if expected type is specific    section The Context of Overload Resolution.
   if expected type is universal or class-wide    section The Context of Overload Resolution.
type tag
   See tag    section Tagged Types and Type Extensions.
type-related
   aspect    section Representation Items.
   representation item    section Representation Items.
type_conversion    section Type Conversions.
   used    section Names(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
   See also unchecked type conversion    section Unchecked Type Conversions.
type_declaration    section Type Declarations.
   used    section Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
type_definition    section Type Declarations.
   used    section Type Declarations(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
Type_Set    section The Package Text_IO(7), see section Input-Output for Enumeration Types(7), see section Input-Output for Enumeration Types.
types
   of a profile    section Subprogram Declarations.

index

UC_Icelandic_Eth    section The Package Characters.Latin_1.
UC_Icelandic_Thorn    section The Package Characters.Latin_1.
UC_A_Acute    section The Package Characters.Latin_1.
UC_A_Circumflex    section The Package Characters.Latin_1.
UC_A_Diaeresis    section The Package Characters.Latin_1.
UC_A_Grave    section The Package Characters.Latin_1.
UC_A_Ring    section The Package Characters.Latin_1.
UC_A_Tilde    section The Package Characters.Latin_1.
UC_AE_Diphthong    section The Package Characters.Latin_1.
UC_C_Cedilla    section The Package Characters.Latin_1.
UC_E_Acute    section The Package Characters.Latin_1.
UC_E_Circumflex    section The Package Characters.Latin_1.
UC_E_Diaeresis    section The Package Characters.Latin_1.
UC_E_Grave    section The Package Characters.Latin_1.
UC_I_Acute    section The Package Characters.Latin_1.
UC_I_Circumflex    section The Package Characters.Latin_1.
UC_I_Diaeresis    section The Package Characters.Latin_1.
UC_I_Grave    section The Package Characters.Latin_1.
UC_N_Tilde    section The Package Characters.Latin_1.
UC_O_Acute    section The Package Characters.Latin_1.
UC_O_Circumflex    section The Package Characters.Latin_1.
UC_O_Diaeresis    section The Package Characters.Latin_1.
UC_O_Grave    section The Package Characters.Latin_1.
UC_O_Oblique_Stroke    section The Package Characters.Latin_1.
UC_O_Tilde    section The Package Characters.Latin_1.
UC_U_Acute    section The Package Characters.Latin_1.
UC_U_Circumflex    section The Package Characters.Latin_1.
UC_U_Diaeresis    section The Package Characters.Latin_1.
UC_U_Grave    section The Package Characters.Latin_1.
UC_Y_Acute    section The Package Characters.Latin_1.
UCHAR_MAX    section Interfacing with C.
ultimate ancestor
   of a type    section Derivation Classes.
unary adding operator    section Unary Adding Operators.
unary operator    section Operators and Expression Evaluation.
unary_adding_operator    section Operators and Expression Evaluation.
   used    section Expressions(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Unbiased_Rounding attribute    section Attributes of Floating Point Types(39), see section Language-Defined Attributes (informative)(39), see section Language-Defined Attributes (informative).
Unbounded    section The Package Text_IO.
   child of Ada.Strings    section Unbounded-Length String Handling.
Unbounded_String    section Unbounded-Length String Handling.
unchecked storage deallocation    section Unchecked Storage Deallocation.
unchecked type conversion    section Unchecked Type Conversions.
Unchecked_Access attribute    section Unchecked Access Value Creation(3), see section Safety and Security Restrictions(3), see section Safety and Security Restrictions,
                              section Language-Defined Attributes (informative).
   See also Access attribute    section Operations of Access Types.
Unchecked_Conversion    section Renamings of Ada 83 Library Units.
   child of Ada    section Unchecked Type Conversions.
Unchecked_Deallocation    section Renamings of Ada 83 Library Units.
   child of Ada    section Unchecked Storage Deallocation.
unconstrained    section Types and Subtypes.
   object    section Object Declarations(9), see section Access Types(9), see section Parameter Associations(9), see section Access Types(9), see section Parameter Associations.
   subtype    section Types and Subtypes(9),     section Derived Types and Classes(6),     section Scalar Types(9),     section Derived Types and Classes(6),     section Scalar Types,
              section Enumeration Types(10), see section Integer Types(9),   section Integer Types(10), see section Integer Types(9),   section Integer Types,
              section Floating Point Types(11), see section Fixed Point Types(13), see section Fixed Point Types(11), see section Fixed Point Types(13), see section Fixed Point Types,
              section Array Types(15),    section Array Types(16),    section Discriminants(15),    section Array Types(16),    section Discriminants,
              section Tagged Types and Type Extensions(15),    section Access Types(14),   section Language-Defined Attributes (informative)(15),    section Access Types(14),   section Language-Defined Attributes (informative).
unconstrained_array_definition    section Array Types.
   used    section Array Types(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
undefined result    section Exceptions and Optimization.
underline    section Character Set(15), see section ASCII(15), see section ASCII.
   used    section Identifiers(2),    section Decimal Literals(2),    section Decimal Literals,
           section Based Literals(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Uniformly_Distributed    section Random Number Generation.
uninitialized allocator    section Allocators.
uninitialized variables    section Data Validity.
   [partial]    section Object Declarations.
Union    section Abstract Types and Subprograms.
unit consistency    section Consistency of a Distributed System.
Unit_Set    section Abstract Types and Subprograms.
universal type    section Derivation Classes.
universal_fixed
   [partial]    section Real Types.
universal_integer    section Integer Types.
   [partial]    section Integer Types.
universal_real
   [partial]    section Real Types.
unknown discriminants    section Discriminants.
unknown_discriminant_part    section Discriminants.
   used    section Discriminants(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
unmarshalling    section Remote Subprogram Calls.
unpolluted    section The Package Streams.
unsigned    section Interfacing with C, B.4(23)
unsigned type
   See modular type    section Integer Types.
Unsigned_    section The Package Interfaces.
unsigned_char    section Interfacing with C.
unsigned_long    section Interfacing with C.
unsigned_short    section Interfacing with C.
unspecified    section Conformity of an Implementation with the Standard.
   [partial]    section Character Set(5),      section Relational Operators and Membership Tests(13), see section Multiplying Operators(5),      section Relational Operators and Membership Tests(13), see section Multiplying Operators,
                section Formal Parameter Modes(11),     section Package Bodies(5),     section Abort of a Task - Abort of a Sequence of Statements(11),     section Package Bodies(5),     section Abort of a Task - Abort of a Sequence of Statements,
                section Program Execution(26),    section Exception Declarations(6),    section Suppressing Checks(26),    section Exception Declarations(6),    section Suppressing Checks,
                section Representation Items(18),    section The Package System.Address_To_Access_Conversions(5), see section Data Validity(18),    section The Package System.Address_To_Access_Conversions(5), see section Data Validity,
                section Storage Management(20),   section The Package Standard(1),     section Elementary Functions(20),   section The Package Standard(1),     section Elementary Functions,
                section Random Number Generation(28),   section Random Number Generation(34), see section External Files and File Objects(28),   section Random Number Generation(34), see section External Files and File Objects,
                section Text Input-Output(8),     section Input-Output of Characters and Strings(8), see section Input-Output of Characters and Strings(8),     section Input-Output of Characters and Strings(8), see section Input-Output of Characters and Strings,
                section Input-Output of Characters and Strings(19), see section File Sharing(1),    section The Package Command_Line(19), see section File Sharing(1),    section The Package Command_Line,
                section The Standard Task Dispatching Policy(6),    section Monotonic Time(19),    section Complex Types(6),    section Monotonic Time(19),    section Complex Types,
                section Complex Elementary Functions(33),   section Complex Elementary Functions(48), see section Safety and Security (normative)(33),   section Complex Elementary Functions(48), see section Safety and Security (normative),
                section Documentation of Implementation Decisions.
Up_To_K    section Subtype Declarations.
update    section The Package Interfaces.C.Strings(18), see section The Package Interfaces.C.Strings(18), see section The Package Interfaces.C.Strings.
   the value of an object    section Objects and Named Numbers.
Update_Error    section The Package Interfaces.C.Strings.
upper bound
   of a range    section Scalar Types.
upper-case letter
   a category of Character    section The Package Characters.Handling.
upper_case_identifier_letter    section Character Set.
Upper_Case_Map    section String-Handling Sets and Mappings.
Upper_Set    section String-Handling Sets and Mappings.
US    section The Package Characters.Latin_1.
usage name    section Declarations.
use-visible    section Visibility(4), see section Use Clauses(4), see section Use Clauses.
use_clause    section Use Clauses.
   used    section Declarative Parts(4), see section Context Clauses - With Clauses(4), see section Context Clauses - With Clauses,
           section Generic Declarations(5), see section Syntax Summary (informative)(5), see section Syntax Summary (informative).
Use_Error    section The Generic Package Sequential_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO(15),   section The Generic Package Direct_IO(18), see section The Package Text_IO,
             section The Package Streams.Stream_IO(26), see section Exceptions in Input-Output(26), see section Exceptions in Input-Output.
use_package_clause    section Use Clauses.
   used    section Use Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
use_type_clause    section Use Clauses.
   used    section Use Clauses(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
User    section Task Units and Task Objects.
user-defined assignment    section User-Defined Assignment and Finalization.
user-defined heap management    section Storage Management.
user-defined operator    section Overloading of Operators.
user-defined storage management    section Storage Management.

index

Val attribute    section Operations of Discrete Types(5), see section Language-Defined Attributes (informative)(5), see section Language-Defined Attributes (informative).
Valid    section Interfacing with COBOL(33),   section Interfacing with COBOL(38), see section Interfacing with COBOL(33),   section Interfacing with COBOL(38), see section Interfacing with COBOL,
         section The Package Text_IO.Editing(5), see section The Package Text_IO.Editing(5), see section The Package Text_IO.Editing.
Valid attribute    section The Valid Attribute(3), see section Safety and Security (normative)(6), see section Language-Defined Attributes (informative)(3), see section Safety and Security (normative)(6), see section Language-Defined Attributes (informative).
Value    section The Package Strings.Maps(21), see section Random Number Generation(14), see section Random Number Generation(21), see section Random Number Generation(14), see section Random Number Generation,
         section The Package Interfaces.C.Strings(13), see section The Package Interfaces.C.Strings(14), see section The Package Interfaces.C.Strings(13), see section The Package Interfaces.C.Strings(14), see section The Package Interfaces.C.Strings,
         section The Package Interfaces.C.Strings(16), see section The Generic Package Interfaces.C.Pointers(6),   section The Generic Package Interfaces.C.Pointers(16), see section The Generic Package Interfaces.C.Pointers(6),   section The Generic Package Interfaces.C.Pointers,
         section The Package Task_Attributes.
Value attribute    section Scalar Types(52), see section Language-Defined Attributes (informative)(52), see section Language-Defined Attributes (informative).
value conversion    section Type Conversions.
Var_Line    section Index Constraints and Discrete Ranges.
variable    section Objects and Named Numbers.
variable object    section Objects and Named Numbers.
variable view    section Objects and Named Numbers.
variant    section Variant Parts and Discrete Choices.
   used    section Variant Parts and Discrete Choices(2), see section Syntax Summary (informative)(2), see section Syntax Summary (informative).
   See also tagged type    section Tagged Types and Type Extensions.
variant_part    section Variant Parts and Discrete Choices.
   used    section Record Types(4), see section Syntax Summary (informative)(4), see section Syntax Summary (informative).
Vector    section Array Types(26), see section Generic Declarations(24), see section Formal Array Types(26), see section Generic Declarations(24), see section Formal Array Types.
version
   of a compilation unit    section Consistency of a Distributed System.
Version attribute    section Consistency of a Distributed System(3), see section Language-Defined Attributes (informative)(3), see section Language-Defined Attributes (informative).
vertical line    section Character Set.
Vertical_Line    section The Package Characters.Latin_1.
view    section Declarations(7), see section Glossary (informative)(12), see section Glossary (informative)(7), see section Glossary (informative)(12), see section Glossary (informative).
view conversion    section Type Conversions.
virtual function
   See dispatching subprogram    section Dispatching Operations of Tagged Types.
Virtual_Length    section The Generic Package Interfaces.C.Pointers.
visibility
   direct    section Visibility(2), see section Visibility(2), see section Visibility.
   immediate    section Visibility(4), see section Visibility(4), see section Visibility.
   use clause    section Visibility(4), see section Use Clauses(4), see section Use Clauses.
visibility rules    section Visibility.
visible    section Visibility(2), see section Visibility(2), see section Visibility.
   within a pragma in a context_clause    section Environment-Level Visibility Rules.
   within a pragma that appears at the place of a compilation unit
         section Environment-Level Visibility Rules.
   within a with_clause    section Environment-Level Visibility Rules.
   within a use_clause in a context_clause    section Environment-Level Visibility Rules.
   within the parent_unit_name of a library unit    section Environment-Level Visibility Rules.
   within the parent_unit_name of a subunit    section Environment-Level Visibility Rules.
visible part    section Scope of Declarations.
   of a formal package    section Formal Packages.
   of a generic unit    section Scope of Declarations.
   of a package (other than a generic formal package)
         section Package Specifications and Declarations.
   of a protected unit    section Protected Units and Protected Objects.
   of a task unit    section Task Units and Task Objects.
   of a view of a callable entity    section Scope of Declarations.
   of a view of a composite type    section Scope of Declarations.
volatile    section Shared Variable Control.
Volatile pragma    section Shared Variable Control(4), see section Language-Defined Pragmas (informative)(4), see section Language-Defined Pragmas (informative).
Volatile_Components pragma    section Shared Variable Control(6), see section Language-Defined Pragmas (informative)(6), see section Language-Defined Pragmas (informative).
Volt    section Fixed Point Types.
VT    section The Package Characters.Latin_1.
VTS    section The Package Characters.Latin_1.

index

wchar_t    section Interfacing with C.
Weekday    section Enumeration Types.
well-formed picture String
   for edited output    section Picture String Formation.
Wide_Bounded
   child of Ada.Strings    section Wide_String Handling.
Wide_Character    section Character Types(3), see section The Package Standard(3), see section The Package Standard.
Wide_Character_Mapping    section Wide_String Handling.
Wide_Character_Mapping_Function    section Wide_String Handling.
Wide_Character_Range    section Wide_String Handling.
Wide_Character_Sequence    section Wide_String Handling.
Wide_Character_Set    section Wide_String Handling.
Wide_Constants
   child of Ada.Strings.Wide_Maps    section Wide_String Handling.
Wide_Fixed
   child of Ada.Strings    section Wide_String Handling.
Wide_Image attribute    section Scalar Types(28), see section Language-Defined Attributes (informative)(28), see section Language-Defined Attributes (informative).
Wide_Maps
   child of Ada.Strings    section Wide_String Handling.
wide_nul    section Interfacing with C.
Wide_Space    section The Package Strings.
Wide_String    section String Types(4), see section The Package Standard(4), see section The Package Standard.
Wide_Text_IO
   child of Ada    section Wide Text Input-Output.
Wide_Unbounded
   child of Ada.Strings    section Wide_String Handling.
Wide_Value attribute    section Scalar Types(40), see section Language-Defined Attributes (informative)(40), see section Language-Defined Attributes (informative).
Wide_Width attribute    section Scalar Types(38), see section Language-Defined Attributes (informative)(38), see section Language-Defined Attributes (informative).
Width attribute    section Scalar Types(39), see section Language-Defined Attributes (informative)(39), see section Language-Defined Attributes (informative).
with_clause    section Context Clauses - With Clauses.
   used    section Context Clauses - With Clauses(3), see section Syntax Summary (informative)(3), see section Syntax Summary (informative).
   mentioned in section Context Clauses - With Clauses(6)
within
   immediately    section Declarative Region.
word    section Representation Attributes(8), see section Record Representation Clauses(8), see section Record Representation Clauses.
Word_Size    section The Package System.
   named number in package System    section The Package System.
Worker    section Random Number Generation.
Write    section Limited Types(19),     section Limited Types(20),     section Task Units and Task Objects(19),     section Limited Types(20),     section Task Units and Task Objects,
         section Example of Tasking and Synchronization(8),     section Example of Tasking and Synchronization(9),     section The Package Streams(8),     section Example of Tasking and Synchronization(9),     section The Package Streams,
         section The Generic Package Sequential_IO(12),   section The Generic Package Direct_IO(13),   section The Generic Package Storage_IO(12),   section The Generic Package Direct_IO(13),   section The Generic Package Storage_IO,
         section The Package Streams.Stream_IO(18), see section The Package Streams.Stream_IO(19), see section Partition Communication Subsystem(18), see section The Package Streams.Stream_IO(19), see section Partition Communication Subsystem.
Write attribute    section Stream-Oriented Attributes(3), see section Stream-Oriented Attributes(3), see section Stream-Oriented Attributes,
                   section Language-Defined Attributes (informative)(282),      section Language-Defined Attributes (informative)(282),      section Language-Defined Attributes (informative).
Write clause    section Representation Attributes(7), see section Stream-Oriented Attributes(7), see section Stream-Oriented Attributes.

index

xor operator    section Expressions(1), see section Logical Operators and Short-circuit Control Forms(1), see section Logical Operators and Short-circuit Control Forms.

index

Year    section Delay Statements, Duration, and Time.
Year_Number    section Delay Statements, Duration, and Time.
Yen_Sign    section The Package Characters.Latin_1.

This document was generated on 10 May 2001 using the texi2html translator version 1.51.