International Standard ISO/IEC 8652:1995

Information technology -- Programming languages -- Ada
AMENDMENT 1 (Draft 9)

Technologies de l'information -- Langages de programmation -- Ada
AMENDEMENT 1

Amendment 1 to International Standard ISO/IEC 8652:1995 was prepared by AXE Consultants.

This document may be copied, in whole or in part, in any form or by any means, as is, or with alterations, provided that (1) alterations are clearly marked as alterations and (2) this copyright notice is included unmodified in any copy. Compiled copies of standard library units and examples need not contain this copyright notice so long as the notice is included in all copies of the source code and documentation. Any other use or distribution of this document is prohibited without the prior express permission of AXE.

Introduction

International Standard ISO/IEC 8652:1995 defines the Ada programming language.

This amendment modifies Ada by making changes and additions that improve:

The safety of applications written in Ada;
The portability of applications written in Ada;
Interoperability with other languages and systems; and
Accessibility and ease of transition from idioms in other programming and modeling languages.

This amendment incorporates the following major additions to the International Standard:

The Ravenscar profile to provide a simplified tasking system for high-integrity systems (see clause D.13);
A non-preemptive task dispatching policy (see clause D.2.4);
Aggregates, constructor functions, and constants for limited types (see clauses 4.3.1, 6.5, and 7.5);
Control of overriding to eliminate errors (see clause 8.3);
Improvements for access types, such as null excluding subtypes (see clause 3.10), additional uses for anonymous access types (see clauses 3.6 and 8.5.1), and anonymous access-to-subprogram subtypes to support 'downward closures' (see clauses 3.10 and 3.10.2);
Additional context clause capabilities: limited views to allow mutually dependent types (see clauses 3.10.1 and 10.1.2) and private context clauses that apply only in the private part of a package (see clause 10.1.2);
Added standard packages, including time management (see 9.6), file directory and name management (see clause A.16), execution-time clocks (see clause D.14), timing events (see clause D.15), and array and vector operations (see clause G.3);
Interfaces, to provide a limited form of multiple inheritance of operations (see clause 3.9.4); and
A mechanism for writing C unions to make interfaces with C systems easier (see clause B.3.3).

This Amendment is organized by sections corresponding to those in the International Standard. These sections include wording changes and additions to the International Standard. Clause and subclause headings are given for each clause that contains a wording change. Clauses and subclauses that do not contain any change or addition are omitted.

For each change, an anchor paragraph from the International Standard (as corrected by Technical Corrigendum 1) is given. New or revised text and instructions are given with each change. The anchor paragraph can be replaced or deleted, or text can be inserted before or after it. When a heading immediately precedes the anchor paragraph, any text inserted before the paragraph is intended to appear under the heading.

Typographical conventions:

Instructions about the text changes are in this font. The actual text changes are in the same fonts as the International Standard - this font for text, this font for syntax, and this font for Ada source code. Note that this document is designed to be viewed with the default font as some Roman font, similar to the Ada 95 standard. This may require some adjustments to your browser.

Disclaimer:

This document is a draft of a possible amendment to Ada 95 (International Standard ISO/IEC 8652:1995). This draft contains only proposals substantially approved by the ISO/IEC JTC 1/SC 22/WG 9 Ada Rapporteur Group (ARG). Many other important proposals are under consideration by the ARG. Neither the ARG nor any other group has determined which, if any, of these proposals will be included in the amendment. Any proposal may be substantially changed or withdrawn before this document begins standardization, and other proposals may be added. This document is not an official publication or work product of the ARG.

Forward and Introduction

Introduction

Replace paragraph 3: [AI95-00387-01]

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.

by:

Ada 95 Rationale. This gives an introduction to the new features of Ada incorporated in the 1995 edition of this Standard, and explains the rationale behind them. Programmers unfamiliar with Ada 95 should read this first.

Ada 2005 Rationale. This gives an introduction to the changes and new features in Ada 2005 (compared with the 1995 edition), and explains the rationale behind them. Programmers should read this rationale before reading this Standard in depth.

Replace paragraph 5: [AI95-00387-01]

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.

by:

The Annotated Ada Reference Manual (AARM). The AARM contains all of the text in the consolidated Ada Reference Manual, 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.

Replace paragraph 6: [AI95-00387-01]

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.

by:

Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. The 1995 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. This amended version provides further flexibility and adds more standardized packages within the framework provided by the 1995 revision.

Replace paragraph 32: [AI95-00285-01; AI95-00387-01]

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.

by:

Replace paragraph 34: [AI95-00285-01; AI95-00387-01]

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.

by:

Insert after paragraph 38: [AI95-00387-01]

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.

the new paragraph:

Interface types provide abstract models from which other interfaces and types may be composed and derived. This provides a reliable form of multiple inheritance. Interface types may also be implemented by synchronized types (task types and protected types) thereby enabling concurrent programming and inheritance to be merged.

Replace paragraph 41: [AI95-00387-01]

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.

by:

Aspect 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.

Replace paragraph 42: [AI95-00387-01]

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.

by:

The predefined environment of the language provides for input-output and other capabilities 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.

The predefined standard library packages provide facilities such as string manipulation, containers of various kinds (vectors, lists, maps etc.), mathematical functions, random number generation, and access to the execution environment.

The specialized annexes define further predefined library packages and facilities with emphasis on areas such as real-time scheduling, interrupt handling, distributed systems, numerical computation, and high-integrity systems.

Replace paragraph 44: [AI95-00387-01]

This International Standard replaces the first edition of 1987. In this edition, the following major language changes have been incorporated:

by:

This amended International Standard updates the edition of 1995 which replaced the first edition of 1987. In the 1995 edition, the following major language changes were incorporated:

Replace paragraph 45: [AI95-00387-01]

Support for standard 8-bit and 16-bit character sets. See Section 2, 3.5.2, 3.6.3, A.1, A.3, and A.4.

by:

Support for standard 8-Bit and 16-bit characters was added. See clauses 2.1, 3.5.2, 3.6.3, A.1, A.3, and A.4.

Replace paragraph 46: [AI95-00387-01]

Object-oriented programming with run-time polymorphism. See the discussions of classes, derived types, tagged types, record extensions, and private extensions in clauses 3.4, 3.9, and 7.3. See also the new forms of generic formal parameters that are allowed by 12.5.1, ``Formal Private and Derived Types'' and 12.7, ``Formal Packages''.

by:

The type model was extended to include facilities for object-oriented programming with dynamic polymorphism. See the discussions of classes, derived types, tagged types, record extensions, and private extensions in clauses 3.4, 3.9, and 7.3. Additional forms of generic formal parameters were allowed as described in clauses 12.5.1 and 12.7.

Replace paragraph 47: [AI95-00387-01]

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 3.10.

by:

Access types were extended to allow an access value to designate a subprogram or an object declared by an object declaration as opposed to just an object allocated on a heap. See clause 3.10.

Replace paragraph 48: [AI95-00387-01]

Efficient data-oriented synchronization is provided via protected types. See Section 9.

by:

Efficient data-oriented synchronization was provided by the introduction of protected types. See clause 9.4.

Replace paragraph 49: [AI95-00387-01]

The library units of a library may be organized into a hierarchy of parent and child units. See Section 10.

by:

The library structure was extended to allow library units to be organized into a hierarchy of parent and child units. See clause 10.1.

Replace paragraph 50: [AI95-00387-01]

Additional support has been added for interfacing to other languages. See Annex B.

by:

Additional support was added for interfacing to other languages. See Annex B.

Replace paragraph 51: [AI95-00387-01]

The Specialized Needs Annexes have been added to provide specific support for certain application areas:

by:

The Specialized Needs Annexes were added to provide specific support for certain application areas:

Replace paragraph 57: [AI95-00387-01]

Annex H, ``Safety and Security''

by:

Annex H, ``High Integrity Systems''

Amendment 1 modifies the 1995 International Standard by making changes and additions that improve the capability of the language and the reliability of programs written in the language. In particular the changes were designed to improve the portability of programs, interfacing to other languages, and both the object-oriented and real-time capabilities.

The following significant changes with respect to the 1995 edition are incorporated:

Support for program text is extended to cover the entire ISO/IEC 10646:2003 repertoire. Execution support now includes the 32-bit character set. See clauses 2.1, 3.5, 3.6, A.1, A.3, and A.4.

The object-oriented model has been improved by the addition of an interface facility which provides multiple inheritance and additional flexibility for type extensions. See clauses 3.4, 3.9, and 7.3. An alternative notation for calling operations more akin to that used in other languages has also been added. See clause 4.1.3.

Access types have been further extended to unify properties such as the ability to access constants and to exclude null values. See clause 3.10. Anonymous access types are now permitted more freely and anonymous access-to-subprogram types are introduced. See clauses 3.3, 3.6, 3.10, and 8.5.1.

The control of structure and visibility has been enhanced to permit mutually dependent references between units and finer control over access from the private part of a package. See clauses 3.10.1 and 10.1.2. In addition, limited types have been made more useful by the provision of aggregates, constants, and constructor functions. See clauses 4.3, 6.5, and 7.5.

The predefined environment has been extended to include additional time and calendar operations, improved string handling, a comprehensive container library, file and directory management, and access to environment variables. See clauses 9.6.1, A.4, A.16, A.17, and A.18.

Two of the Specialized Needs Annexes have been considerably enhanced:

The Real-Time Systems Annex now includes the Ravenscar profile for high-integrity systems, further dispatching policies such as Round Robin and Earliest Deadline First, support for timing events, and support for control of CPU time utilization. See clauses D.2, D.13, D.14, and D.15.

The Numerics Annex now includes support for real and complex vectors and matrices as previously defined in ISO/IEC 13813:1997 plus further basic operations for linear algebra. See clause G.3.

The overall reliability of the language has been enhanced by a number of improvements. These include new syntax which detects accidental overloading, as well as pragmas for making assertions and giving better control over the suppression of checks. See clauses 6.1, 11.4.2, and 11.5.

Section 1: General

1.1.2 Structure

Replace paragraph 13: [AI95-00347-01]

Annex H, ``Safety and Security''

by:

Annex H, ``High Integrity Systems''

1.1.4 Method of Description and Syntax Notation

Insert after paragraph 14: [AI95-00285-01]

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.

the new paragraph:

numeric_literal

1.2 Normative References

Insert after paragraph 5: [AI95-00351-01]

Information technology - Control functions for coded graphic character sets.

the new paragraph:

Data elements and interchange formats - Information interchange - Representation of dates and times

Replace paragraph 8: [AI95-00285-01]

Information technology - Universal Multiple-Octet Coded Character Set (UCS) - Part 1: Architecture and Basic Multilingual Plane

by:

Information technology - Universal Multiple-Octet Coded Character Set (UCS)

Section 2: Lexical Elements

2.1 Character Set

Replace paragraph 1: [AI95-00285-01]

comment

graphic_character

format_effector

by:

other_control

other_private_use

other_surrogate

comment

Delete paragraph 2: [AI95-00285-01]

character ::= graphic_character | format_effector | other_control_function

Delete paragraph 3: [AI95-00285-01]

graphic_character ::= identifier_letter | digit | space_character | special_character

Replace paragraph 4: [AI95-00285-01]

format_effector

other_control_function

by:

The character repertoire for the text of an Ada program consists of the collection of characters described by the ISO/IEC 10646:2003 Universal Multiple-Octet Coded Character Set. The coded representation for these characters is implementation defined (it need not be a representation defined within ISO/IEC 10646:2003).

The semantics of an Ada program whose text is not in Normalization Form KC (as defined by section 24 of ISO/IEC 10646:2003) are implementation defined.

Replace paragraph 5: [AI95-00285-01]

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.

by:

The description of the language definition in this International Standard uses the character properties General Category, Simple Uppercase Mapping, Uppercase Mapping, and Special Case Condition of the documents referenced by the note in section 1 of ISO/IEC 10646:2003. The actual set of graphic symbols used by an implementation for the visual representation of the text of an Ada program is not specified.

Delete paragraph 7: [AI95-00285-01]

identifier_letter: upper_case_identifier_letter | lower_case_identifier_letter

Replace paragraph 8: [AI95-00285-01]

upper_case_identifier_letter: Any character of Row 00 of ISO 10646 BMP whose name begins ``Latin Capital Letter''.

by:

letter_uppercase: Any character whose General Category is defined to be "Letter, Uppercase".

Replace paragraph 9: [AI95-00285-01]

lower_case_identifier_letter: Any character of Row 00 of ISO 10646 BMP whose name begins ``Latin Small Letter''.

by:

letter_lowercase: Any character whose General Category is defined to be "Letter, Lowercase".

letter_titlecase: Any character whose General Category is defined to be "Letter, Titlecase".

letter_modifier: Any character whose General Category is defined to be "Letter, Modifier".

letter_other: Any character whose General Category is defined to be "Letter, Other".

mark_non_spacing: Any character whose General Category is defined to be "Mark, Non-Spacing".

mark_spacing_combining: Any character whose General Category is defined to be "Mark, Spacing Combining".

Replace paragraph 10: [AI95-00285-01]

digit: One of the characters 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9.

by:

number_decimal_digit: Any character whose General Category is defined to be "Number, Decimal Digit".

number_letter: Any character whose General Category is defined to be "Number, Letter".

Delete paragraph 11: [AI95-00285-01]

space_character: The character of ISO 10646 BMP named ``Space''.

Replace paragraph 12: [AI95-00285-01]

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.

by:

other_control: Any character whose General Category is defined to be "Other, Control".

other_format: Any character whose General Category is defined to be "Other, Format".

other_private_use: Any character whose General Category is defined to be "Other, Private Use".

other_surrogate: Any character whose General Category is defined to be "Other, Surrogate".

punctuation_connector: Any character whose General Category is defined to be "Punctuation, Connector".

separator_space: Any character whose General Category is defined to be "Separator, Space".

separator_line: Any character whose General Category is defined to be "Separator, Line".

separator_paragraph: Any character whose General Category is defined to be "Separator, Paragraph".

Replace paragraph 13: [AI95-00285-01]

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).

by:

format_effector: The characters whose code position is 16#09# (CHARACTER TABULATION), 16#0A# (LINE FEED(LF)), 16#0B# (LINE TABULATION), 16#0C# (FORM FEED(FF)), 16#0D# (CARRIAGE RETURN(CR)), 16#85# (NEXT LINE(NEL)), and the characters in categories separator_line and separator_paragraph. The names mentioned in parentheses in this list are not defined by ISO/IEC 10646:2003; they are only used for convenience in this International Standard.

Replace paragraph 14: [AI95-00285-01]

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.

by:

graphic_character: Any character which is not in the categories other_control, other_private_use, other_surrogate, other_format, format_effector, and whose code position is neither 16#FFFE# nor 16#FFFF#.

Replace paragraph 15: [AI95-00285-01]

special_character

by:

The following names are used when referring to certain characters (the first name is that given in ISO/IEC 10646:2003):

Delete paragraph 16: [AI95-00285-01]

identifier_letter

Delete paragraph 17: [AI95-00285-01]

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.

2.2 Lexical Elements, Separators, and Delimiters

Replace paragraph 3: [AI95-00285-01]

separator

by:

separator

separator_space

format_effector

Replace paragraph 4: [AI95-00285-01]

A space character is a separator except within a comment, a string_literal, or a character_literal.

by:

A separator_space is a separator except within a comment, a string_literal, or a character_literal.

Replace paragraph 5: [AI95-00285-01]

Character tabulation (HT) is a separator except within a comment.

by:

Character Tabulation is a separator except within a comment.

Replace paragraph 8: [AI95-00285-01]

A delimiter is either one of the following special characters:

by:

A delimiter is either one of the following characters:

2.3 Identifiers

Replace paragraph 2: [AI95-00285-01]

identifier ::=
   identifier_letter {[underline] letter_or_digit}

by:

identifier_start ::= letter_uppercase |
                     letter_lowercase |
                     letter_titlecase |
                     letter_modifier |
                     letter_other |
                     number_letter
identifier_extend ::= identifier_start |
                      mark_non_spacing |
                      mark_spacing_combining |
                      number_decimal_digit |
                      other_format
identifier ::= identifier_start {[punctuation_connector] identifier_extend}

Delete paragraph 3: [AI95-00285-01]

letter_or_digit ::= identifier_letter | digit

Replace paragraph 5: [AI95-00285-01]

identifier

Identifier

by:

identifier

The characters in category other_format are eliminated.

Full case folding, as defined by documents referenced in the note in section 1 of ISO/IEC 10646:2003, is applied to obtain the uppercase version of each character.

Insert after paragraph 6: [AI95-00285-01]

identifier

the new paragraph:

NOTES
3 Identifiers differing only in the use of corresponding upper and lower case letters are considered the same.

2.6 String Literals

Insert after paragraph 6: [AI95-00285-01]

null string literal

string_literal

string_element

the new paragraph:

string_literal

2.9 Reserved Words

In the list in paragraph 2, add: [AI95-00284-02]

interface

overriding

synchronized

Section 3: Declarations and Types

3.1 Declarations

Replace paragraph 3: [AI95-00348-01]

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

by:

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

3.2 Types and Subtypes

Replace paragraph 4: [AI95-00326-01]

record

record extensions

array

task

protected

private

private extension

by:

record

record extensions

array

task

protected

incomplete

private

private extension

Replace paragraph 5: [AI95-00326-01]

discriminants

by:

discriminants

Replace paragraph 6: [AI95-00366-01]

subcomponent

part

by:

subcomponent

part

3.2.1 Type Declarations

Replace paragraph 4: [AI95-00251-01]

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

by:

type_definition ::=
     enumeration_type_definition | integer_type_definition
   | real_type_definition | array_type_definition
   | record_type_definition | access_type_definition
   | derived_type_definition | interface_type_definition

Replace paragraph 8: [AI95-00326-01]

full_type_declaration

full type

type_definition

task_definition

protected_definition

access_definition

full type definition

type_declaration

by:

full_type_declaration

full type

full view

type_definition

task_definition

protected_definition

access_definition

full type definition

type_declaration

3.2.2 Subtype Declarations

Replace paragraph 3: [AI95-00231-01]

subtype_indication ::=  subtype_mark [constraint]

by:

subtype_indication ::=  [null_exclusion] subtype_mark [constraint]

3.2.3 Classification of Operations

Insert after paragraph 6: [AI95-00335-01]

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;

the new paragraph:

For a specific type, the stream-oriented attributes of the type that are available (see 13.13.2) at the end of the list of declarative_items where the type is declared;

Replace paragraph 7: [AI95-00200-01]

Any subprograms not covered above that are explicitly declared immediately within the same declarative region as the type and that override (see 8.3) other implicitly declared primitive subprograms of the type.

by:

In the case of a nonformal type, any subprograms not covered above that are explicitly declared immediately within the same declarative region as the type and that override (see 8.3) other implicitly declared primitive subprograms of the type.

3.3.1 Object Declarations

Replace paragraph 2: [AI95-00385-01]

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

by:

object_declaration ::=
   defining_identifier_list : [aliased] [constant] subtype_indication [:= expression]
 | defining_identifier_list : [constant] access_definition [:= expression]
 | defining_identifier_list : [aliased] [constant] array_type_definition [:= expression]
 | single_task_declaration
 | single_protected_declaration

Replace paragraph 5: [AI95-00287-01]

object_declaration

constant

subtype_indication

array_type_definition

by:

object_declaration

constant

subtype_indication

array_type_definition

Replace paragraph 8: [AI95-00373-01; AI95-00385-01]

subtype_indication

object_declaration

by:

subtype_indication

access_definition

object_declaration

require late initialization

Replace paragraph 9: [AI95-00363-01]

object_declaration

constrained by its initial value

constrained object

by:

object_declaration

constrained by its initial value

constrained object

Replace paragraph 16: [AI95-00385-01]

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).

by:

1.: The subtype_indication, access_definition, array_type_definition, single_task_declaration, or single_protected_declaration is first elaborated. This creates the nominal subtype (and the anonymous type in the last four cases).

Replace paragraph 18: [AI95-00373-01]

3.: The object is created, and, if there is not an initialization expression, any per-object expressions (see 3.8) are elaborated and any implicit initial values for the object or for its subcomponents are obtained as determined by the nominal subtype.

by:

3.: The object is created, and, if there is not an initialization expression, any per-object expressions (see 3.8) are elaborated and any implicit initial values for the object or for its subcomponents are obtained as determined by the nominal subtype. Any initial values (whether explicit or implicit) are assigned to the object or to the corresponding subcomponents. As described in 5.2 and 7.6, Initialize and Adjust procedures can be called.

Delete paragraph 19: [AI95-00373-01]

4.: Any initial values (whether explicit or implicit) are assigned to the object or to the corresponding subcomponents. As described in 5.2 and 7.6, Initialize and Adjust procedures can be called.

Replace paragraph 20: [AI95-00373-01]

default_expression

by:

For the third step above, evaluations and assignments are performed in an arbitrary order subject to the following restrictions:

Assignment to any part of the object is preceded by the evaluation of the value that is to be assigned;

the evaluation of a default_expression that includes the name of a discriminant is preceded by the assigment to that discriminant;

the evaluation of the default_expression for any component that depends on a discriminant is preceded by the assignment to that discriminant;

the assignments to any components, including implicit components, not requiring late initialization must precede the initial value evaluations for any components requiring late initialization; if two components both require late initialization, then assignments to parts of the component occurring earlier in the order of the component declarations must precede the initial value evaluations of the component occurring later.

3.4 Derived Types and Classes

Replace paragraph 2: [AI95-00251-01]

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

by:

interface_list ::= interface_subtype_mark {and interface_subtype_mark}

derived_type_definition ::=
    [abstract] new parent_subtype_indication [[and interface_list] record_extension_part]

Replace paragraph 3: [AI95-00251-01]

parent_

subtype_indication

by:

parent_

subtype_indication

Replace paragraph 8: [AI95-00251-01]

Each class of types that includes the parent type also includes the derived type.

by:

Each class of types that includes the parent type or an interface ancestor type also includes the derived type.

Insert after paragraph 23: [AI95-00251-01]

derived_type_definition

the new paragraph:

interface_list

Replace paragraph 27: [AI95-00391-01]

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 6.4.1) 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.

by:

extension_aggregate

ancestor_part

null record

record_component_association_list

Insert after paragraph 35: [AI95-00251-01]

17 If the reserved word abstract is given in the declaration of a type, the type is abstract (see 3.9.3).

the new paragraph:

18 An interface type which has an interface ancestor "is derived from" that type, and therefore is a derived type. A derived_type_definition, however, never defines an interface type.

3.4.1 Derivation Classes

Replace paragraph 2: [AI95-00251-01]

derived from

directly

indirectly

rooted

root type

by:

derived from

directly

indirectly

rooted

root type

Replace paragraph 6: [AI95-00230-01]

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 8.6).

by:

Universal types: Universal types are defined for (and belong to) the integer, real, fixed point, and access classes, and are referred to in this standard as respectively, universal_integer, universal_real, universal_fixed, and universal_access. These are analogous to class-wide types for these language-defined 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 8.6).

Replace paragraph 10: [AI95-00251-01]

descendant

ancestor

ultimate ancestor

by:

descendant

ancestor

ultimate ancestor

3.5 Scalar Types

Insert after paragraph 27: [AI95-00285-01]

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 3.5.7) immediately below the value of Arg; Constraint_Error is raised if there is no such machine number.

the new paragraphs:

S'Wide_Wide_Image: S'Wide_Wide_Image denotes a function with the following specification:

        function S'Wide_Wide_Image(Arg : S'Base)
          return Wide_Wide_String

image

Arg

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.

nongraphic character

nul

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 3.5.8) 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.

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 3.5.10) digits after the decimal point.

Replace paragraph 30: [AI95-00285-01]

image

Arg

by:

Arg

Delete paragraph 31: [AI95-00285-01]

Delete paragraph 32: [AI95-00285-01]

nongraphic character

nul

Delete paragraph 33: [AI95-00285-01]

Delete paragraph 34: [AI95-00285-01]

Replace paragraph 37: [AI95-00285-01]

Arg

by:

Arg

S'Wide_Wide_Width: S'Wide_Wide_Width denotes the maximum length of a Wide_Wide_String returned by S'Wide_Wide_Image over all the values of S. It denotes zero for a subtype that has a null range. Its type is universal_integer.

Insert after paragraph 39: [AI95-00285-01]

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.

the new paragraphs:

S'Wide_Wide_Value: S'Wide_Wide_Value denotes a function with the following specification:

        function S'Wide_Wide_Value(Arg : Wide_Wide_String)
          return S'Base

This function returns a value given an image of the value as a Wide_Wide_String, ignoring any leading or trailing spaces.

For the evaluation of a call on S'Wide_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_Wide_Image for a nongraphic character of the type), the result is the corresponding enumeration value; otherwise Constraint_Error is raised.

For the evaluation of a call on S'Wide_Wide_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.

For the evaluation of a call on S'Wide_Wide_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:

numeric_literal

numeral.[exponent]

.numeral[exponent]

base#based_numeral.#[exponent]

base#.based_numeral#[exponent]

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.

Replace paragraph 43: [AI95-00285-01]

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.

by:

Arg

Delete paragraph 44: [AI95-00285-01]

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.

Delete paragraph 45: [AI95-00285-01]

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:

Delete paragraph 46: [AI95-00285-01]

numeric_literal

Delete paragraph 47: [AI95-00285-01]

numeral.[exponent]

Delete paragraph 48: [AI95-00285-01]

.numeral[exponent]

Delete paragraph 49: [AI95-00285-01]

base#based_numeral.#[exponent]

Delete paragraph 50: [AI95-00285-01]

base#.based_numeral#[exponent]

Delete paragraph 51: [AI95-00285-01]

Replace paragraph 55: [AI95-00285-01]

Arg

by:

Arg

Replace paragraph 56: [AI95-00285-01]

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.

by:

An implementation may extend the Wide_Wide_Value, Wide_Value, Value, Wide_Wide_Image, Wide_Image, and Image attributes of a floating point type to support special values such as infinities and NaNs.

Replace paragraph 59: [AI95-00285-01]

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.

by:

21 For any value V (including any nongraphic character) of an enumeration subtype S, S'Value(S'Image(V)) equals V, as do S'Wide_Value(S'Wide_Image(V)) and S'Wide_Wide_Value(S'Wide_Wide_Image(V)). None of these expressions ever raise Constraint_Error.

3.5.2 Character Types

Replace paragraph 2: [AI95-00285-01]

character_literal

italics

by:

character_literal

italics

Replace paragraph 3: [AI95-00285-01]

character_literal

FFFE

FFFF

FFFE

FFFF

character_literal

by:

character_literal

graphic_character

character_literal

graphic_character

character_literal

FFFE

FFFF

graphic_character

Replace paragraph 4: [AI95-00285-01]

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

by:

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

Delete paragraph 5: [AI95-00285-01]

identifier_letter

3.5.4 Integer Types

Replace paragraph 16: [AI95-00340-01]

For every modular subtype S, the following attribute is defined:

by:

For every modular subtype S, the following attributes are defined:

S'Mod

S'Mod denotes a function with the following specification:

        function S'Mod (Arg : universal_integer)
             return S'Base

Arg

mod

3.5.9 Fixed Point Types

Replace paragraph 8: [AI95-00100-01]

small

ordinary_fixed_point_definition

ordinary

small

attribute_definition_clause

delta

small

delta

by:

small

machine numbers

ordinary_fixed_point_definition

ordinary

small

attribute_definition_clause

delta

small

delta

3.6 Array Types

Replace paragraph 7: [AI95-00230-01]

component_definition ::= [aliased] subtype_indication

by:

component_definition ::= [aliased] subtype_indication | access_definition

Delete paragraph 11: [AI95-00363-01]

component_definition

aliased

Replace paragraph 22: [AI95-00230-01]

discrete_subtype_definition

subtype_indication

range

discrete_subtype_definition

component_definition

array_type_definition

subtype_indication

discrete_subtype_definition

component_definition

by:

discrete_subtype_definition

subtype_indication

range

discrete_subtype_definition

component_definition

array_type_definition

subtype_indication

access_definition

discrete_subtype_definition

component_definition

3.6.2 Operations of Array Types

Replace paragraph 16: [AI95-00287-01]

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.

by:

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. 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.

3.6.3 String Types

Replace paragraph 2: [AI95-00285-01]

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:

by:

There are three predefined string types, String, Wide_String, and Wide_Wide_String, each indexed by the value of the predefined subtype Positive; these are declared in the visible part of package Standard:

Replace paragraph 4: [AI95-00285-01]

type String is array (Positive range <>) of Character;
type Wide_String is array (Positive range <>) of Wide_Character;

by:

type String is array (Positive range <>) of Character;
type Wide_String is array (Positive range <>) of Wide_Character;
type Wide_Wide_String is array (Positive range <>) of Wide_Wide_Character;

3.7 Discriminants

Replace paragraph 1: [AI95-00326-01]

known_discriminant_part

unknown_discriminant_part

by:

known_discriminant_part

unknown_discriminant_part

Replace paragraph 5: [AI95-00231-01]

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

by:

discriminant_specification ::=
    defining_identifier_list : [null_exclusion] subtype_mark [:= default_expression]
  | defining_identifier_list : access_definition [:= default_expression]

Replace paragraph 9: [AI95-00231-01; AI95-00254-01]

subtype_mark

access_definition

subtype_mark

access_definition

access discriminant

subtype_mark

access_definition

by:

null_exclusion

subtype_mark

access_definition

access discriminant

Delete paragraph 10: [AI95-00230-01]

discriminant_specification

limited

Replace paragraph 27: [AI95-00230-01]

access_definition

default_expression

discriminant_constraint

access_definition

by:

access_definition

default_expresssion

discriminant_constraint

access_definition

known_discriminant_part

access_definition

3.7.1 Discriminant Constraints

Replace paragraph 7: [AI95-00363-01]

discriminant_constraint

subtype_indication

subtype_mark

discriminant_constraint

by:

discriminant_constraint

subtype_indication

subtype_mark

discriminant_constraint

3.8 Record Types

Delete paragraph 8: [AI95-00287-01]

default_expression

Replace paragraph 9: [AI95-00366-01]

component_declaration

component

component_declaration

discriminant_specification

by:

component_declaration

discriminant_specification

Insert before paragraph 14: [AI95-00318-02]

component_definition

component_declaration

aliased

component_definition

the new paragraph:

record_type_declaration

limited

limited record

Replace paragraph 18: [AI95-00230-01]

component_definition

discrete_subtype_definition

name

attribute_reference

prefix

name

per-object expression

constraint

range

per-object constraint

component_definition

component_declaration

discrete_subtype_definition

entry_declaration

constraint

range

subtype_indication

discrete_subtype_definition

subtype_indication

discrete_subtype_definition

constraint

range

by:

component_definition

discrete_subtype_definition

name

attribute_reference

prefix

name

per-object expression

constraint

range

per-object constraint

component_definition

component_declaration

discrete_subtype_definition

entry_declaration

access_definition

constraint

range

subtype_indication

discrete_subtype_definition

access_definition

subtype_indication

discrete_subtype_definition

constraint

range

Replace paragraph 25: [AI95-00287-01]

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.

by:

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.

3.9 Tagged Types and Type Extensions

Replace paragraph 4: [AI95-00344-01]

full_type_declaration

generic_package_declaration

by:

full_type_declaration

generic_package_declaration

Replace paragraph 6: [AI95-00260-02; AI95-00362-01]

package Ada.Tags is
    type Tag is private;

by:

package Ada.Tags is
    pragma Preelaborate(Tags);
    type Tag is private;

    No_Tag : constant Tag;

Insert after paragraph 7: [AI95-00260-02; AI95-00344-01]

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

the new paragraphs:

    function Descendant_Tag(External : String; Ancestor : Tag) return Tag;
    function Is_Descendant_At_Same_Level(Descendant, Ancestor : Tag)
        return Boolean;

    function Parent_Tag (T : Tag) return Tag;

Insert after paragraph 9: [AI95-00260-02]

private
   ... -- not specified by the language
end Ada.Tags;

the new paragraph:

No_Tag is the default initial value of type Tag.

Replace paragraph 12: [AI95-00260-02; AI95-00279-01; AI95-00344-01]

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.

by:

The function Internal_Tag returns a 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. Tag_Error is also raised if the specific type identified is a library-level type whose tag has not yet been created.

The function Descendant_Tag returns the (internal) tag for the type that corresponds to the given external tag and is both a descendant of the type identified by the Ancestor tag and has the same accessibility level as the identified ancestor. Tag_Error is raised if External is not the external tag for such a type. Tag_Error is also raised if the specific type identified is a library-level type whose tag has not yet been created.

The function Is_Descendant_At_Same_Level returns True if Descendant tag identifies a type that is both a descendant of the type identified by Ancestor and at the same accessibility level. If not, it returns False.

The function Parent_Tag returns the tag of the parent type of the type whose tag is T. If the type does not have a parent type (that is, it was not declared by a derived_type_declaration), then No_Tag is returned.

Insert after paragraph 18: [AI95-00260-02]

X'Tag: X'Tag denotes the tag of X. The value of this attribute is of type Tag.

the new paragraphs:

The following language-defined generic function exists:

generic
    type T (<>) is abstract tagged limited private;
    type Parameters (<>) is limited private;
    with function Constructor (Params : access Parameters)
        return T is abstract;
function Ada.Tags.Generic_Dispatching_Constructor
   (The_Tag : Tag;
    Params : access Parameters) return T'Class;
pragma Preelaborate (Generic_Dispatching_Constructor);
pragma Convention (Intrinsic, Generic_Dispatching_Constructor);

Tags.Generic_Dispatching_Constructor provides a mechanism to create an object of an appropriate type from just a tag value. The function Constructor is expected to create the object given a reference to an object of type Parameters.

Insert after paragraph 25: [AI95-00260-02; AI95-00344-01]

The tag is preserved by type conversion and by parameter passing. The tag of a value is the tag of the associated object (see 6.2).

the new paragraphs:

Tag_Error is raised by a call of Descendant_Tag, Expanded_Name, External_Tag, Is_Descendant_At_Same_Level, or Parent_Tag if any tag passed is No_Tag.

An instance of Tags.Generic_Dispatching_Constructor or Tags.Generic_Limited_Dispatching_Constructor raises Tag_Error if The_Tag does not represent a concrete descendant of T. Otherwise, it dispatches to the primitive function denoted by the formal Constructor for the type identified by the tag The_Tag, passing Params, and returns the result. Any exception raised by the function is propagated.

Erroneous Execution

If the internal tag provided to an instance of Tags.Generic_Dispatching_Constructor or Tags.Generic_Limited_Dispatching_Constructor identifies a specific type whose tag has not been elaborated, or does not exist in the partition at the time of the call, execution is erroneous.

Replace paragraph 26: [AI95-00279-01]

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.

by:

The implementation of the functions in Ada.Tags may raise Tag_Error if no specific type corresponding to the tag or external tag passed as a parameter exists in the partition at the time the function is called.

Insert after paragraph 30: [AI95-00260-02]

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 7.3.1). 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 3.10.1).

the new paragraph:

66 The capability provided by Tags.Generic_Dispatching_Constructor is sometimes known as a factory.

3.9.1 Type Extensions

Replace paragraph 3: [AI95-00344-01; AI95-00345-01]

record_extension_part

by:

record_extension_part

Replace paragraph 4: [AI95-00344-01; AI95-00391-01]

A type extension shall not be declared in a generic body if the parent type is declared outside that body.

by:

Within the body of a generic unit, or the body of any of its descendant library units, a tagged type shall not be declared as a descendant of a formal type declared within the formal part of the generic unit.

Static Semantics

null extension

known_discriminant_part

record_extension_part

component_declaration

Replace paragraph 7: [AI95-00344-01]

library package_specification

package_body

by:

package_body

3.9.2 Dispatching Operations of Tagged Types

Replace paragraph 1: [AI95-00260-02]

dispatching operations

controlling

dispatches

dispatching call

by:

dispatching operations

formal_abstract_subprogram_declaration

controlling

dispatches

dispatching call

Replace paragraph 2: [AI95-00260-02]

call on a dispatching operation

name

prefix

controlling operand

controlling formal parameter

controlling result

by:

call on a dispatching operation

name

prefix

controlling operand

controlling formal parameter

controlling result

Replace paragraph 17: [AI95-00196-01]

If all of the controlling operands are tag-indeterminate, then:

by:

If all of the controlling operands (if any) are tag-indeterminate, then:

Replace paragraph 18: [AI95-00196-01; AI95-00239-01]

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;

by:

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 a descendant of type T, then its controlling tag value is determined by the controlling tag value of this enclosing call;

If the call has a controlling result and is the (possibly parenthesized or qualified) expression of an assignment_statement whose target is of a class-wide type, then its controlling tag value is determined by the target;

3.9.3 Abstract Types and Subprograms

Replace paragraph 1: [AI95-00345-01]

abstract type

abstract subprogram

by:

abstract type

abstract subprogram

Static Semantics

abstract

Replace paragraph 2: [AI95-00345-01]

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.

by:

abstract

Replace paragraph 3: [AI95-00260-02]

abstract_subprogram_declaration

abstract subprogram

by:

abstract_subprogram_declaration

formal_abstract_subprogram_declaration

abstract subprogram

Replace paragraph 4: [AI95-00251-01; AI95-00334-01]

For a derived type, if the parent or ancestor type has an abstract primitive subprogram, or a primitive function with a controlling result, then:

by:

If a type has an implicitly declared primitive subprogram that is inherited or is the predefined equality operator, and the corresponding primitive subprogram of the parent or ancestor type is abstract or a function with a controlling access result, or a type other than a null extension inherits a function with a controlling result, then:

Replace paragraph 5: [AI95-00251-01; AI95-00334-01]

If the derived type is abstract or untagged, the inherited subprogram is abstract.

by:

If the type is abstract or untagged, the implicitly declared subprogram is abstract.

Replace paragraph 6: [AI95-00391-01]

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.

by:

Otherwise, the subprogram shall be overridden with a nonabstract subprogram or, in the case of a private extension inheriting a function with a controlling result, have a full type that is a null extension; 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.

Replace paragraph 11: [AI95-00260-02]

prefix

attribute_reference

by:

formal_abstract_subprogram_declaration

prefix

attribute_reference

3.9.4 Interface Types

Insert new clause: [AI95-00251-01; AI95-00345-01]

An interface type is an abstract tagged type which provides a restricted form of multiple inheritance. A tagged, task, or protected type may be derived from one or more interface types.

Syntax

interface_type_definition ::=
    [limited | task | protected | synchronized] interface [and interface_list]

Static Semantics

interface_type_definition

limited

task

protected

synchronized

limited interface

task interface

protected interface

synchronized interface

synchronized

An interface type has no components.

Legality Rules

All user-defined primitive subprograms of an interface type shall be abstract subprograms or null procedures.

interface_list

A descendant of a nonlimited interface shall be nonlimited. A descendant of a task interface shall be a task type or a task interface. A descendant of a protected interface shall be a protected type or a protected interface. A descendant of a synchronized interface shall be a task type, a protected type, or a synchronized interface.

A full view shall be a descendant of an interface type if and only if the corresponding partial view (if any) is also a descendant of the interface type.

For an interface type declared in a visible part, a primitive subprogram shall not be declared in the private part.

In addition to the places where Legality Rules normally apply (see 12.3), these rules apply also in the private part of an instance of a generic unit.

3.10 Access Types

Replace paragraph 2: [AI95-00231-01]

access_type_definition ::=
    access_to_object_definition
  | access_to_subprogram_definition

by:

access_type_definition ::=
    [null_exclusion] access_to_object_definition
  | [null_exclusion] access_to_subprogram_definition

Replace paragraph 6: [AI95-00231-01; AI95-00254-01]

access_definition ::= access subtype_mark

by:

null_exclusion ::= not null
access_definition ::=
   [null_exclusion] access [general_access_modifier] subtype_mark
 | [null_exclusion] access [protected] procedure parameter_profile
 | [null_exclusion] access [protected] function parameter_and_result_profile

Replace paragraph 9: [AI95-00225-01; AI95-00363-01]

aliased

object_declaration

component_definition

aliased

object_declaration

allocator

by:

aliased

object_declaration

component_definition

aliased

limited

Replace paragraph 12: [AI95-00230-01; AI95-00231-01; AI95-00254-01]

access_definition

subtype_mark

designated subtype

access_definition

by:

access_definition

subtype_mark

designated subtype

general_access_modifier

constant

parameter_profile

parameter_and_result_profile

designated profile

null_exclusion

access_definition

Replace paragraph 13: [AI95-00230-01; AI95-00231-01]

null

attribute_reference

allocator

by:

attribute_reference

allocator

Replace paragraph 14: [AI95-00231-01]

access_definition

access_to_object_definition

by:

access_definition

access_to_object_definition

access_type_definition

null_exclusion

Legality Rules

null_exclusion

subtype_indication

subtype_mark

Replace paragraph 15: [AI95-00231-01]

composite_constraint

compatible

satisfies

composite_constraint

by:

composite_constraint

compatible

null_exclusion

satisfies

composite_constraint

null_exclusion

Replace paragraph 17: [AI95-00230-01; AI95-00254-01]

access_definition

by:

access_definition

3.10.1 Incomplete Type Declarations

Replace paragraph 2: [AI95-00326-01]

incomplete_type_declaration ::= type defining_identifier [discriminant_part];

by:

incomplete_type_declaration ::= type defining_identifier [discriminant_part] [is tagged];

Static Semantics

incomplete_type_declaration

incomplete view

known_discriminant_part

incomplete_type_declaration

tagged

tagged incomplete view

it occurs in the immediate scope of the completion of T, or

it occurs in the scope of a nonlimited_with_clause that mentions a library package in whose visible part the completion of T is declared.

Replace paragraph 4: [AI95-00326-01]

incomplete_type_declaration

known_discriminant_part

full_type_declaration

known_discriminant_part

incomplete_type_declaration

discriminant_part

unknown_discriminant_part

full_type_declaration

by:

incomplete_type_declaration

tagged

full_type_declaration

incomplete_type_declaration

known_discriminant_part

full_type_declaration

known_discriminant_part

incomplete_type_declaration

discriminant_part

unknown_discriminant_part

full_type_declaration

Replace paragraph 5: [AI95-00326-01]

name

incomplete_type_declaration

by:

name

Delete paragraph 7: [AI95-00326-01]

as the subtype_mark defining the subtype of a parameter or result of an access_to_subprogram_definition;

Replace paragraph 8: [AI95-00326-01]

as the subtype_mark in an access_definition;

by:

as the subtype_mark in an access_definition.

name

as the subtype_mark defining the subtype of a parameter in a formal_part;

Replace paragraph 9: [AI95-00326-01]

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.

by:

as the prefix of an attribute_reference whose attribute_designator is Class; such an attribute_reference is restricted to the uses allowed here; it denotes a tagged incomplete view.

name

as the subtype_mark defining the subtype of a parameter or result of an access_to_subprogram_definition.

If any of the above uses occurs as part of the declaration of a primitive subprogram of the incomplete view, and the declaration occurs immediately within the private part of a package, then the completion of the incomplete view shall also occur immediately within the private part; it may not be deferred to the package body.

Replace paragraph 10: [AI95-00217-06; AI95-00326-01]

A dereference (whether implicit or explicit -- see 4.1) shall not be of an incomplete type.

by:

prefix

Delete paragraph 11: [AI95-00326-01]

incomplete_type_declaration

known_discriminant_part

3.10.2 Operations of Access Types

Replace paragraph 2: [AI95-00235-01]

attribute_reference

attribute_designator

prefix

attribute_reference

implicit_dereference

prefix

by:

attribute_reference

attribute_designator

A is an access-to-object type with designated type D and the type of the prefix is D'Class or is covered by D, or

A is an access-to-subprogram type whose designated profile is type conformant with that of the prefix.

prefix

attribute_reference

implicit_dereference

function_call

attribute_reference

prefix

Replace paragraph 3: [AI95-00162-01]

accessibility levels

task_body

block_statement

subprogram_body

entry_body

accept_statement

deeper than

by:

accessibility levels

deeper than

Replace paragraph 7: [AI95-00162-01]

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.

by:

An entity or view created by a declaration has the same accessibility level as the innermost enclosing master other than the declaration itself, 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.

Replace paragraph 10: [AI95-00318-02]

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.

by:

For any function, the accessibility level of the result object is that of the execution of the called function.

Insert after paragraph 11: [AI95-00385-01]

The accessibility level of a derived access type is that of its ultimate ancestor.

the new paragraphs:

The accessibility level of the anonymous access type defined by an access_definition of an object_declaration is the same as that of the declared object.

Replace paragraph 12: [AI95-00230-01]

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.

by:

The accessibility level of the anonymous access type defined by an access_definition of an object_renaming_declaration is the same as that of the renamed view.

The accessibility level of the anonymous access type of a component is that of the master that elaborated its access_definition. This is the same as the level of the type whose definition encloses the access_definition except in the case of an access discriminant specified for a limited type, in which case it is the same as that of the containing object or associated constrained subtype.

Replace paragraph 13: [AI95-00162-01; AI95-00254-01; AI95-00318-02]

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.

by:

The accessibility level of the anonymous access type of an access parameter specifying an access-to-object type is the same as that of the view designated by the actual.

The accessibility level of the anonymous access type of an access parameter specifying an access-to-subprogram type is infinite.

The accessibility level of the anonymous access type of an access result type (see 6.5) is the same as that of the associated function or access-to-subprogram type.

Replace paragraph 19: [AI95-00254-01]

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.

by:

The statically deeper relationship does not apply to the accessibility level of the anonymous type of an access parameter specifying an access-to-object type; that is, such an accessibility level is not considered to be statically deeper, nor statically shallower, than any other.

Replace paragraph 26: [AI95-00363-01]

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.

by:

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 constrained by its initial value.

Replace paragraph 27: [AI95-00363-01]

If A is a named access type and D is a tagged type, then the type of the view shall be covered by D; if A is anonymous and D is tagged, then the type of the view shall be either D'Class or a type covered by D; if D is untagged, then the type of the view shall be D, and A's designated subtype shall either statically match the nominal subtype of the view or be discriminated and unconstrained;

by:

If A is a named access type and D is a tagged type, then the type of the view shall be covered by D; if A is anonymous and D is tagged, then the type of the view shall be either D'Class or a type covered by D; if D is untagged, then the type of the view shall be D, and either:

the designated subtype of A shall statically match the nominal subtype of the view; or

D shall be discriminated in its full view and unconstrained in any partial view, and the designated subtype of A shall be unconstrained.

Replace paragraph 32: [AI95-00229-01; AI95-00254-01]

by:

Replace paragraph 34: [AI95-00230-01]

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 4.6). Named access types have predefined equality operators; anonymous access types do not (see 4.5.2).

by:

Replace paragraph 37: [AI95-00254-01]

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 12.6). Note that Unchecked_Access is not allowed for subprograms.

by:

The accessibility rules imply that it is 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 -- only for anonymous access-to-subprogram parameters. Downward closures also can be implemented using generic formal subprograms (see 12.6). Note that Unchecked_Access is not allowed for subprograms.

Section 4: Names and Expressions

4.1.3 Selected Components

Insert after paragraph 9: [AI95-00252-01]

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.

the new paragraph:

A view of a subprogram whose first formal parameter is of a tagged or is an access parameter whose designated type is tagged: The prefix (after any implicit dereference) shall resolve to denote an object or value of a specific tagged type T or class-wide type T'Class. The selector_name shall resolve to denote a view of a subprogram declared immediately within the region in which an ancestor of the type T is declared. The first formal parameter of the subprogram shall be of type T, or a class-wide type that covers T, or an access parameter designating one of these types. The designator of the subprogram shall not be the same as that of a component of the tagged type visible at the point of the selected_component. The selected_component denotes a view of this subprogram that omits the first formal parameter.

Insert after paragraph 13: [AI95-00252-01]

prefix

direct_name

block_statement

loop_statement

accept_statement

entry_body

prefix

selector_name

the new paragraph:

Legality Rules

selected_component

prefix

Insert after paragraph 15: [AI95-00252-01]

selected_component

variant

prefix

the new paragraph:

selected_component

prefix

selector_name

selected_component

prefix

actual_parameter_part

In paragraph 17 replace: [AI95-00252-01]

Control.Seize     -- an entry of a protected object    (see 9.4)

by:

X.Activate        -- a procedure call assuming X has   (see 6.4)
                  -- a tagged type
Control.Seize     -- an entry of a protected object    (see 9.4)

4.1.4 Attributes

Replace paragraph 14: [AI95-00235-01]

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 3.10.2) 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.

by:

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 attribute_reference has to be a single access type, and the resolution of the name can use the fact that the type of the object or profile of the callable entity denoted by the prefix has to be match the designated type or be type conformant with the designated profile of the access type.

4.2 Literals

Delete paragraph 2: [AI95-00230-01]

null

Delete paragraph 7: [AI95-00230-01; AI95-00231-01]

null

Replace paragraph 8: [AI95-00230-01]

universal_integer

universal_real

by:

universal_integer

universal_real

null

universal_access

4.3 Aggregates

Replace paragraph 3: [AI95-00287-01; AI95-00389-01]

aggregate

by:

aggregate

4.3.1 Record Aggregates

Replace paragraph 4: [AI95-00287-01]

record_component_association ::=
   [ component_choice_list => ] expression

by:

record_component_association ::=
     [ component_choice_list => ] expression
   |   component_choice_list => <>

Replace paragraph 8: [AI95-00287-01; AI95-00389-01]

record_aggregate

by:

record_aggregate

Replace paragraph 16: [AI95-00287-01; AI95-00389-01]

record_component_association

by:

record_component_association

others

record_component_association

Insert after paragraph 17: [AI95-00287-01; AI95-00389-01]

variant_part

the new paragraphs:

record_component_association

default_expression

expression

record_aggregate

The record_component_association_list shall include others => <>; and

The type of the record_aggregate shall have known discriminants or be a tagged, task, or protected, definite type; and

The record_component_association_list shall not include a positional component association.

Insert before paragraph 20: [AI95-00287-01]

record_component_association

the new paragraph:

record_component_association

expression

record_component_association

component_declaration

default_expression

Insert after paragraph 29: [AI95-00287-01]

 --  The allocator is evaluated twice: Succ and Pred designate different cells

the new paragraphs:

(Value => 0, Succ|Pred => <>)   --  see 3.10.1

 --  Succ and Pred will be set to null

4.3.2 Extension Aggregates

Replace paragraph 4: [AI95-00287-01; AI95-00389-01]

extension_aggregate

ancestor_part

expression

by:

extension_aggregate

ancestor_part

expression

Replace paragraph 5: [AI95-00306-01; AI95-00389-01]

ancestor_part

subtype_mark

extension_aggregate

ancestor_part

by:

ancestor_part

subtype_mark

ancestor_part

expression

extension_aggregate

ancestor_part

extension_aggregate

ancestor_part

record_component_association_list

others

4.3.3 Array Aggregates

Replace paragraph 3: [AI95-00287-01]

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

by:

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

Replace paragraph 5: [AI95-00287-01]

array_component_association ::=
    discrete_choice_list => expression

by:

array_component_association ::=
    discrete_choice_list => expression
  | discrete_choice_list => <>

Replace paragraph 7: [AI95-00287-01]

array_aggregate

by:

array_aggregate

Insert before paragraph 24: [AI95-00287-01]

array_aggregate

the new paragraph:

Each array component expression defines the value for the associated component(s). For a component given by <>, the associated component(s) are initialized by default (see 3.3.1).

4.5.2 Relational Operators and Membership Tests

Replace paragraph 3: [AI95-00251-01]

tested type

range

subtype_mark

simple_expression

by:

tested type

range

subtype_mark

simple_expression

Insert after paragraph 7: [AI95-00230-01]

function "=" (Left, Right : T) return Boolean
function "/="(Left, Right : T) return Boolean

the new paragraphs:

universal_access

function "=" (Left, Right : universal_access) return Boolean
function "/="(Left, Right : universal_access) return Boolean

Insert after paragraph 9: [AI95-00230-01]

function "<" (Left, Right : T) return Boolean
function "<="(Left, Right : T) return Boolean
function ">" (Left, Right : T) return Boolean
function ">="(Left, Right : T) return Boolean

the new paragraphs:

Name Resolution Rules

universal_access

Legality Rules

universal_access

4.5.5 Multiplying Operators

Replace paragraph 20: [AI95-00364-01]

Legality Rules

universal_fixed

by:

Name Resolution Rules

universal_fixed

4.6 Type Conversions

Replace paragraph 5: [AI95-00330-01]

type_conversion

name

view conversion

out

in out

type_conversion

value conversions

by:

type_conversion

name

view conversion

out

in out

type_conversion

value conversions

Replace paragraph 8: [AI95-00251-01]

If the target type is a numeric type, then the operand type shall be a numeric type.

by:

In a view conversion for an untagged type, the target type shall be convertible (back) to the operand type.

Delete paragraph 9: [AI95-00246-01; AI95-00251-01]

If the target type is an array type, then the operand type shall be an array type. Further:

Delete paragraph 10: [AI95-00251-01]

The types shall have the same dimensionality;

Delete paragraph 11: [AI95-00251-01]

Corresponding index types shall be convertible;

Delete paragraph 12: [AI95-00246-01; AI95-00251-01; AI95-00392-01]

The component subtypes shall statically match; and

Delete paragraph 12.1: [AI95-00246-01; AI95-00251-01; AI95-00363-01]

In a view conversion, the target type and the operand type shall both or neither have aliased components.

Delete paragraph 13: [AI95-00230-01; AI95-00251-01]

If the target type is a general access type, then the operand type shall be an access-to-object type. Further:

Delete paragraph 14: [AI95-00251-01]

If the target type is an access-to-variable type, then the operand type shall be an access-to-variable type;

Delete paragraph 15: [AI95-00251-01]

If the target designated type is tagged, then the operand designated type shall be convertible to the target designated type;

Delete paragraph 16: [AI95-00251-01; AI95-00363-01; AI95-00384-01]

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

Delete paragraph 17: [AI95-00251-01]

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 12.3), this rule applies also in the private part of an instance of a generic unit.

Delete paragraph 18: [AI95-00230-01; AI95-00251-01]

If the target type is an access-to-subprogram type, then the operand type shall be an access-to-subprogram type. Further:

Delete paragraph 19: [AI95-00251-01]

The designated profiles shall be subtype-conformant.

Delete paragraph 20: [AI95-00251-01]

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 12.3), 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.

Replace paragraph 21: [AI95-00251-01]

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:

by:

If there is a type that is an ancestor of both the target type and the operand type, then:

The target type shall be untagged; or

Replace paragraph 23: [AI95-00251-01]

The operand type shall be a class-wide type that covers the target type.

by:

The operand type shall be a class-wide type that covers the target type; or

The operand and target types shall both be class-wide types and the specific type associated with at least one of them shall be an interface type.

Replace paragraph 24: [AI95-00246-01; AI95-00251-01; AI95-00392-01]

In a view conversion for an untagged type, the target type shall be convertible (back) to the operand type.

by:

If there is no type that is an ancestor of both the target type and the operand type, then:

If the target type is a numeric type, then the operand type shall be a numeric type.

If the target type is an array type, then the operand type shall be an array type. Further:

The types shall have the same dimensionality;

Corresponding index types shall be convertible;

The component subtypes shall statically match;

If the component types are anonymous access types, then the accessibility level of the operand type shall not be statically deeper than that of the target type;

Neither the target type nor the operand type shall be limited; and

In a view conversion: if the target type has aliased components, then so shall the operand type; and the operand type shall not have a tagged, private, or volatile subcomponent.

If the target type is universal_access, then the operand type shall be an access type.

If the target type is a general access-to-object type, then the operand type shall be universal_access or an access-to-object type. Further, if not universal_access:

If the target type is an access-to-variable type, then the operand type shall be an access-to-variable type;

If the target designated type is tagged, then the operand designated type shall be convertible to the target designated type;

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 designated type shall be discriminated in its full view and unconstrained in any partial view, and one of the designated subtypes shall be unconstrained;

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 12.3), this rule applies also in the private part of an instance of a generic unit.

If the target type is an access-to-subprogram type, then the operand type shall be universal_access or an access-to-subprogram type. Further, if not universal_access:

The designated profiles shall be subtype-conformant.

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 12.3), 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.

Insert after paragraph 39: [AI95-00392-01]

In either array case, the value of each component of the result is that of the matching component of the operand value (see 4.5.2).

the new paragraph:

If the component types of the array types are anonymous access types, then a check is made that the accessibility level of the operand type is not deeper than that of the target type.

Replace paragraph 49: [AI95-00230-01; AI95-00231-01]

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.

by:

If the operand value is null, the result of the conversion is the null value of the target type.

Replace paragraph 51: [AI95-00231-01]

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.

by:

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. If the target subtype excludes the null value, then a check is made that the value is not null.

Replace paragraph 61: [AI95-00230-01]

22 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 4.7) can be used instead of such a type_conversion.

by:

22 A ramification of the overload resolution rules is that the operand of an (explicit) type_conversion cannot be 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 4.7) can be used instead of such a type_conversion.

4.8 Allocators

Replace paragraph 5: [AI95-00287-01; AI95-00344-01]

allocator

by:

allocator

subtype_indication

qualified_expression

allocator

Replace paragraph 6: [AI95-00363-01]

allocator

by:

allocator

Replace paragraph 7: [AI95-00344-01]

allocator

subtype_indication

qualified_expression

by:

allocator

subtype_indication

qualified_expression

allocator

qualified_expression

Replace paragraph 11: [AI95-00280-01]

If the created object contains any tasks, they are activated (see 9.2). Finally, an access value that designates the created object is returned.

by:

allocator

If the created object contains any tasks, they are activated (see 9.2). Finally, an access value that designates the created object is returned.

Bounded (Run-Time) Errors

allocator

4.9 Static Expressions and Static Subtypes

Replace paragraph 26: [AI95-00263-01]

static subtype

static scalar subtype

static string subtype

in out

by:

static subtype

static scalar subtype

static string subtype

in out

Insert after paragraph 31: [AI95-00311-01]

A discriminant constraint is static if each expression of the constraint is static, and the subtype of each discriminant is static.

the new paragraph:

In any case, the constraint of the first subtype of a scalar formal type is neither static nor null.

Replace paragraph 35: [AI95-00269-01]

If the expression is not part of a larger static expression, then its value shall be in the base range of its expected type. Otherwise, the value may be arbitrarily large or small.

by:

If the expression is not part of a larger static expression and the expression is expected to be of a single specific type, then its value shall be in the base range of its expected type. Otherwise, the value may be arbitrarily large or small.

Replace paragraph 37: [AI95-00269-01]

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).

by:

The last restriction above does not apply if the expected type is a descendant of a formal scalar type (or a corresponding actual type in an instance).

In addition to the places where Legality Rules normally apply (see 12.3), the above restrictions also apply in the private part of an instance of a generic unit.

Replace paragraph 38: [AI95-00268-01; AI95-00269-01]

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 Annex G).

by:

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, the rounding performed is implementation-defined. If the expected type is a descendant of a formal scalar type, or if the static expression appears in the body of an instance of a generic unit and the corresponding expression is nonstatic in the corresponding generic body, then no special rounding or truncating is required -- normal accuracy rules apply (see Annex G).

Implementation Advice

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 rounding should be the same as the default rounding for the target system.

4.9.1 Statically Matching Constraints and Subtypes

Replace paragraph 1: [AI95-00311-01]

statically matches

constraint

subtype_indication

range

discrete_subtype_definition

by:

statically matches

both are null constraints;

both are static and have equal corresponding bounds or discriminant values;

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; or

both are nonstatic and both come from the same formal_type_declaration.

Replace paragraph 2: [AI95-00231-01; AI95-00254-01]

statically matches

by:

statically matches

Section 5: Statements

5.2 Assignment Statements

Replace paragraph 4: [AI95-00287-01]

variable

_name

assignment_statement

expression

by:

variable

_name

assignment_statement

expression

Replace paragraph 5: [AI95-00287-01]

variable

_name

by:

variable

_name

Section 6: Subprograms

6.1 Subprogram Declarations

Replace paragraph 2: [AI95-00218-03]

subprogram_declaration ::= subprogram_specification ;

by:

overriding_indicator ::= [not] overriding
subprogram_declaration ::=
    [overriding_indicator]
    subprogram_specification ;

Replace paragraph 3: [AI95-00218-03]

abstract_subprogram_declaration ::= subprogram_specification is abstract;

by:

abstract_subprogram_declaration ::=
    [overriding_indicator]
    subprogram_specification is abstract;

Replace paragraph 4: [AI95-00348-01]

subprogram_specification ::=
     procedure defining_program_unit_name parameter_profile
   | function defining_designator parameter_and_result_profile

by:

procedure_specification ::= procedure defining_program_unit_name parameter_profile

function_specification ::= function defining_designator parameter_and_result_profile

subprogram_specification ::=
     procedure_specification
   | function_specification

Replace paragraph 13: [AI95-00231-01; AI95-00318-02]

parameter_and_result_profile ::= [formal_part] return subtype_mark

by:

parameter_and_result_profile ::=
    [formal_part] return [null_exclusion] subtype_mark
  | [formal_part] return access_definition

Replace paragraph 15: [AI95-00231-01]

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

by:

parameter_specification ::=
    defining_identifier_list : mode [null_exclusion] subtype_mark [:= default_expression]
  | defining_identifier_list : access_definition [:= default_expression]

Replace paragraph 23: [AI95-00231-01; AI95-00318-02]

subtype_mark

access_definition

parameter_specification

by:

null_exclusion

subtype_mark

access_definition

parameter_specification

null_exclusion

subtype_mark

access_definition

parameter_and_result_profile

Replace paragraph 24: [AI95-00231-01; AI95-00254-01; AI95-00318-02]

access parameter

access_definition

by:

access parameter

access_definition

access result type

access_definition

Replace paragraph 27: [AI95-00254-01]

For any access parameters, the designated subtype of the parameter type.

by:

For any access parameters of an access-to-object type, the designated subtype of the parameter type.

For any access parameters of an access-to-subprogram type, the subtypes of the profile of the parameter type.

Replace paragraph 28: [AI95-00231-01; AI95-00254-01; AI95-00318-02]

For any result, the result subtype.

by:

For any non-access result, the nominal subtype of the function result.

For any access result type of an access-to-object type, the designated subtype of the result type.

For any access result type of an access-to-subprogram type, the subtypes of the profile of the result type.

Insert after paragraph 30: [AI95-00218-03]

abstract_subprogram_declaration

subprogram_declaration

the new paragraph:

overriding_indicator

6.3 Subprogram Bodies

Replace paragraph 2: [AI95-00218-03]

subprogram_body ::=
   subprogram_specification is
     declarative_part
   begin
      handled_sequence_of_statements
   end [designator];

by:

subprogram_body ::=
   [overriding_indicator]
   subprogram_specification is
     declarative_part
   begin
      handled_sequence_of_statements
   end [designator];

6.3.1 Conformance Rules

Replace paragraph 10: [AI95-00252-01]

a subprogram declared immediately within a protected_body.

by:

a subprogram declared immediately within a protected_body;

the view of a subprogram denoted by a selected_component whose prefix denotes an object or value of a tagged type, and whose selector_name denotes a subprogram operating on the type (see 4.1.3).

Insert after paragraph 13: [AI95-00254-01]

The default calling convention is entry for an entry.

the new paragraph:

The calling convention for an access parameter of an access-to-subprogram type is protected if the reserved word protected appears in its definition and otherwise is the convention of the subprogram that contains the parameter.

Replace paragraph 16: [AI95-00318-02]

mode conformant

by:

mode conformant

Insert after paragraph 24: [AI95-00345-01]

discrete_subtype_definition

fully conformant

subtype_indication

range

subtype_mark

simple_expression

range

the new paragraph:

type conformant

mode conformant

subtype conformant

fully conformant

6.3.2 Inline Expansion of Subprograms

Insert after paragraph 6: [AI95-00309-01]

pragma

the new paragraph:

pragma

direct_name

subprogram_body

declarative_part

6.4 Subprogram Calls

Replace paragraph 8: [AI95-00310-01]

name

prefix

procedure_call_statement

name

prefix

function_call

actual_parameter_part

implicit_dereference

by:

name

prefix

procedure_call_statement

name

prefix

function_call

name

prefix

actual_parameter_part

implicit_dereference

Replace paragraph 12: [AI95-00231-01]

function_call

by:

function_call

6.5 Return Statements

Replace paragraph 2: [AI95-00318-02]

return_statement ::= return [expression];

by:

return_statement ::= simple_return_statement | extended_return_statement

simple_return_statement ::= return [expression];

extended_return_statement ::=
    return identifier : [aliased] return_subtype_indication [:= expression] [do
        handled_sequence_of_statements
    end return];

return_subtype_indication ::= subtype_indication | access_definition

Replace paragraph 3: [AI95-00318-02]

expression

return_statement

return expression

result subtype

subtype_mark

return

by:

result subtype

subtype_mark

access_definition

return

expression

simple_return_statement

extended_return_statement

return expression

Replace paragraph 4: [AI95-00318-02]

return_statement

applies to

return_statement

by:

return_statement

applies to

extended_return_statement

return_statement

Replace paragraph 5: [AI95-00318-02]

return_statement

code_statement

return_statement

by:

return_statement

code_statement

simple_return_statement

extended_return_statement

subtype_mark

return_subtype_indication

extended_return_statement

subtype_indication

access_definition

return_subtype_indication

access_definition

qualified_expression

Static Semantics

extended_return_statement

return object

return_subtype_indication

Replace paragraph 6: [AI95-00318-02]

return_statement

expression

by:

extended_return_statement

subtype_indication

access_definition

handled_sequence_of_statements

simple_return_statement

expression

return object

Delete paragraph 7: [AI95-00318-02]

expression

Replace paragraph 8: [AI95-00318-02]

If the result type is a specific tagged type:

by:

If the result type of a function is a specific tagged type, the tag of the return object is that of the result type.

Delete paragraph 9: [AI95-00318-02]

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.

Delete paragraph 10: [AI95-00318-02]

If it is nonlimited, then the tag of the result is that of the result type.

Delete paragraph 11: [AI95-00318-02]

return-by-reference

Delete paragraph 12: [AI95-00318-02]

a tagged limited type;

Delete paragraph 13: [AI95-00318-02]

a task or protected type;

Delete paragraph 14: [AI95-00318-02]

a nonprivate type with the reserved word limited in its declaration;

Delete paragraph 15: [AI95-00318-02]

a composite type with a subcomponent of a return-by-reference type;

Delete paragraph 16: [AI95-00318-02]

a private type whose full type is a return-by-reference type.

Delete paragraph 17: [AI95-00318-02]

If the result type is a return-by-reference type, then a check is made that the return expression is one of the following:

Delete paragraph 18: [AI95-00162-01; AI95-00316-01; AI95-00318-02]

a name that denotes an object view whose accessibility level is not deeper than that of the master that elaborated the function body; or

Delete paragraph 19: [AI95-00318-02]

a parenthesized expression or qualified_expression whose operand is one of these kinds of expressions.

Replace paragraph 20: [AI95-00318-02; AI95-00344-01]

The exception Program_Error is raised if this check fails.

by:

If the result type is class-wide, a check is made that the accessibility level of the type identified by the tag of the result is not deeper than that of the master that elaborated the function body. If this check fails, Program_Error is raised.

Delete paragraph 21: [AI95-00318-02]

return_statement

Replace paragraph 22: [AI95-00318-02]

return_statement

by:

return_statement

function_call

Replace paragraph 24: [AI95-00318-02]

return;                         -- in a procedure body, entry_body, or accept_statement
return Key_Value(Last_Index);   -- in a function body

by:

return;                         -- in a procedure body, entry_body,
                                -- accept_statement, or extended_return_statement

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

return Node : Cell do           -- in a function body, see 3.10.1 for Cell
   Node.Value := Result;
   Node.Succ := Next_Node;
end return;

6.5.1 Pragma No_Return

Insert new clause: [AI95-00329-01]

pragma

Syntax

pragma

pragma

local_

name

local_

name

Legality Rules

pragma

return_statement

Static Semantics

pragma

Dynamic Semantics

pragma

6.7 Null Procedures

Insert new clause: [AI95-00348-01]

null_procedure_declaration

Syntax

null_procedure_declaration ::= procedure_specification is null;

Static Semantics

null_procedure_declaration

null procedure

null_procedure_declaration

Dynamic Semantics

subprogram_body

Section 7: Packages

7.3 Private Types and Private Extensions

Replace paragraph 2: [AI95-00251-01]

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

by:

private_extension_declaration ::=
   type defining_identifier [discriminant_part] is
     [abstract] new ancestor_subtype_indication [and interface_list] with private;

7.3.1 Private Operations

Replace paragraph 12: [AI95-00287-01]

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.

9 Partial views provide initialization, membership tests, selected components for the selection of discriminants and inherited components, qualification, and explicit conversion. Nonlimited partial views also provide assignment_statements.

7.4 Deferred Constants

Replace paragraph 9: [AI95-00256-01]

The completion of a deferred constant declaration shall occur before the constant is frozen (see 7.4).

by:

The completion of a deferred constant declaration shall occur before the constant is frozen (see 13.14).

7.5 Limited Types

Replace paragraph 1: [AI95-00287-01]

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.

by:

A limited type is (a view of) a type for which copying (such as for an assignment_statement) is not allowed. A nonlimited type is a (view of a) type for which copying is allowed.

Insert before paragraph 2: [AI95-00287-01; AI95-00318-02]

limited

record_type_definition

the new paragraph:

expression

aggregate

function_call

expression

qualified_expression

the initialization expression of an object_declaration (see 3.3.1)

the default_expression of a component_declaration (see 3.8)

the expression of a record_component_association (see 4.3.1)

the expression for an ancestor_part of an extension_aggregate (see 4.3.2)

an expression of a positional_array_aggregate or the expression of an array_component_association (see 4.3.3)

the qualified_expression of an initialized allocator (see 4.8)

the expression of a return_statement (see 6.5)

the default_expression or actual parameter for a formal object of mode in (see 12.4)

Insert after paragraph 8: [AI95-00287-01; AI95-00318-02]

There are no predefined equality operators for a limited type.

the new paragraph:

Implementation Requirements

aggregate

function_call

aggregate

function_call

Replace paragraph 9: [AI95-00287-01; AI95-00318-02]

13 The following are consequences of the rules for limited types:

by:

13 While it is allowed to write initializations of limited objects, such initializations never copy a limited object. The source of such an assignment operation must be an aggregate or function_call, and such aggregates and function_calls must be built directly in the target object.

Delete paragraph 10: [AI95-00287-01]

An initialization expression is not allowed in an object_declaration if the type of the object is limited.

Delete paragraph 11: [AI95-00287-01]

A default expression is not allowed in a component_declaration if the type of the record component is limited.

Delete paragraph 12: [AI95-00287-01]

An initialized allocator is not allowed if the designated type is limited.

Delete paragraph 13: [AI95-00287-01]

A generic formal parameter of mode in must not be of a limited type.

Delete paragraph 14: [AI95-00287-01]

14 Aggregates are not available for a limited composite type. Concatenation is not available for a limited array type.

Delete paragraph 15: [AI95-00287-01]

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.

7.6 User-Defined Assignment and Finalization

Replace paragraph 5: [AI95-00161-01]

    type Controlled is abstract tagged private;

by:

    type Controlled is abstract tagged private;
    pragma Preelaborable_Initialization(Controlled);

Replace paragraph 6: [AI95-00348-01]

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

by:

    procedure Initialize (Object : in out Controlled) is null;
    procedure Adjust     (Object : in out Controlled) is null;
    procedure Finalize   (Object : in out Controlled) is null;

Replace paragraph 7: [AI95-00161-01]

    type Limited_Controlled is abstract tagged limited private;

by:

    type Limited_Controlled is abstract tagged limited private;
    pragma Preelaborable_Initialization(Limited_Controlled);

Replace paragraph 8: [AI95-00348-01]

    procedure Initialize (Object : in out Limited_Controlled);
    procedure Finalize (Object : in out Limited_Controlled);
private
    ... -- not specified by the language
end Ada.Finalization;

by:

    procedure Initialize (Object : in out Limited_Controlled) is null;
    procedure Finalize   (Object : in out Limited_Controlled) is null;
private
    ... -- not specified by the language
end Ada.Finalization;

Replace paragraph 9: [AI95-00348-01; AI95-00360-01]

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 4.5.2. The type Limited_Controlled is like Controlled, except that it is limited and it lacks the primitive subprogram Adjust.

by:

A controlled type is a descendant of Controlled or Limited_Controlled. 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 4.5.2. The type Limited_Controlled is like Controlled, except that it is limited and it lacks the primitive subprogram Adjust.

need finalization

it is a controlled type, a task type or a protected type; or

it has a component that needs finalization; or

it is a limited type that has an access discriminant whose designated type needs finalization; or

it is one of a number of language-defined types that are explicitly defined to need finalization.

Replace paragraph 21: [AI95-00147-01]

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.

by:

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).

Furthermore, an implementation is permitted to omit implicit Initialize, Adjust, and Finalize calls and associated assignment operations on an object of nonlimited controlled type provided that:

any omitted Initialize call is not a call on a user-defined Initialize procedure, and

any usage of the value of the object after the implicit Initialize or Adjust call and before any subsequent Finalize call on the object does not change the external effect of the program, and

after the omission of such calls and operations, any execution of the program that executes an Initialize or Adjust call on an object or initializes an object by an aggregate will also later execute a Finalize call on the object and will always do so prior to assigning a new value to the object, and

the assignment operations associated with omitted Adjust calls are also omitted.

This permission applies to Adjust and Finalize calls even if the implicit calls have additional external effects.

7.6.1 Completion and Finalization

Replace paragraph 3: [AI95-00162-01]

left

task_body

block_statement

subprogram_body

entry_body

accept_statement

by:

left

package_body

accept_statement

block_statement

simple_statement

expression

range

expression

range

simple_statement

Replace paragraph 11: [AI95-00280-01]

allocator

by:

allocator

finalization of the collection

Replace paragraph 12: [AI95-00256-01]

The target of an assignment statement is finalized before copying in the new value, as explained in 7.6.

by:

assignment_statement

Replace paragraph 13: [AI95-00162-01]

object_name

object_renaming_declaration

in out

generic_instantiation

aggregate

declarative_item

statement

compound_statement

statement

compound_statement

by:

The master of an object is the master enclosing its creation whose accessibility level (see 3.10.2) is equal to that of the object.

Replace paragraph 13.1: [AI95-00162-01]

If a transfer of control or raising of an exception occurs prior to performing a finalization of an anonymous object, the anonymous object is finalized as part of the finalizations due to be performed for the object's innermost enclosing master.

by:

delay_statement

expression

Replace paragraph 16: [AI95-00256-01]

For an Adjust invoked as part of the initialization of a controlled object, other adjustments due to be performed might or might not be performed, and then Program_Error is raised. During its propagation, finalization might or might not be applied to objects whose Adjust failed. For an Adjust invoked as part of an assignment statement, any other adjustments due to be performed are performed, and then Program_Error is raised.

by:

For an Adjust invoked as part of assignment operations other than those invoked as part of an assignment_statement, other adjustments due to be performed might or might not be performed, and then Program_Error is raised. During its propagation, finalization might or might not be applied to objects whose Adjust failed. For an Adjust invoked as part of an assignment_statement, any other adjustments due to be performed are performed, and then Program_Error is raised.

Section 8: Visibility Rules

8.1 Declarative Region

Insert after paragraph 4: [AI95-00318-02]

a loop_statement;

the new paragraph:

an extended_return_statement;

8.3 Visibility

Insert after paragraph 12: [AI95-00251-01]

An implicit declaration of an inherited subprogram overrides a previous implicit declaration of an inherited subprogram.

the new paragraphs:

If two or more homographs are implicitly declared at the same place:

If one is a non-null non-abstract subprogram, then it overrides all which are null or abstract subprograms.

If all are null procedures or abstract subprograms, then any null procedure overrides all abstract subprograms; if more than one homograph remains that is not thus overridden, then one is chosen arbitrarily to override the others.

Replace paragraph 20: [AI95-00217-06]

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.

by:

The declaration of a library unit (including a library_unit_renaming_declaration) is hidden from all visibility at places outside its declarative region that are not within the scope of a nonlimited_with_clause that mentions it. The limited view of a library package is hidden from all visibility at places that are not within the scope of a limited_with_clause that mentions it; in addition, the limited view is hidden from all visibility within the declarative region of the package, as well as within the scope of any nonlimited_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.

Insert after paragraph 23: [AI95-00195-01]

A declaration is also hidden from direct visibility where hidden from all visibility.

the new paragraph:

attribute_definition_clause

visible

attribute_definition_clause

Replace paragraph 26: [AI95-00218-03; AI95-00251-01; AI95-00377-01]

context_clause

subunit

with_clause

by:

context_clause

with_clause

If two or more homographs are implicitly declared at the same place (and not overridden by a non-overridable declaration) then at most one shall be a non-null non-abstract subprogram. If all are null or abstract, then all of the null subprograms shall be fully conformant with one another. If all are abstract, then all of the subprograms shall be fully conformant with one another.

All of 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.

subprogram_declaration

abstract_subprogram_declaration

subprogram_body

subprogram_body_stub

subprogram_renaming_declaration

generic_instantiation

overriding_indicator

the operation shall be a primitive operation for some type;

if the overriding_indicator is overriding, then the operation shall override a homograph at the point of the declaration or body;

if the overriding_indicator is not overriding, then the operation shall not override any homograph (at any point).

In addition to the places where Legality Rules normally apply, these rules also apply in the private part of an instance of a generic unit.

8.4 Use Clauses

Replace paragraph 5: [AI95-00217-06]

package_

name

use_package_clause

by:

package_

name

use_package_clause

Insert after paragraph 7: [AI95-00217-06]

use_clause

the new paragraph:

named

use_package_clause

package_

name

named

use_type_clause

subtype_mark

Replace paragraph 8: [AI95-00217-06]

package_

name

use_package_clause

potentially use-visible

subtype_mark

use_type_clause

potentially use-visible

by:

use_package_clause

potentially use-visible

use_type_clause

potentially use-visible

8.5.1 Object Renaming Declarations

Replace paragraph 2: [AI95-00230-01]

object_renaming_declaration ::=
    defining_identifier : subtype_mark renames object_name;

by:

object_renaming_declaration ::=
    defining_identifier : subtype_mark renames object_name;
  | defining_identifier : access_definition renames object_name;

Replace paragraph 3: [AI95-00230-01; AI95-00254-01]

object_name

subtype_mark

by:

object_name

subtype_mark

access_definition

Replace paragraph 4: [AI95-00231-01; AI95-00254-01]

The renamed entity shall be an object.

by:

access_definition

Replace paragraph 5: [AI95-00363-01]

slice

by:

slice

Replace paragraph 6: [AI95-00230-01]

object_renaming_declaration

renaming_declaration

subtype_mark

object_renaming_declaration

by:

object_renaming_declaration

renaming_declaration

subtype_mark

access_definition

object_renaming_declaration

8.5.3 Package Renaming Declarations

Replace paragraph 3: [AI95-00217-06]

The renamed entity shall be a package.

by:

The renamed entity shall be a nonlimited view of a package.

8.5.4 Subprogram Renaming Declarations

Replace paragraph 2: [AI95-00218-03]

subprogram_renaming_declaration ::= subprogram_specification renames callable_entity_name;

by:

subprogram_renaming_declaration ::=
    [overriding_indicator]
    subprogram_specification renames callable_entity_name;

Insert after paragraph 5: [AI95-00228-01]

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 profile shall be mode-conformant with that of the renamed callable entity and the subprogram it declares takes its convention from the renamed subprogram; otherwise, the profile shall be subtype-conformant with that of the renamed callable entity and the convention of the renamed subprogram shall not be Intrinsic. A renaming-as-body is illegal if the declaration occurs before the subprogram whose declaration it completes is frozen, and the renaming renames the subprogram itself, through one or more subprogram renaming declarations, none of whose subprograms has been frozen.

the new paragraph:

callable_entity_name

8.6 The Context of Overload Resolution

Replace paragraph 17: [AI95-00382-01]

type_declaration

current instance

by:

type_declaration

current instance

subtype_mark

access_definition

Replace paragraph 25: [AI95-00230-01; AI95-00231-01; AI95-00254-01]

when T is an anonymous access type (see 3.10) with designated type D, to an access-to-variable type whose designated type is D'Class or is covered by D.

by:

when T is a specific anonymous access-to-object type (see 3.10) with designated type D, to an access-to-object type whose designated type is D'Class or is covered by D, and that is access-to-constant only if T is access-to-constant; or

when T is an anonymous access-to-subprogram type (see 3.10), to an access-to-subprogram type whose designated profile is subtype-conformant with that of T.

Replace paragraph 27: [AI95-00332-01]

single

type_conversion

by:

single

type_conversion

Section 9: Tasks and Synchronization

9.1 Task Units and Task Objects

Replace paragraph 2: [AI95-00345-01]

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

by:

task_type_declaration ::=
   task type defining_identifier [known_discriminant_part] [is
      [new interface_list with]
      task_definition];

Delete paragraph 8: [AI95-00345-01]

Legality Rules

task_body

Insert after paragraph 9.1: [AI95-00345-01]

task_definition

task_item

the new paragraphs:

task_type_declaration

interface_list

task_type_declaration

entry_declaration

task_type_declaration

implemented

Legality Rules

task_body

interface_subtype_mark

interface_list

task_type_declaration

the inherited subprogram shall be overridden with a primitive subprogram of the task type, in which case the overriding subprogram shall be subtype conformant with the inherited subprogram and not abstract; or

the inherited subprogram is implemented by a single entry of the task type; in which case its profile after omitting the first parameter shall be subtype conformant with that of the task entry.

If neither applies, the inherited subprogram shall be a null procedure.

Replace paragraph 21: [AI95-00287-01]

4 A task type is a limited type (see 7.5), 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 C.7).

by:

4 A task type is a limited type (see 7.5), and hence has neither assignment_statements 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 C.7).

9.3 Task Dependence - Termination of Tasks

Replace paragraph 2: [AI95-00162-01]

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.

by:

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 other than the declaration itself.

Replace paragraph 3: [AI95-00162-01]

If the task is created by the elaboration of an object_declaration, it depends on each master that includes this elaboration.

by:

If the task is created by the elaboration of an object_declaration, it depends on each master that includes this elaboration other than the declaration itself.

9.4 Protected Units and Protected Objects

Replace paragraph 2: [AI95-00345-01]

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

by:

protected_type_declaration ::=
   protected type defining_identifier [known_discriminant_part] [is
      [new interface_list with]
      protected_definition];

Delete paragraph 10: [AI95-00345-01]

Legality Rules

protected_body

Replace paragraph 11: [AI95-00345-01]

protected_definition

protected_operation_declaration

protected_definition

known_discriminant_part

protected_element_declaration

private

by:

protected_definition

protected_operation_declaration

protected_definition

known_discriminant_part

protected_element_declaration

private

protected_type_declaration

interface_list

protected_type_declaration

protected_operation_declaration

protected_type_declaration

implemented

Legality Rules

protected_body

interface_subtype_mark

interface_list

protected_type_declaration

the inherited subprogram is overridden with a primitive subprogram of the protected type, in which case the overriding subprogram shall be subtype conformant with the inherited subprogram and not abstract; or

the inherited subprogram is implemented by a protected subprogram or single entry of the protected type, in which case its profile after omitting the first parameter shall be subtype conformant with that of the protected subprogram or entry.

If neither applies, the inherited subprogram is a null procedure.

out

in out

Insert after paragraph 20: [AI95-00280-01]

finalization

entry_call_statement

the new paragraph:

Bounded (Run-Time) Errors

Replace paragraph 23: [AI95-00287-01]

15 A protected type is a limited type (see 7.5), and hence has neither an assignment operation nor predefined equality operators.

by:

15 A protected type is a limited type (see 7.5), and hence has neither assignment_statements nor predefined equality operators.

9.6 Delay Statements, Duration, and Time

Replace paragraph 11: [AI95-00351-01]

  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;

by:

  subtype Year_Number  is Integer range 1901 .. 2399;
  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;

Replace paragraph 24: [AI95-00351-01]

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.

by:

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 time zone; 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.

9.6.1 Formatting, Time Zones, and other operations for Time

Insert new clause: [AI95-00351-01]

Static Semantics

The following language-defined library packages exist:

package Ada.Calendar.Time_Zones is

    -- Time zone manipulation:

    type Time_Offset is range -1440 .. 1440;

    Unknown_Zone_Error : exception;

    function UTC_Time_Offset (Date : Time := Clock) return Time_Offset;

end Ada.Calendar.Time_Zones;


package Ada.Calendar.Arithmetic is

    -- Arithmetic on days:

    type Day_Count is range
      -366*(1+Year_Number'Last - Year_Number'First)
      ..
      366*(1+Year_Number'Last - Year_Number'First);

    subtype Leap_Seconds_Count is Integer range -999 .. 999;

    procedure Difference (Left, Right : in Time;
                          Days : out Day_Count;
                          Seconds : out Duration;
                          Leap_Seconds : out Leap_Seconds_Count);

    function "+" (Left : Time; Right : Day_Count) return Time;

    function "+" (Left : Day_Count; Right : Time) return Time;

    function "-" (Left : Time; Right : Day_Count) return Time;

    function "-" (Left, Right : Time) return Day_Count;

end Ada.Calendar.Arithmetic;

with Ada.Calendar.Time_Zones;
package Ada.Calendar.Formatting is

    -- Day of the week:

    type Day_Name is (Monday, Tuesday, Wednesday, Thursday,
        Friday, Saturday, Sunday);

    function Day_of_Week (Date : Time) return Day_Name;

    -- Hours:Minutes:Seconds access:

    subtype Hour_Number         is Natural range 0 .. 23;
    subtype Minute_Number       is Natural range 0 .. 59;
    subtype Second_Number       is Natural range 0 .. 59;
    subtype Second_Duration     is Day_Duration range 0.0 .. 1.0;

    function Hour       (Date : Time;
                         Time_Zone  : Time_Zones.Time_Offset := 0)
                            return Hour_Number;

    function Minute     (Date : Time;
                         Time_Zone  : Time_Zones.Time_Offset := 0)
                            return Minute_Number;

    function Second     (Date : Time;
                         Time_Zone  : Time_Zones.Time_Offset := 0)
                            return Second_Number;

    function Sub_Second (Date : Time;
                         Time_Zone  : Time_Zones.Time_Offset := 0)
                            return Second_Duration;

    function Seconds_Of (Hour   :  Hour_Number;
                         Minute : Minute_Number;
                         Second : Second_Number := 0;
                         Sub_Second : Second_Duration := 0.0)
        return Day_Duration;

    procedure Split (Seconds    : in Day_Duration;
                     Hour       : out Hour_Number;
                     Minute     : out Minute_Number;
                     Second     : out Second_Number;
                     Sub_Second : out Second_Duration);

    procedure Split (Date       : in Time;
                     Time_Zone  : in Time_Zones.Time_Offset := 0;
                     Year       : out Year_Number;
                     Month      : out Month_Number;
                     Day        : out Day_Number;
                     Hour       : out Hour_Number;
                     Minute     : out Minute_Number;
                     Second     : out Second_Number;
                     Sub_Second : out Second_Duration);

    function Time_Of (Year       : Year_Number;
                      Month      : Month_Number;
                      Day        : Day_Number;
                      Hour       : Hour_Number;
                      Minute     : Minute_Number;
                      Second     : Second_Number;
                      Sub_Second : Second_Duration := 0.0;
                      Leap_Second: Boolean := False;
                      Time_Zone  : Time_Zones.Time_Offset := 0)
                              return Time;

    function Time_Of (Year       : Year_Number;
                      Month      : Month_Number;
                      Day        : Day_Number;
                      Seconds    : Day_Duration;
                      Leap_Second: Boolean := False;
                      Time_Zone  : Time_Zones.Time_Offset := 0)
                              return Time;

    procedure Split (Date       : in Time;
                     Time_Zone  : in Time_Zones.Time_Offset := 0;
                     Year       : out Year_Number;
                     Month      : out Month_Number;
                     Day        : out Day_Number;
                     Hour       : out Hour_Number;
                     Minute     : out Minute_Number;
                     Second     : out Second_Number;
                     Sub_Second : out Second_Duration;
                     Leap_Second: out Boolean);

    procedure Split (Date       : in Time;
                     Time_Zone  : in Time_Zones.Time_Offset := 0;
                     Year       : out Year_Number;
                     Month      : out Month_Number;
                     Day        : out Day_Number;
                     Seconds    : out Day_Duration;
                     Leap_Second: out Boolean);

    -- Simple image and value:
    function Image (Date : Time;
                    Include_Time_Fraction : Boolean := False;
                    Time_Zone  : Time_Zones.Time_Offset := 0) return String;

    function Value (Date : String;
                    Time_Zone  : Time_Zones.Time_Offset := 0) return Time;

    function Image (Elapsed_Time : Duration;
                    Include_Time_Fraction : Boolean := False) return String;

    function Value (Elapsed_Time : String) return Duration;

end Ada.Calendar.Formatting;

Type Time_Offset represents the number of minutes difference between the implementation-defined time zone used by Ada.Calendar and another time zone.

function UTC_Time_Offset (Date : Time := Clock) return Time_Offset;

Returns, as a number of minutes, the difference between the implementation-defined time zone of Calendar, and UTC time, at the time Date. If the time zone of the Calendar implementation is unknown, then Unknown_Zone_Error is raised.

procedure Difference (Left, Right : in Time;
                      Days : out Day_Count;
                      Seconds : out Duration;
                      Leap_Seconds : out Leap_Seconds_Count);

Returns the difference between Left and Right. Days is the number of days of difference, Seconds is the remainder seconds of difference, and Leap_Seconds is the number of leap seconds. If Left < Right, then Seconds <= 0.0, Days <= 0, and Leap_Seconds <= 0. Otherwise, all values are non-negative. For the returned values, if Days = 0, then Seconds + Duration(Leap_Seconds) = Calendar."-" (Left, Right).

function "+" (Left : Time; Right : Day_Count) return Time;
function "+" (Left : Day_Count; Right : Time) return Time;

Adds a number of days to a time value. Time_Error is raised if the result is not representable as a value of type Time.

function "-" (Left : Time; Right : Day_Count) return Time;

Subtracts a number of days from a time value. Time_Error is raised if the result is not representable as a value of type Time.

function "-" (Left, Right : Time) return Day_Count;

Subtracts two time values, and returns the number of days between them. This is the same value that Difference would return in Days.

function Day_of_Week (Date : Time) return Day_Name;

Returns the day of the week for Time. This is based on the Year, Month, and Day values of Time.

function Hour       (Date : Time;
                     Time_Zone  : Time_Zones.Time_Offset := 0)
                        return Hour_Number;

Returns the hour for Date, as appropriate for the specified time zone offset.

function Minute     (Date : Time;
                     Time_Zone  : Time_Zones.Time_Offset := 0)
                        return Minute_Number;

Returns the minute within the hour for Date, as appropriate for the specified time zone offset.

function Second     (Date : Time;
                     Time_Zone  : Time_Zones.Time_Offset := 0)
                        return Second_Number;

Returns the second within the hour and minute for Date, as appropriate for the specified time zone offset.

function Sub_Second (Date : Time;
                     Time_Zone  : Time_Zones.Time_Offset := 0)
                        return Second_Duration;

Returns the fraction of second for Date (this has the same accuracy as Day_Duration), as appropriate for the specified time zone offset.

function Seconds_Of (Hour   : Hour_Number;
                     Minute : Minute_Number;
                     Second : Second_Number := 0;
                     Sub_Second : Second_Duration := 0.0)
    return Day_Duration;

Returns a Day_Duration value for the Hour:Minute:Second.Sub_Second. This value can be used in Calendar.Time_Of as well as the argument to Calendar."+" and Calendar."-".

procedure Split (Seconds    : in Day_Duration;
                 Hour       : out Hour_Number;
                 Minute     : out Minute_Number;
                 Second     : out Second_Number;
                 Sub_Second : out Second_Duration);

Splits Seconds into Hour:Minute:Second.Sub_Second.

procedure Split (Date       : in Time;
                 Time_Zone  : in Time_Zones.Time_Offset := 0;
                 Year       : out Year_Number;
                 Month      : out Month_Number;
                 Day        : out Day_Number;
                 Hour       : out Hour_Number;
                 Minute     : out Minute_Number;
                 Second     : out Second_Number;
                 Sub_Second : out Second_Duration);

Splits Date into its constituent parts (Year, Month, Day, Hour, Minute, Second, Sub_Second), relative to the specified time zone offset.

function Time_Of (Year       : Year_Number;
                  Month      : Month_Number;
                  Day        : Day_Number;
                  Hour       : Hour_Number;
                  Minute     : Minute_Number;
                  Second     : Second_Number;
                  Sub_Second : Second_Duration := 0.0;
                  Leap_Second: Boolean := False;
                  Time_Zone  : Time_Zones.Time_Offset := 0)
                          return Time;

Returns a Time built from the date and time values, relative to the specified time zone offset. Time_Error is raised if Leap_Second is True, and Hour, Minute, and Second are not appropriate for a Leap_Second.

function Time_Of (Year       : Year_Number;
                  Month      : Month_Number;
                  Day        : Day_Number;
                  Seconds    : Day_Duration;
                  Leap_Second: Boolean := False;
                  Time_Zone  : Time_Zones.Time_Offset := 0)
                          return Time;

Returns a Time built from the date and time values, relative to the specified time zone offset. Time_Error is raised if Leap_Second is True, and Seconds is not appropriate for a Leap_Second.

procedure Split (Date       : in Time;
                 Time_Zone  : in Time_Zones.Time_Offset := 0;
                 Year       : out Year_Number;
                 Month      : out Month_Number;
                 Day        : out Day_Number;
                 Hour       : out Hour_Number;
                 Minute     : out Minute_Number;
                 Second     : out Second_Number;
                 Sub_Second : out Second_Duration;
                 Leap_Second: out Boolean);

Split Date into its constituent parts (Year, Month, Day, Hour, Minute, Second, Sub_Second), relative to the specified time zone offset. Leap_Second is true if Date identifies a leap second.

procedure Split (Date       : in Time;
                 Time_Zone  : in Time_Zones.Time_Offset := 0;
                 Year       : out Year_Number;
                 Month      : out Month_Number;
                 Day        : out Day_Number;
                 Seconds    : out Day_Duration;
                 Leap_Second: out Boolean);

Split Date into its constituent parts (Year, Month, Day, Seconds), relative to the specified time zone offset. Leap_Second is true if Date identifies a leap second.

function Image (Date : Time;
                Include_Time_Fraction : Boolean := False;
                Time_Zone  : Time_Zones.Time_Offset := 0) return String;

Returns a string form of the Date relative to the given Time_Zone. The format is "Year-Month-Day Hour:Minute:Second", where each value other than Year is a 2-digit form of the value of the functions defined in Calendar and Calendar.Formatting, including a leading '0', if needed. Year is a 4-digit value. If Include_Time_Fraction is True, Sub_Seconds*100 is suffixed to the string as a 2-digit value following a '.'.

function Value (Date : String)
                Time_Zone  : Time_Zones.Time_Offset := 0) return Time;

Returns a Time value for the image given as Date, relative to the given time zone. Constraint_Error is raised if the string is not formatted as described for Image, or the function cannot interpret the given string as a Time value.

function Image (Elapsed_Time : Duration;
                Include_Time_Fraction : Boolean := False) return String;

abs

function Value (Elapsed_Time : String) return Duration;

Returns a Duration value for the image given as Elapsed_Time. Constraint_Error is raised if the string is not formatted as described for Image, or the function cannot interpret the given string as a Duration value.

Implementation Advice

An implementation should support leap seconds if the target system supports them. If leap seconds are not supported, Difference should return zero for Leap_Seconds, Split should return False for Leap_Second, and Time_Of should raise Time_Error if Leap_Second is True.

NOTES
36 The time in the time zone known as Greenwich Mean Time (GMT) is generally equivalent to UTC time.

37 The implementation-defined time zone of package Calendar may, but need not, be the local time zone. UTC_Time_Offset always returns the difference relative to the implementation-defined time zone of package Calendar. If UTC_Time_Offset does not raise Unknown_Zone_Error, UTC time can be safely calculated (within the accuracy of the underlying time-base).

38 Calling Split on the results of subtracting Duration(UTC_Time_Offset*60) from Clock provides the components (hours, minutes, and so on) of the UTC time. In the United States, for example, UTC_Time_Offset will generally be negative.

9.7.2 Timed Entry Calls

Replace paragraph 1: [AI95-00345-01]

timed_entry_call

by:

timed_entry_call

Replace paragraph 3: [AI95-00345-01]

entry_call_alternative ::=
   entry_call_statement [sequence_of_statements]

by:

entry_call_alternative ::=
   procedure_or_entry_call [sequence_of_statements]

procedure_or_entry_call ::=
   procedure_call_statement | entry_call_statement

Legality Rules

procedure_call_statement

procedure_or_entry_call

procedure_

name

procedure_

prefix

procedure_call_statement

Static Semantics

procedure_call_statement

procedure_or_entry_call

procedure_

name

procedure_

prefix

procedure_call_statement

Replace paragraph 4: [AI95-00345-01]

timed_entry_call

entry_

name

delay_

expression

delay_alternative

by:

timed_entry_call

entry_

name

procedure_

name

procedure_

prefix

delay_

expression

delay_alternative

sequence_of_statements

entry_call_alternative

delay_alternative

sequence_of_statements

9.7.4 Asynchronous Transfer of Control

Replace paragraph 4: [AI95-00345-01]

triggering_statement ::= entry_call_statement | delay_statement

by:

triggering_statement ::= procedure_or_entry_call | delay_statement

Replace paragraph 6: [AI95-00345-01]

asynchronous_select

triggering_statement

entry_call_statement

entry_

name

abortable_part

by:

asynchronous_select

triggering_statement

procedure_or_entry_call

entry_

name

procedure_

name

procedure_

prefix

abortable_part

sequence_of_statements

triggering_alternative

abortable_part

9.8 Abort of a Task - Abort of a Sequence of Statements

Replace paragraph 3: [AI95-00345-01]

task_

name

by:

task_

name

9.9 Task and Entry Attributes

Replace paragraph 1: [AI95-00345-01]

prefix

by:

prefix

Section 10: Program Structure and Compilation Issues

10.1.1 Compilation Units - Library Units

Insert after paragraph 12: [AI95-00217-06; AI95-00326-01]

library_unit_declaration

library_unit_renaming_declaration

private

private

public

public descendants

private descendants

the new paragraphs:

package_declaration

limited view

For each nested package_declaration, a declaration of the limited view of that package, with the same defining_program_unit_name.

For each type_declaration in the visible part, an incomplete view of the type is declared. If the type_declaration is tagged, then the view is a tagged incomplete view.

package_declaration

private

not

library_item

package_declaration

Replace paragraph 19: [AI95-00331-01]

with_clause

by:

with_clause

Replace paragraph 26: [AI95-00217-06]

library_item

library_unit_body

library_unit_declaration

library_item

with_clause

attribute_reference

by:

library_item

library_unit_body

library_unit_declaration

library_item

with_clause

attribute_reference

Dynamic Semantics

The elaboration of the limited view of a package has no effect.

10.1.2 Context Clauses - With Clauses

Replace paragraph 4: [AI95-00217-06; AI95-00326-01]

with_clause ::= with library_unit_name {, library_unit_name};

by:

with_clause ::= limited_with_clause | nonlimited_with_clause
limited_with_clause ::= limited [private] with library_unit_name {, library_unit_name};
nonlimited_with_clause ::= [private] with library_unit_name {, library_unit_name};

Replace paragraph 6: [AI95-00217-06]

library_item

mentioned

with_clause

library_unit_

name

prefix

with_clause

by:

library_item

named

with_clause

library_unit_

name

with_clause

library_item

mentioned

with_clause

prefix

with_clause

Replace paragraph 8: [AI95-00217-06; AI95-00220-01; AI95-00262-01]

with_clause

compilation_unit

by:

with_clause

compilation_unit

the declaration, body, or subunit of a private descendant of that library unit;

the body or subunit of a public descendant of that library unit, but not a subprogram body acting as a subprogram declaration (see 10.1.4); or

the declaration of a public descendant of that library unit, and the with_clause shall include the reserved word private.

name

with_clause

private

a private part,

a body, but not within the subprogram_specification of a library subprogram body,

a private descendant of the unit on which one of these with_clauses appear, or

a pragma within a context clause.

library_item

limited_with_clause

package_declaration

subprogram_declaration

generic_declaration

generic_instantiation

package_renaming_declaration

limited_with_clause

library_unit_body

subunit

limited_with_clause

library_item

in the same context_clause as a nonlimited_with_clause which mentions the same library_item; or

in the same context_clause as a use_clause which names an entity declared within the declarative region of the library_item; or

in the scope of a nonlimited_with_clause which mentions the same library_item; or

in the scope of a use_clause which names an entity declared within the declarative region of the library_item.

10.1.3 Subunits of Compilation Units

Replace paragraph 3: [AI95-00218-03]

subprogram_body_stub ::= subprogram_specification is separate;

by:

subprogram_body_stub ::=
    [overriding_indicator]
    subprogram_specification is separate;

Replace paragraph 8: [AI95-00243-01]

parent body

parent_unit_name

subunit

subunit

proper_body

subunit

by:

parent body

parent_unit_name

subunit

subunit

proper_body

subunit

subunit of a program unit

10.1.4 The Compilation Process

Replace paragraph 3: [AI95-00217-06]

The mechanisms for creating an environment and for adding and replacing compilation units within an environment are implementation defined.

by:

limited_with_clause

Replace paragraph 6: [AI95-00217-06]

The implementation may require that a compilation unit be legal before inserting it into the environment.

by:

limited_with_clause

Replace paragraph 7: [AI95-00214-01]

library_item

defining_program_unit_name

pragma

by:

library_item

subunit

body_stub

library_item

subunit

body_stub

pragma

10.1.5 Pragmas and Program Units

Replace paragraph 9: [AI95-00212-01]

library_item

by:

library_item

10.1.6 Environment-Level Visibility Rules

Replace paragraph 2: [AI95-00312-01]

parent_unit_name

library_item

with_clause

library_item

with_clause

prefix

selector_name

by:

parent_unit_name

library_item

with_clause

library_item

Insert after paragraph 5: [AI95-00312-01]

pragma

library_item

the new paragraph:

with_clause

pragma

context_clause

pragma

prefix

selector_name

10.2 Program Execution

Replace paragraph 6: [AI95-00217-06]

If a compilation unit with stubs is needed, then so are any corresponding subunits.

by:

If a compilation unit with stubs is needed, then so are any corresponding subunits;

If the limited view of a unit is needed, then the full view of the unit is needed.

Replace paragraph 9: [AI95-00256-01]

elaboration dependences

library_item

by:

elaboration dependences

library_item

10.2.1 Elaboration Control

Insert after paragraph 4: [AI95-00161-01]

pragma

the new paragraphs:

pragma

pragma

direct_name

Replace paragraph 9: [AI95-00161-01]

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.

by:

The creation of an object (including a component) of a type which does not have preelaborable initialization. Similarly the evaluation of an extension_aggregate with an ancestor subtype_mark denoting a subtype of such a type.

Insert after paragraph 11: [AI95-00161-01]

pragma

preelaborated

library_item

the new paragraphs:

The following rules specify which entities have preelaborable initialization:

The partial view of a private type or private extension, a protected type without entry_declarations, a generic formal private type, or a generic formal derived type, have preelaborable initialization if and only if the pragma Preelaborable_Initialization has been applied to them.

A component (including a discriminant) of a record or protected type has preelaborable initialization if its declaration includes a default_expression whose execution does not perform any actions prohibited in preelaborable constructs as described above, or if its declaration does not include a default expression and its type has preelaborable initialization.

A derived type has preelaborable initialization if its parent type has preelaborable initialization and (in the case of a derived record or protected type) if the non-inherited components all have preelaborable initialization. Moreover, a user-defined controlled type with an overridding Initialize procedure does not have preelaborable initialization.

A view of a type has preelaborable initialization if it is an elementary type, an array type whose component type has preelaborable initialization, or a record type whose components all have preelaborable initialization.

pragma

package_specification

direct_name

entry_declaration

pragma

generic_formal_part

direct_name

generic_formal_part

pragma

generic_instantiation

Replace paragraph 16: [AI95-00366-01]

library_item

by:

library_item

Replace paragraph 17: [AI95-00366-01]

pragma

by:

pragma

Replace paragraph 18: [AI95-00366-01]

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.

by:

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. In addition, the implementation may omit a call on such a subprogram and simply reuse the results produced by an earlier call on the same subprogram, provided that none of the parameters nor any object accessible via access values from the parameters are of a limited type, and the addresses and values of all by-reference actual parameters, the values of all by-copy-in actual parameters, and the values of all objects accessible via access values from the parameters, are the same as they were at the earlier call. This permission applies even if the subprogram produces other side effects when called.

Section 11: Exceptions

11.3 Raise Statements

Replace paragraph 2: [AI95-00361-01]

raise_statement ::= raise [exception_name];

by:

raise_statement ::= raise; |
       raise exception_name [with string_expression];

Insert after paragraph 3: [AI95-00361-01]

raise_statement

exception_

name

re-raise statement

the new paragraph:

Name Resolution Rules

expression

raise_statement

Replace paragraph 4: [AI95-00361-01]

raise an exception

raise_statement

exception_

name

by:

raise an exception

raise_statement

exception_

name

string_

expression

11.4.1 The Package Exceptions

Replace paragraph 2: [AI95-00362-01]

package Ada.Exceptions is
    type Exception_Id is private;
    Null_Id : constant Exception_Id;
    function Exception_Name(Id : Exception_Id) return String;

by:

package Ada.Exceptions is
    pragma Preelaborate(Exceptions);
    type Exception_Id is private;
    pragma Preelaborable_Initialization (Exception_Id);
    Null_Id : constant Exception_Id;
    function Exception_Name(Id : Exception_Id) return String;

Replace paragraph 3: [AI95-00362-01]

    type Exception_Occurrence is limited private;
    type Exception_Occurrence_Access is access all Exception_Occurrence;
    Null_Occurrence : constant Exception_Occurrence;

by:

    type Exception_Occurrence is limited private;
    pragma Preelaborable_Initialization (Exception_Occurrence);
    type Exception_Occurrence_Access is access all Exception_Occurrence;
    Null_Occurrence : constant Exception_Occurrence;

Replace paragraph 4: [AI95-00329-01]

    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);

by:

    procedure Raise_Exception(E : in Exception_Id;
                              Message : in String := "");
        pragma No_Return(Raise_Exception);
    function Exception_Message(X : Exception_Occurrence) return String;
    procedure Reraise_Occurrence(X : in Exception_Occurrence);

Replace paragraph 10: [AI95-00361-01; AI95-00378-01]

raise_statement

exception_

name

by:

raise_statement

exception_

name

string_

expression

raise_statement

exception_

name

string_

expression

Replace paragraph 12: [AI95-00378-01]

defining_identifier

block_statement

by:

defining_identifier

block_statement

Replace paragraph 13: [AI95-00378-01]

Exception_Information returns implementation-defined information about the exception occurrence.

by:

Exception_Information returns implementation-defined information about the exception occurrence. The returned string has lower bound 1.

Replace paragraph 14: [AI95-00241-01; AI95-00329-01]

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.

by:

Reraise_Occurrence has no effect in the case of Null_Occurrence. Raise_Exception and Exception_Name raise Constraint_Error for a Null_Id. Exception_Message, Exception_Name, and Exception_Information raise Constraint_Error for a Null_Occurrence. Exception_Identity applied to Null_Occurrence returns Null_Id.

11.4.2 Pragmas Assert and Assertion_Policy

Insert new clause: [AI95-00286-01]

Pragma Assert is used to assert the truth of a Boolean expression at any point within a sequence of declarations or statements. Pragma Assertion_Policy is used to control whether such assertions are to be ignored by the implementation, checked at run-time, or handled in some implementation-defined manner.

Syntax

pragma

pragma

Boolean_

expression

string_

expression

pragma

declarative_item

statement

pragma

pragma

policy_

identifier

pragma

Legality Rules

policy_

identifier

Static Semantics

pragma

The following language-defined library package exists:

package Ada.Assertions is
    pragma Pure(Assertions);

    Assertion_Error : exception;

    procedure Assert(Check : in Boolean);
    procedure Assert(Check : in Boolean; Message : in String);

end Ada.Assertions;

A compilation unit containing a pragma Assert has a semantic dependence on the Ada.Assertions library unit.

The assertion policy that applies within an instance is the policy that applies within the generic unit.

Dynamic Semantics

pragma

Calling the procedure Ada.Assertions.Assert without a Message parameter is equivalent to:

if Check = False then
   raise Ada.Assertions.Assertion_Error;
end if;

Calling the procedure Ada.Assertions.Assert with a Message parameter is equivalent to:

if Check = False then
   raise Ada.Assertions.Assertion_Error with Message;
end if;

The procedures Assertions.Assert have these effects independently of the assertion policy in effect.

Implementation Permissions

Assertion_Error may be declared by renaming an implementation-defined exception from another package.

Implementations may define their own assertion policies.

NOTES
Normally, the Boolean expression in an Assert pragma should not call functions that have significant side-effects when the result of the expression is True, so that the particular assertion policy in effect will not affect normal operation of the program.

11.5 Suppressing Checks

Replace paragraph 1: [AI95-00224-01]

pragma

by:

Checking pragmas

pragma

Replace paragraph 3: [AI95-00224-01]

pragma

by:

The forms of checking pragmas are as follows:

Replace paragraph 4: [AI95-00224-01]

pragma

identifier

name

by:

pragma

identifier

pragma

identifier

Replace paragraph 5: [AI95-00224-01]

pragma

declarative_part

package_specification

by:

declarative_part

package_specification

Replace paragraph 6: [AI95-00224-01]

identifier

name

by:

identifier

Delete paragraph 7: [AI95-00224-01]

pragma

package_specification

name

package_specification

Replace paragraph 8: [AI95-00224-01]

pragma

package_specification

name

pragma

name

suppressed

by:

declarative_part

package_specification

pragma

suppressed

pragma

Replace paragraph 11: [AI95-00231-01]

name

null

discriminant_association

null

by:

name

null

Insert before paragraph 20: [AI95-00280-01]

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.

the new paragraphs:

Accessibility_Check: Check the accessibility level of an entity or view.

Allocation_Check: For an allocator, check that the master of any tasks has not yet finished waiting for dependents, and that the finalization of the collection has not started.

Replace paragraph 27: [AI95-00224-01]

pragma

by:

pragma

Insert after paragraph 29: [AI95-00224-01]

pragma

the new paragraph:

pragma

declarative_part

pragma

Replace paragraph 32: [AI95-00224-01]

pragma Suppress(Range_Check);
pragma Suppress(Index_Check, On => Table);

by:

pragma Suppress(Index_Check);
pragma Unsuppress(Overflow_Check);

Section 12: Generic Units

12.3 Generic Instantiation

Replace paragraph 2: [AI95-00218-03]

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];

by:

generic_instantiation ::=
     package defining_program_unit_name is
        new generic_package_name [generic_actual_part];
   | [overriding_indicator]
     procedure defining_program_unit_name is
        new generic_procedure_name [generic_actual_part];
   | [overriding_indicator]
     function defining_designator is
        new generic_function_name [generic_actual_part];

12.4 Formal Objects

Delete paragraph 8: [AI95-00287-01]

Replace paragraph 9: [AI95-00255-01]

formal_object_declaration

subtype_mark

in out

subtype_mark

by:

formal_object_declaration

subtype_mark

in out

subtype_mark

Replace paragraph 10: [AI95-00269-01]

formal_object_declaration

in out

by:

formal_object_declaration

full constant declaration

formal_object_declaration

in out

12.5 Formal Types

Replace paragraph 3: [AI95-00251-01]

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

by:

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
    | formal_interface_type_definition

Replace paragraph 8: [AI95-00233-01]

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. For an elementary formal type, the predefined operators are implicitly declared immediately after the declaration of the formal type. For a composite formal type, the predefined operators are implicitly declared either immediately after the declaration of the formal type, or later in its immediate scope according to the rules of 7.3.1. 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 12.5.1.

by:

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. For an elementary formal type, the predefined operators are implicitly declared immediately after the declaration of the formal type. For a composite formal type, the predefined operators are implicitly declared either immediately after the declaration of the formal type, or later immediately within the declarative region in which the type is declared according to the rules of 7.3.1. 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 12.5.1.

12.5.1 Formal Private and Derived Types

Replace paragraph 3: [AI95-00251-01]

formal_derived_type_definition ::= [abstract] new subtype_mark [with private]

by:

formal_derived_type_definition ::=
     [abstract] new subtype_mark [[and interface_list] with private]

Insert after paragraph 10: [AI95-00231-01]

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 3.7.

the new paragraph:

If the ancestor subtype is an access subtype, the actual subtype shall exclude null if and only if the ancestor subtype excludes null.

Insert after paragraph 15: [AI95-00251-01]

unknown_discriminant_part

the new paragraph:

The actual type for a generic formal derived type shall be a descendant of every ancestor of the formal type.

Replace paragraph 20: [AI95-00233-01]

discriminant_part

derived_type_definition

by:

discriminant_part

derived_type_definition

Replace paragraph 21: [AI95-00233-01]

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 7.3.1). In an instance, the copy of such an implicit declaration declares a view of the corresponding primitive subprogram of the ancestor of the formal derived type, even if this primitive has been overridden for the actual type. When the ancestor of the formal derived type is itself a formal type, the copy of the implicit declaration declares a view of the corresponding copied operation of the ancestor. 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.

by:

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, immediately within the declarative region in which the formal type is declared, where the corresponding primitive subprogram of the ancestor is visible (see 7.3.1). In an instance, the copy of such an implicit declaration declares a view of the corresponding primitive subprogram of the ancestor of the formal derived type, even if this primitive has been overridden for the actual type. When the ancestor of the formal derived type is itself a formal type, the copy of the implicit declaration declares a view of the corresponding copied operation of the ancestor. 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.

Insert after paragraph 23: [AI95-00158-01]

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.

the new paragraphs:

Dynamic Semantics

12.5.4 Formal Access Types

Replace paragraph 4: [AI95-00231-01]

general_access_modifier

constant

general_access_modifier

all

by:

general_access_modifier

constant

general_access_modifier

all

12.5.5 Formal Interface Types

Insert new clause: [AI95-00251-01; AI95-00345-01]

The class determined for a formal interface type is the class of all interface types.

Syntax

formal_interface_type_definition ::= interface_type_definition

Legality Rules

The actual type shall be an interface type.

The actual type shall be a descendant of every ancestor of the formal type.

The actual type shall be a limited, task, protected, or synchronized interface if and only if the formal type is also, respectively, a limited, task, protected, or synchronized interface.

12.6 Formal Subprograms

Replace paragraph 2: [AI95-00260-02]

formal_subprogram_declaration ::= with subprogram_specification [is subprogram_default];

by:

formal_subprogram_declaration ::= formal_abstract_subprogram_declaration
   | formal_concrete_subprogram_declaration
formal_concrete_subprogram_declaration ::=
     with subprogram_specification [is subprogram_default];
formal_abstract_subprogram_declaration ::=
     with subprogram_specification is abstract [subprogram_default];

Replace paragraph 3: [AI95-00348-01]

subprogram_default ::= default_name | <>

by:

subprogram_default ::= default_name | <> | null

Insert after paragraph 4: [AI95-00260-01; AI95-00348-01]

default_name ::= name

the new paragraph:

subprogram_default

null

formal_abstract_subprogram_declaration

Insert after paragraph 8: [AI95-00260-02]

The profiles of the formal and actual shall be mode-conformant.

the new paragraphs:

formal_abstract_subprogram_declaration

controlling type

formal_abstract_subprogram_declaration

controlling type

formal_abstract_subprogram_declaration

Replace paragraph 9: [AI95-00345-01]

formal_subprogram_declaration

subtype_mark

formal_subprogram_declaration

subtype_mark

formal_subprogram_declaration

name

default_expression

formal_subprogram_declaration

by:

formal_subprogram_declaration

subtype_mark

formal_subprogram_declaration

subtype_mark

formal_subprogram_declaration

name

default_expression

formal_subprogram_declaration

Insert after paragraph 10: [AI95-00260-01; AI95-00348-01]

subprogram_default

the new paragraphs:

subprogram_default

null

formal_subprogram_declaration

formal_abstract_subprogram_declaration

Replace paragraph 16: [AI95-00260-01; AI95-00348-01]

18 The actual subprogram cannot be abstract (see 3.9.3).

by:

18 The actual subprogram cannot be abstract unless the formal subprogram is a formal_abstract_subprogram_declaration (see 3.9.3).

19 The subprogram declared by a formal_abstract_subprogram_declaration is an abstract subprogram. All calls on a subprogram declared by a formal_abstract_subprogram_declaration must be dispatching calls. See 3.9.3.

20 A null procedure as a subprogram default has convention Intrinsic (see 6.3.1).

12.7 Formal Packages

Replace paragraph 3: [AI95-00317-01]

formal_package_actual_part ::=
    (<>) | [generic_actual_part]

by:

formal_package_actual_part ::=
    ([others =>] <>)
  | [generic_actual_part]
  | (formal_package_association {, formal_package_association}, others => <>)

formal_package_association ::=
    generic_association
  | generic_formal_parameter_selector_name => <>

formal_package_association

Replace paragraph 5: [AI95-00317-01]

formal_package_actual_part

by:

formal_package_actual_part

others

If the formal_package_actual_part includes generic_associations as well as associations with <>, then only the actual parameters specified explicitly with generic_associations are required to match;

Otherwise, all actual parameters shall match, whether the actual parameter is given explicitly or by default.

The rules for matching of actual parameters between the actual instance and the formal package are as follows:

Replace paragraph 10: [AI95-00317-01]

basic_declarative_item

package_specification

formal_package_actual_part

generic_formal_part

by:

basic_declarative_item

package_specification

formal_package_actual_part

Section 13: Representation Issues

13.1 Representation Items

Replace paragraph 11: [AI95-00326-01]

Operational and representation aspects of a generic formal parameter are the same as those of the actual. Operational and representation aspects of a partial view are the same as those of the full view. A type-related representation item is not allowed for a descendant of a generic formal untagged type.

by:

Operational and representation aspects of a generic formal parameter are the same as those of the actual. Operational and representation aspects are the same for all views of a type. A type-related representation item is not allowed for a descendant of a generic formal untagged type.

13.3 Representation Attributes

Insert after paragraph 8: [AI95-00133-01]

storage element

word

the new paragraph:

machine scalar

component_clause

Replace paragraph 25: [AI95-00051-01]

attribute_definition_clause

by:

attribute_definition_clause

allocator

Delete paragraph 26: [AI95-00247-01]

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.

Replace paragraph 28: [AI95-00051-01]

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.

by:

Program execution is erroneous if an object that is not allocated under control of the implementation is not aligned according to its Alignment.

Replace paragraph 30: [AI95-00051-01]

An implementation should support specified Alignments that are factors and multiples of the number of storage elements per word, subject to the following:

by:

An implementation should support a confirming Alignment clause for any kind of type.

An implementation should support a nonconfirming Alignment clause for a discrete type, fixed point type, record type, or array type, specifying an Alignment value that is zero or a power of two, subject to the following:

Replace paragraph 31: [AI95-00051-01]

An implementation need not support specified Alignments for combinations of Sizes and Alignments that cannot be easily loaded and stored by available machine instructions.

by:

An implementation need not support an Alignment clause for a signed integer type specifying an Alignment greater than the largest Alignment value that is ever chosen by default by the implementation for any signed integer type. A corresponding limitation may be imposed for modular integer types, fixed point types, enumeration types, record types, and array types.

Replace paragraph 32: [AI95-00051-01]

An implementation need not support specified Alignments that are greater than the maximum Alignment the implementation ever returns by default.

by:

An implementation need not support a nonconfirming Alignment clause which could enable the creation of an object of an elementary type which cannot be easily loaded and stored by available machine instructions.

Replace paragraph 42: [AI95-00051-01]

The recommended level of support for the Size attribute of objects is:

by:

The recommended level of support for the Size attribute of objects is the same as for subtypes (see below).

Delete paragraph 43: [AI95-00051-01]

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).

Replace paragraph 50: [AI95-00051-01]

If the Size of a subtype is specified, and allows for efficient independent addressability (see 9.10) on the target architecture, then the Size of the following objects of the subtype should equal the Size of the subtype:

by:

If the Size of a subtype allows for efficient independent addressability (see 9.10) on the target architecture, then the Size of the following objects of the subtype should equal the Size of the subtype:

Insert after paragraph 56: [AI95-00051-01]

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.

the new paragraphs:

An implementation should support a confirming Size clause for any kind of type.

An implementation should support a nonconfirming Size clause for a discrete type or a fixed point type, subject to the following:

An implementation need not support a Size clause for a signed integer type specifying a Size greater than that of the largest signed integer type supported by the implementation in the absence of a size clause (that is, when the size is chosen by default). A corresponding limitation may be imposed for modular integer types, fixed point types, and enumeration types.

13.5.1 Record Representation Clauses

Insert after paragraph 10: [AI95-00133-01]

position

first_bit

last_bit

position

first_bit

last_bit

first_bit

the new paragraphs:

If the nondefault bit ordering applies to the type, then either:

the value of last_bit shall be less than the size of the largest machine scalar; or

the value of first_bit shall be zero and the value of last_bit + 1 shall be a multiple of System.Storage_Unit.

Replace paragraph 13: [AI95-00133-01]

record_representation_clause

mod_clause

position

first_bit

last_bit

by:

record_representation_clause

mod_clause

position

first_bit

last_bit

component_clause

If the nondefault bit ordering applies to the type then the layout is determined as follows:

the component_clauses for which the value of last_bit is greater than or equal to the size of the largest machine scalar directly specify the position and size of the corresponding component;

for other component_clauses, all the components having the same value of position are considered to be part of a single machine scalar, located at that position; this machine scalar has a size which is the smallest machine scalar size larger than the largest last_bit for all component_clauses at that position; the first_bit and last_bit of each component_clause are then interpreted as bit offsets in this machine scalar.

Insert after paragraph 17: [AI95-00133-01]

record_representation_clause

the new paragraph:

An implementation should support machine scalars that correspond to all the integer, floating point, and address formats supported by the machine.

13.5.2 Storage Place Attributes

Replace paragraph 2: [AI95-00133-01]

R.C'Position: Denotes the same value as R.C'Address - R'Address. The value of this attribute is of the type universal_integer.

by:

R.C'Position: If the nondefault bit ordering applies to the composite type, and if a component_clause specifies the placement of C, denotes the value given for the position of the component_clause; otherwise, denotes the same value as R.C'Address - R'Address. The value of this attribute is of the type universal_integer.

Replace paragraph 3: [AI95-00133-01]

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.

by:

R.C'First_Bit: If the nondefault bit ordering applies to the composite type, and if a component_clause specifies the placement of C, denotes the value given for the first_bit of the component_clause; otherwise, 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.

Replace paragraph 4: [AI95-00133-01]

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.

by:

R.C'Last_Bit: If the nondefault bit ordering applies to the composite type, and if a component_clause specifies the placement of C, denotes the value given for the last_bit of the component_clause; otherwise, 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.

13.5.3 Bit Ordering

Replace paragraph 8: [AI95-00133-01]

If Word_Size = Storage_Unit, then the implementation should support the nondefault bit ordering in addition to the default bit ordering.

by:

The implementation should support the nondefault bit ordering in addition to the default bit ordering.

NOTES
13 Bit_Order clauses make it possible to write record_representation_clauses that can be ported between machines having different bit ordering. They do not guarantee transparent exchange of data between such machines.

13.7 The Package System

Replace paragraph 3: [AI95-00362-01]

package System is
   pragma Preelaborate(System);

by:

package System is
   pragma Pure(System);

Replace paragraph 12: [AI95-00161-01]

    type Address is implementation-defined;
    Null_Address : constant Address;

by:

    type Address is implementation-defined;
    pragma Preelaborable_Initialization(Address);
    Null_Address : constant Address;

In paragraph 15 replace: [AI95-00221-01]

   Default_Bit_Order : constant Bit_Order;

by:

   Default_Bit_Order : constant Bit_Order := implementation-defined;

Replace paragraph 35: [AI95-00221-01]

See 13.5.3 for an explanation of Bit_Order and Default_Bit_Order.

by:

See 13.5.3 for an explanation of Bit_Order and Default_Bit_Order. Default_Bit_Order shall be a static constant.

Replace paragraph 36: [AI95-00362-01]

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.

by:

13.7.1 The Package System.Storage_Elements

Replace paragraph 2: [AI95-00362-01]

package System.Storage_Elements is
   pragma Preelaborate(System.Storage_Elements);

by:

package System.Storage_Elements is
   pragma Pure(Storage_Elements);

Delete paragraph 15: [AI95-00362-01]

Package System.Storage_Elements may be declared pure.

13.9.1 Data Validity

Replace paragraph 12: [AI95-00167-01]

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.

by:

expression

assignment_statement

object_declaration

13.11 Storage Management

Replace paragraph 6: [AI95-00161-01]

    type Root_Storage_Pool is
        abstract new Ada.Controlled.Limited_Controlled with private;

by:

    type Root_Storage_Pool is
        abstract new Ada.Controlled.Limited_Controlled with private;
    pragma Preelaborable_Initialization(Root_Storage_Pool);

Replace paragraph 25: [AI95-00230-01]

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.

by:

allocator

If the allocator is initializing an access discriminant of an object of a limited type, and the discriminant is itself a subcomponent of an object being created by an outer allocator, then the storage pool used for the outer allocator should also be used for the allocator initializing the access discriminant;

Otherwise, the storage pool should be created at the point of the allocator, and be reclaimed when the allocated object becomes inaccessible.

13.11.1 The Max_Size_In_Storage_Elements Attribute

Replace paragraph 3: [AI95-00256-01]

universal_integer

by:

universal_integer

13.11.2 Unchecked Storage Deallocation

Replace paragraph 17: [AI95-00162-01]

For a standard storage pool, Free should actually reclaim the storage.

by:

For a standard storage pool, Free should actually reclaim the storage. If the object being reclaimed has an access discriminant which designates an object which was created by an allocator of the (anonymous) type of the access discriminant, then the designated object should also be reclaimed.

13.12 Pragma Restrictions

Replace paragraph 4: [AI95-00381-01]

restriction ::= restriction_identifier
    | restriction_parameter_identifier => expression

by:

restriction ::= restriction_identifier
    | restriction_parameter_identifier => restriction_parameter_argument

restriction_parameter_argument ::= name | expression

Insert after paragraph 7: [AI95-00257-01; AI95-00368-01]

restrictions

the new paragraphs:

restriction

identifier

No_Implementation_Attributes: There are no implementation-defined attributes. This restriction applies only to the current compilation or environment, not the entire partition.

No_Implementation_Pragmas: There are no implementation-defined pragmas or pragma arguments. This restriction applies only to the current compilation or environment, not the entire partition.

No_Obsolescent_Features: There is no use of language features defined in Annex J. It is implementation-defined if uses of the renamings of J.1 are detected by this restriction. This restriction applies only to the current compilation or environment, not the entire partition.

13.12.1 Restriction No_Dependence

Insert new clause: [AI95-00381-01]

Static Semantics

restriction_parameter

_identifier

No_Dependence: Specifies a language-defined library unit on which there are no semantic dependences.

Name Resolution Rules

restriction_parameter_argument

Post-Compilation Rules

name

13.13.1 The Package Streams

Replace paragraph 3: [AI95-00161-01]

    type Root_Stream_Type is abstract tagged limited private;

by:

    type Root_Stream_Type is abstract tagged limited private;
    pragma Preelaborable_Initialization(Root_Stream_Type);

Replace paragraph 8: [AI95-00227-01]

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.

by:

The Read operation transfers stream elements from the specified stream to fill the array Item. Elements are transferred until Item'Length elements have been transferred, or until the end of the stream is reached. If any elements are transferred, the index of the last stream element transferred is returned in Last. Otherwise, Item'First - 1 is returned in Last. Last is less than Item'Last only if the end of the stream is reached.

Insert after paragraph 10: [AI95-00227-01]

See A.12.1, ``The Package Streams.Stream_IO'' for an example of extending type Root_Stream_Type.

the new paragraph:

If the end of stream has been reached, and Item'First is Stream_Element_Offset'First, Read will raise Constraint_Error.

13.13.2 Stream-Oriented Attributes

Insert after paragraph 1: [AI95-00366-01]

The operational attributes Write, Read, Output, and Input convert values to a stream of elements and reconstruct values from a stream.

the new paragraphs:

support external streaming

A limited type supports external streaming only if it has available Read and Write attributes. A type with a part that is of an access type supports external streaming only if that access type or the type of some part that includes the access type component, has available Read and Write attributes. An anonymous access type does not support external streaming. All other types support external streaming.

Insert before paragraph 2: [AI95-00270-01]

the new paragraphs:

For every subtype S of an elementary type T, the following operational attribute is defined:

S'Stream_Size: Denotes the number of bits occupied in a stream by items of subtype S. Hence, the number of stream elements required per item of elementary type T is:

        T'Stream_Size / Ada.Streams.Stream_Element'Size

The value of this attribute is of type universal_integer and is a multiple of Stream_Element'Size.

Stream_Size may be specified for first subtypes via an attribute_definition_clause; the expression of such a clause shall be static, non-negative, and a multiple of Stream_Element'Size.

Implementation Advice

The recommended level of support for the Stream_Size attribute is: A Stream_Size clause should be supported for an elementary type T if the specified Stream_Size is a multiple of Stream_Element'Size and is no less than the size of the first subtype of T, and no greater than the size of the largest type of the same elementary class (signed integer, modular integer, floating point, ordinary fixed point, decimal fixed point, or access).

Replace paragraph 9: [AI95-00195-01; AI95-00270-01]

by:

Constraint_Error is raised by the predefined Write attribute if the value of the elementary item is outside the range of values representable using Stream_Size bits. For a signed integer type, an enumeration type, or a fixed-point type, the range is unsigned only if the integer code for the first subtype low bound is non-negative, and a (symmetric) signed range that covers all values of the first subtype would require more than Stream_Size bits; otherwise the range is signed.

Replace paragraph 17: [AI95-00270-01]

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.

by:

By default, the predefined stream-oriented attributes for an elementary type should only read or write the minimum number of stream elements required by the first subtype of the type, rounded up to the nearest factor or multiple of the word size that is also a multiple of the stream element size.

Replace paragraph 27: [AI95-00195-01]

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.

by:

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), passes it to S'Read, and returns the value of the object. Normal default initialization and finalization take place for this object (see 3.3.1, 7.6, 7.6.1).

Replace paragraph 31: [AI95-00344-01]

Item

Stream

Item

by:

Item

Stream

Item

Replace paragraph 34: [AI95-00279-01; AI95-00344-01]

Stream

by:

Stream

Replace paragraph 35: [AI95-00195-01]

component_declaration

default_expression

by:

component_declaration

default_expression

It is unspecified at which point and in which order these checks are performed. In particular, if Constraint_Error is raised due to the failure of one of these checks, it is unspecified how many stream elements have been read from the stream.

Insert after paragraph 36: [AI95-00279-01; AI95-00344-01]

attribute_definition_clause

attribute_reference

attribute_definition_clause

the new paragraph:

Erroneous Execution

If the internal tag returned by Descendant_Tag to T'Class'Input identifies a specific type whose tag has not been created, or does not exist in the partition at the time of the call, execution is erroneous.

Insert after paragraph 36.1: [AI95-00195-01]

the new paragraphs:

If Constraint_Error is raised during a call to Read because of failure of one the above checks, the implementation must ensure that the discriminants of the actual parameter of Read are not modified.

Implementation Permissions

The number of calls performed by the predefined implementation of the stream- oriented attributes on the Read and Write operations of the stream type is unspecified. An implementation may take advantage of this permission to perform internal buffering. However, all the calls on the Read and Write operations of the stream type needed to implement an explicit invocation of a stream-oriented attribute must take place before this invocation returns. An explicit invocation is one appearing explicitly in the program text, possibly through a generic instantiation (see 12.3).

Insert after paragraph 38: [AI95-00279-01]

32 User-specified attributes of S'Class are not inherited by other class-wide types descended from S.

the new paragraph:

33 If the prefix subtype S of function S'Class'Input is a library-level subtype, then reading a value of a type which has not yet been frozen with the S'Class'Input function will always raise Tag_Error; execution cannot be erroneous.

13.14 Freezing Rules

Insert after paragraph 7: [AI95-00251-01]

The declaration of a record extension causes freezing of the parent subtype.

the new paragraph:

The declaration of a specific descendant of an interface type freezes the interface type.

Insert after paragraph 15: [AI95-00341-01]

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.

the new paragraph:

At the place where a specific tagged type is frozen, the primitive subprograms of the type are frozen.

Insert after paragraph 19: [AI95-00279-01]

An operational or representation item that directly specifies an aspect of an entity shall appear before the entity is frozen (see 13.1).

the new paragraph:

Dynamic Semantics

The tag (see 3.9) of a tagged type T is created at the point where T is frozen.

Annex A: Predefined Language Environment

A.1 The Package Standard

Replace paragraph 36: [AI95-00285-01]

   -- 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 3.5.2.

   type Wide_Character is (nul, soh ... FFFE, FFFF);

   package ASCII is ... end ASCII;  --Obsolescent; see J.5

by:

   -- 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/IEC 10646:2003 BMP character set.
   -- The first 256 positions have the same contents as type Character. See 3.5.2.

   type Wide_Character is (nul, soh ... FFFE, FFFF);

   -- The declaration of type Wide_Wide_Character is based on the full
   -- ISO/IEC 10646:2003 character set. The first 65536 positions have the
   -- same contents as type Wide_Character. See 3.5.2.

   type Wide_Wide_Character is (nul, soh ... FFFE, FFFF, ...);

   package ASCII is ... end ASCII;  --Obsolescent; see J.5

Replace paragraph 42: [AI95-00285-01]

   -- The predefined operators for this type correspond to those for String

by:

   -- The predefined operators for this type correspond to those for String.

    type Wide_Wide_String is array (Positive range <>) of Wide_Wide_Character;
    pragma Pack (Wide_Wide_String);

    -- The predefined operators for this type correspond to those for String.

Replace paragraph 49: [AI95-00285-01]

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.

by:

In each of the types Character, Wide_Character, and Wide_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.

A.3 Character Handling

Replace paragraph 1: [AI95-00285-01]

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.

by:

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 and Wide_Wide_Character data. The child package Characters.Latin_1 declares a set of constants initialized to values of type Character.

A.3.2 The Package Characters.Handling

Replace paragraph 2: [AI95-00362-01]

package Ada.Characters.Handling is
   pragma Preelaborate(Handling);

by:

package Ada.Characters.Handling is
   pragma Pure(Handling);

Replace paragraph 13: [AI95-00285-01]

   --Classifications of and conversions between Wide_Character and Character.

by:

   --Classifications of and conversions between Wide_Wide_Character, Wide_Character, and Character.

Insert after paragraph 14: [AI95-00285-01]

   function Is_Character (Item : in Wide_Character) return Boolean;
   function Is_String    (Item : in Wide_String)    return Boolean;

the new paragraph:

   function Is_Character (Item : in Wide_Wide_Character) return Boolean;
   function Is_String    (Item : in Wide_Wide_String)    return Boolean;
   function Is_Wide_Character (Item : in Wide_Wide_Character) return Boolean;
   function Is_Wide_String    (Item : in Wide_Wide_String)    return Boolean;

Insert after paragraph 16: [AI95-00285-01]

   function To_String    (Item       : in Wide_String;
                        Substitute : in Character := ' ')
   return String;

the new paragraph:

   function To_Character (Item :       in Wide_Wide_Character;
                          Substitute : in Character := ' ') return Character;
   function To_String    (Item :       in Wide_Wide_String;
                          Substitute : in Character := ' ') return String;

Insert after paragraph 18: [AI95-00285-01]

   function To_Wide_String    (Item : in String)    return Wide_String;

the new paragraphs:

   function To_Wide_Character (Item :       in Wide_Wide_Character;
                               Substitute : in Wide_Character := ' ')
                               return Wide_Character;

   function To_Wide_String    (Item :       in Wide_Wide_String;
                               Substitute : in Wide_Character := ' ')
                               return Wide_String;

   function To_Wide_Wide_Character (Item : in Character)
         return Wide_Wide_Character;

   function To_Wide_Wide_String    (Item : in String)
         return Wide_Wide_String;

   function To_Wide_Wide_Character (Item : in Wide_Character)
         return Wide_Wide_Character;

   function To_Wide_Wide_String    (Item : in Wide_String)
         return Wide_Wide_String;

Replace paragraph 42: [AI95-00285-01]

The following set of functions test Wide_Character values for membership in Character, or convert between corresponding characters of Wide_Character and Character.

by:

The following functions test Wide_Wide_Character or Wide_Character values for membership in Wide_Character or Character, or convert between corresponding characters of Wide_Wide_Character, Wide_Character, and Character.

Replace paragraph 43: [AI95-00285-01]

Is_Character: Returns True if Wide_Character'Pos(Item) <= Character'Pos(Character'Last).

by:

function Is_Character (Item : in Wide_Character) return Boolean;

Returns True if Wide_Character'Pos(Item) <= Character'Pos(Character'Last).

function Is_Character (Item : in Wide_Wide_Character) return Boolean;

Returns True if Wide_Wide_Character'Pos(Item) <= Character'Pos(Character'Last).

function Is_Wide_Character (Item : in Wide_Wide_Character) return Boolean;

Returns True if Wide_Wide_Character'Pos(Item) <= Wide_Character'Pos(Wide_Character'Last).

Replace paragraph 44: [AI95-00285-01]

Is_String: Returns True if Is_Character(Item(I)) is True for each I in Item'Range.

by:

function Is_String (Item : in Wide_String)      return Boolean;
function Is_String (Item : in Wide_Wide_String) return Boolean;

Returns True if Is_Character(Item(I)) is True for each I in Item'Range.

function Is_Wide_String (Item : in Wide_Wide_String) return Boolean;

Returns True if Is_Wide_Character(Item(I)) is True for each I in Item'Range.

Replace paragraph 45: [AI95-00285-01]

To_Character: Returns the Character corresponding to Item if Is_Character(Item), and returns the Substitute Character otherwise.

by:

function To_Character (Item :       in Wide_Character;
                       Substitute : in Character := ' ') return Character;
function To_Character (Item :       in Wide_Wide_Character;
                       Substitute : in Character := ' ') return Character;

Returns the Character corresponding to Item if Is_Character(Item), and returns the Substitute Character otherwise.

function To_Wide_Character (Item : in Character) return Wide_Character;

Returns the Wide_Character X such that Character'Pos(Item) = Wide_Character'Pos (X).

function To_Wide_Character (Item :       in Wide_Wide_Character;
                            Substitute : in Wide_Character := ' ')
                            return Wide_Character;

Returns the Wide_Character corresponding to Item if Is_Wide_Character(Item), and returns the Substitute Wide_Character otherwise.

function To_Wide_Wide_Character (Item : in Character) return
    Wide_Wide_Character;

Returns the Wide_Wide_Character X such that Character'Pos(Item) = Wide_Wide_Character'Pos (X).

function To_Wide_Wide_Character (Item : in Wide_Character)
                                 return Wide_Wide_Character;

Returns the Wide_Wide_Character X such that Wide_Ch

International Standard ISO/IEC 8652:1995

Information technology -- Programming languages -- Ada AMENDMENT 1 (Draft 9)

Technologies de l'information -- Langages de programmation -- Ada AMENDEMENT 1

Introduction

Forward and Introduction

Introduction

Section 1: General

1.1.2 Structure

1.1.4 Method of Description and Syntax Notation

1.2 Normative References

Section 2: Lexical Elements

2.1 Character Set

2.2 Lexical Elements, Separators, and Delimiters

2.3 Identifiers

2.6 String Literals

2.9 Reserved Words

Section 3: Declarations and Types

3.1 Declarations

3.2 Types and Subtypes

3.2.1 Type Declarations

3.2.2 Subtype Declarations

3.2.3 Classification of Operations

3.3.1 Object Declarations

3.4 Derived Types and Classes

3.4.1 Derivation Classes

3.5 Scalar Types

3.5.2 Character Types

3.5.4 Integer Types

3.5.9 Fixed Point Types

3.6 Array Types

3.6.2 Operations of Array Types

3.6.3 String Types

3.7 Discriminants

3.7.1 Discriminant Constraints

3.8 Record Types

3.9 Tagged Types and Type Extensions

3.9.1 Type Extensions

3.9.2 Dispatching Operations of Tagged Types

3.9.3 Abstract Types and Subprograms

3.9.4 Interface Types

3.10 Access Types

3.10.1 Incomplete Type Declarations

3.10.2 Operations of Access Types

Section 4: Names and Expressions

4.1.3 Selected Components

4.1.4 Attributes

4.2 Literals

4.3 Aggregates

4.3.1 Record Aggregates

4.3.2 Extension Aggregates

4.3.3 Array Aggregates

4.5.2 Relational Operators and Membership Tests

4.5.5 Multiplying Operators

4.6 Type Conversions

4.8 Allocators

4.9 Static Expressions and Static Subtypes

4.9.1 Statically Matching Constraints and Subtypes

Section 5: Statements

5.2 Assignment Statements

Section 6: Subprograms

6.1 Subprogram Declarations

6.3 Subprogram Bodies

6.3.1 Conformance Rules

6.3.2 Inline Expansion of Subprograms

6.4 Subprogram Calls

6.5 Return Statements

6.5.1 Pragma No_Return

6.7 Null Procedures

Section 7: Packages

7.3 Private Types and Private Extensions

7.3.1 Private Operations

7.4 Deferred Constants

7.5 Limited Types

7.6 User-Defined Assignment and Finalization

7.6.1 Completion and Finalization

Section 8: Visibility Rules

8.1 Declarative Region

8.3 Visibility

8.4 Use Clauses

8.5.1 Object Renaming Declarations

Information technology -- Programming languages -- Ada
AMENDMENT 1 (Draft 9)

Technologies de l'information -- Langages de programmation -- Ada
AMENDEMENT 1