International Standard ISO/IEC 8652:1995

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

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), containers (see clause A.17), 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

Insert before paragraph 15: [AI95-00395-01]

syntactic category

like_this

the new paragraph:

When this International Standard mentions the conversion of some character or sequence of characters to upper case, it means the character or sequence of characters obtained by using locale-independent full case folding, as defined by documents referenced in the note in section 1 of ISO/IEC 10646:2003.

1.2 Normative References

Replace paragraph 3: [AI95-00415-01]

Information technology -- Programming languages -- FORTRAN

by:

Information technology -- Programming languages -- Fortran -- Part 1: Base language

Replace paragraph 4: [AI95-00415-01]

Programming languages -- COBOL

by:

Programming languages -- COBOL

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 7: [AI95-00415-01]

Programming languages -- C

by:

Programming languages -- C

Replace paragraph 8: [AI95-00285-01; AI95-00376-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)

Information technology - Programming languages - C++

Information technology - Programming Languages, their environments and system software inferfaces - Extensions for the programming language C to support new character data types

1.3 Definitions

Replace paragraph 1: [AI95-00415-01]

italic

Webster's Third New International Dictionary of the English Language

by:

italic

CRC Concise Encyclopedia of Mathematics, Second Edition

Webster's Third New International Dictionary of the English Language

Section 2: Lexical Elements

2.1 Character Set

Replace paragraph 1: [AI95-00285-01; AI95-00395-01]

comment

graphic_character

format_effector

by:

planes

Delete paragraph 2: [AI95-00285-01]

character ::= graphic_character | format_effector | other_control_function

Replace paragraph 3: [AI95-00285-01; AI95-00395-01]

graphic_character ::= identifier_letter | digit | space_character | special_character

by:

character

Replace paragraph 4: [AI95-00285-01; AI95-00395-01]

format_effector

other_control_function

by:

The coded representation for characters is implementation defined (it need not be a representation defined within ISO/IEC 10646:2003). A character whose relative code position in its plane is 16#FFFE# or 16#FFFF# is not allowed anywhere in the text of a program.

The semantics of an Ada program whose text is not in Normalization Form KC (as defined by section 24 of ISO/IEC 10646:2003) is 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.

Replace paragraph 6: [AI95-00285-01]

The categories of characters are defined as follows:

by:

Characters are categorized as follows:

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

Replace paragraph 11: [AI95-00285-01]

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

by:

separator_space: Any character whose General Category is defined to be "Separator, 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:

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

other_control: Any character whose General Category is defined to be "Other, Control", and which is not defined to be a format_effector.

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

Replace paragraph 14: [AI95-00285-01; AI95-00395-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, format_effector, and whose relative code position in its plane 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

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

by:

1 The characters in categories other_control, other_private_use, and other_surrogate are only allowed in comments.

2.2 Lexical Elements, Separators, and Delimiters

Replace paragraph 2: [AI95-00285-01]

compilation

lines

format_effector

by:

compilation

lines

format_effector

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:

The character whose code position is 16#09# (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; AI95-00395-01]

identifier ::=
   identifier_letter {[underline] letter_or_digit}

by:

identifier ::=
   identifier_start {identifier_start | identifier_extend}

Replace paragraph 3: [AI95-00285-01; AI95-00395-01]

letter_or_digit ::= identifier_letter | digit

by:

identifier_start ::=
     letter_uppercase
   | letter_lowercase
   | letter_titlecase
   | letter_modifier
   | letter_other
   | number_letter

identifier_extend ::=
     mark_non_spacing
   | mark_spacing_combining
   | number_decimal_digit
   | punctuation_connector
   | other_format

Replace paragraph 4: [AI95-00395-01]

An identifier shall not be a reserved word.

by:

other_format

identifier

Replace paragraph 5: [AI95-00285-01; AI95-00395-01]

identifier

Identifier

by:

identifier

The characters in category other_format are eliminated.

The remaining sequence of characters is converted to upper case.

Replace paragraph 6: [AI95-00285-01; AI95-00395-01]

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

by:

After applying these transformations, an identifier shall not be identical to a reserved word (in upper case).

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

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

2.4.1 Decimal Literals

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

exponent ::= E [+] numeral | E - numeral

the new paragraph:

digit ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

2.6 String Literals

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

NOTES
6 An end of line cannot appear in a string_literal.

the new paragraph:

7 No transformation is performed on the sequence of characters in a string_literal.

2.9 Reserved Words

In paragraph 2 replace: [AI95-00284-02; AI95-00395-01]

The following are the reserved words (ignoring upper/lower case distinctions):

by:

other_format

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

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

Replace paragraph 7: [AI95-00231-01]

null constraint

range_constraint

index_constraint

discriminant_constraint

by:

null constraint

range_constraint

index_constraint

discriminant_constraint

Replace paragraph 8: [AI95-00231-01; AI95-00415-01]

subtype

belong

by:

subtype

belong

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 7: [AI95-00230-01]

type_declaration

named

anonymous

identifier

by:

type_declaration

named

anonymous

identifier

Replace paragraph 8: [AI95-00230-01; 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

access_definition

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

Replace paragraph 1: [AI95-00416-01]

operates on a type T

predefined operation

primitive operations

by:

operates on a type T

predefined operation

primitive 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; AI95-00406-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 : [aliased] [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 1: [AI95-00401-01]

derived_type_definition

derived

parent type

by:

derived_type_definition

derived

Replace paragraph 2: [AI95-00251-01; AI95-00419-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] [limited] new parent_subtype_indication [[and interface_list] record_extension_part]

Replace paragraph 3: [AI95-00251-01; AI95-00401-01]

parent_

subtype_indication

by:

interface

_subtype_mark

interface_list

progenitor subtype

progenitor type

parent

_subtype_indication

the parent subtype

parent type

A derived type has one parent type and zero or more progenitor types.

Replace paragraph 5: [AI95-00401-01; AI95-00419-01]

record_extension_part

record extension

record_extension_part

by:

record_extension_part

record extension

record_extension_part

interface_list

limited

derived_type_definition

Replace paragraph 8: [AI95-00251-01; AI95-00401-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 a progenitor type also includes the derived type.

Replace paragraph 15: [AI95-00419-01]

The derived type is limited if and only if the parent type is limited.

by:

The derived type is limited if the parent is a limited type that is not an interface type, or if the reserved word limited appears.

Replace paragraph 17: [AI95-00401-01]

For each user-defined primitive subprogram (other than a user-defined equality operator -- see below) of the parent type that already exists at the place of the derived_type_definition, there exists a corresponding inherited primitive subprogram of the derived type with the same defining name. Primitive user-defined equality operators of the parent type are also inherited by the derived type, except when the derived type is a nonlimited record extension, and the inherited operator would have a profile that is type conformant with the profile of the corresponding predefined equality operator; in this case, the user-defined equality operator is not inherited, but is rather incorporated into the implementation of the predefined equality operator of the record extension (see 4.5.2).

by:

For each user-defined primitive subprogram (other than a user-defined equality operator -- see below) of the parent type or of a progenitor type that already exists at the place of the derived_type_definition, there exists a corresponding inherited primitive subprogram of the derived type with the same defining name. Primitive user-defined equality operators of the parent type are also inherited by the derived type, except when the derived type is a nonlimited record extension, and the inherited operator would have a profile that is type conformant with the profile of the corresponding predefined equality operator; in this case, the user-defined equality operator is not inherited, but is rather incorporated into the implementation of the predefined equality operator of the record extension (see 4.5.2).

Replace paragraph 18: [AI95-00401-01]

corresponding subtype

by:

corresponding subtype

Replace paragraph 22: [AI95-00401-01]

default_expression

by:

default_expression

Replace paragraph 23: [AI95-00251-01; AI95-00401-01]

derived_type_definition

by:

derived_type_definition

Replace paragraph 27: [AI95-00391-01; AI95-00401-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; AI95-00401-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 a progenitor type "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; AI95-00401-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 elementary 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, or the literal null) is ``universal'' in that it is acceptable where some particular type in the class is expected (see 8.6).

Replace paragraph 10: [AI95-00230-01; AI95-00351-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; AI95-00395-01]

character_literal

FFFE

FFFF

FFFE

FFFF

character_literal

by:

character_literal

graphic_character

character_literal

graphic_character

character_literal

graphic_character

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

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; AI95-00406-01]

component_definition ::= [aliased] subtype_indication

by:

component_definition ::=
   [aliased] subtype_indication
 | [aliased] 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

Replace paragraph 10: [AI95-00230-01; AI95-00402-01]

discriminant_specification

limited

by:

Default_expression

default_expression

known_discriminant_part

discriminant_specification

default_expression

limited

Delete paragraph 11: [AI95-00402-01]

Default_expression

default_expression

known_discriminant_part

Replace paragraph 27: [AI95-00230-01; AI95-00416-01]

access_definition

default_expression

discriminant_constraint

access_definition

by:

access_definition

default_expression

discriminant_constraint

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

default_expression

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 2: [AI95-00345-01]

tagged

tagged type

derived_type_definition

record_extension_part

by:

tagged

tagged type

derived_type_definition

record_extension_part

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; AI95-00405-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;

    type Tag_Array is array (Positive range <>) of Tag;

    function Interface_Ancestor_Tags (T : Tag) return Tag_Array;

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 10: [AI95-00400-01]

block_statement

by:

block_statement

The function Expanded_Name (respectively, Wide_Expanded_Name) returns the same sequence of graphic characters as that defined for Wide_Wide_Expanded_Name, if all the graphic characters are defined in Character (respectively, Wide_Character); otherwise, the sequence of characters is implementation defined, but no shorter than that returned by Wide_Wide_Expanded_Name for the same value of the argument.

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

attribute_reference

the new paragraph:

The string returned by the functions Expanded_Name, Wide_Expanded_Name, Wide_Wide_Expanded_Name, and External_Tag has lower bound 1.

Replace paragraph 12: [AI95-00260-02; AI95-00279-01; AI95-00344-01; AI95-00405-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 (see 13.14).

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.

The function Interface_Ancestor_Tags returns an array containing the tag of each interface ancestor type of the type whose tag is T, other than T itself. The lower bound of the returned array is 1, and the order of the returned tags is unspecified. Each tag appears in the result exactly once. If the type whose tag is T has no interface ancestors, a null array 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; AI95-00405-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, Interface_Ancestor_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.

Replace paragraph 30: [AI95-00260-02; AI95-00326-01]

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

by:

65 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:

When an extension is declared immediately within a body, primitive subprograms are inherited and are overridable, but new primitive subprograms cannot be added.

3.9.2 Dispatching Operations of Tagged Types

Replace paragraph 1: [AI95-00260-02]

dispatching operations

controlling

dispatches

dispatching call

by:

formal_abstract_subprogram_declaration

dispatching operations

controlling

dispatches

dispatching call

Replace paragraph 2: [AI95-00260-02; AI95-00416-01]

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

controlling access result

Replace paragraph 4: [AI95-00416-01]

The name or expression is statically tagged if it is of a specific tagged type and, if it is a call with a controlling result, it has at least one statically tagged controlling operand;

by:

The name or expression is statically tagged if it is of a specific tagged type and, if it is a call with a controlling result or controlling access result, it has at least one statically tagged controlling operand;

Replace paragraph 5: [AI95-00416-01]

The name or expression is dynamically tagged if it is of a class-wide type, or it is a call with a controlling result and at least one dynamically tagged controlling operand;

by:

The name or expression is dynamically tagged if it is of a class-wide type, or it is a call with a controlling result or controlling access result and at least one dynamically tagged controlling operand;

Replace paragraph 6: [AI95-00416-01]

The name or expression is tag indeterminate if it is a call with a controlling result, all of whose controlling operands (if any) are tag indeterminate.

by:

The name or expression is tag indeterminate if it is a call with a controlling result or controlling access result, all of whose controlling operands (if any) are tag indeterminate.

Replace paragraph 11: [AI95-00404-01; AI95-00416-01]

default_expression

by:

default_expression

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;

Replace paragraph 22: [AI95-00260-02]

73 This subclause covers calls on primitive subprograms of a tagged type. Rules for tagged type membership tests are described in 4.5.2. Controlling tag determination for an assignment_statement is described in 5.2).

by:

73 This subclause covers calls on dispatching subprograms of a tagged type. Rules for tagged type membership tests are described in 4.5.2. Controlling tag determination for an assignment_statement is described in 5.2).

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 is a function with a controlling access result, or if 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; AI95-00396-01]

An interface type is an abstract tagged type that provides a restricted form of multiple inheritance. A tagged, task, or protected type have one or more interface types as ancestors.

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, or if the partial view is untagged.

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.

Dynamic Semantics

interface_type_definition

NOTES
79 Nonlimited interface types have predefined nonabstract equality operators. These may be overridden with user-defined abstract equality operators. Such operators will then require an explicit overriding for any nonabstract descendant of the interface.

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; AI95-00404-01]

access_definition ::= access subtype_mark

by:

null_exclusion ::= not null
access_definition ::=
   [null_exclusion] access [constant] 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:

null

allocator

attribute_reference

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; AI95-00412-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

discriminant_part

incomplete_type_declaration

tagged

tagged incomplete view

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

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

subtype_mark

subtype_declaration

subtype_mark

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

Replace paragraph 7: [AI95-00326-01; AI95-00412-01]

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

by:

as the subtype_mark in the subtype_indication of a subtype_declaration; the subtype_indication shall not have a null_exclusion or a constraint;

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.

name

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 9: [AI95-00416-01]

The accessibility level of a view conversion is the same as that of the operand.

by:

The accessibility level of a view conversion, qualified expression, or parenthesized_expression, is the same as that of the operand.

Replace paragraph 10: [AI95-00318-02; AI95-00416-01]

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:

The accessibility level of the result of a function call that is used as a prefix of a name or as the actual parameter in a call is that of the immediately enclosing master. In other contexts, the accessibility level is that of the object being initialized from the function result.

Within a return statement, the accessibility level of the return object is that of the execution of the return statement. If the return statement completes normally by returning from the function, prior to leaving the function, the accessibility level of the return object changes to be a level determined by the point of call.

Replace paragraph 12: [AI95-00230-01; AI95-00416-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:

For an access discriminant, the accessibility level of its anonymous access type is determined as follows:

For an access discriminant whose value is determined by a discriminant_association in a subtype_indication, the accessibility level of the object or subprogram designated by the associated value (or library level if the value is null);

For an access discriminant of an object defined by an aggregate where the value of the discriminant is determined by a component_association in the aggregate, the accessibility level of the object or subprogram designated by the associated value (or library level if the value is null);

For an access discriminant of any other object with an unconstrained nominal subtype, the accessibility level of the object.

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

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.

Replace paragraph 14: [AI95-00416-01]

The accessibility level of an object created by an allocator is the same as that of the access type.

by:

The accessibility level of an object created by an allocator is the same as that of the access type, except for an allocator that defines the value of an access parameter or an access discriminant. For an access parameter, the accessibility level is that of the master immediately enclosing the call. For an access discriminant, the accessibility level is determined as follows:

for an allocator used to define the constraint in a subtype_declaration, the level of the subtype_declaration;

for an allocator used to define the constraint in a component_definition, the level of the enclosing type;

for an allocator used to define the discriminant of an object, the level of the object.

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 Access attribute for subprograms and parameters of an anonymous access-to-subprogram type may together be used to implement "downward closures" -- that is, to pass a more-nested subprogram as a parameter to a less-nested subprogram, as might be appropriate for an iterator abstaction or numerical integration. Downward closures can also 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 Names

Replace paragraph 11: [AI95-00415-01]

name

direct_name

character_literal

by:

name

direct_name

character_literal

4.1.3 Selected Components

Insert after paragraph 9: [AI95-00252-01; AI95-00407-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 type 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 declarative 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. This view is called a prefixed view of the subprogram, and the prefix of the selected_component (after any implicit dereference) is called the prefix of the prefixed view.

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

prefix

direct_name

block_statement

loop_statement

accept_statement

entry_body

prefix

selector_name

the new paragraph:

Legality Rules

For a subprogram whose first parameter is an access parameter, the prefix of any prefixed view shall denote an aliased view of an object.

in out

out

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

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

by:

X.Activate        -- a prefixed view of a procedure    (see 6.4)
                  -- assuming X has 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]

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]

record_aggregate

by:

record_aggregate

Replace paragraph 16: [AI95-00287-01]

record_component_association

by:

record_component_association

others

record_component_association

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

variant_part

the new paragraph:

record_component_association

default_expression

expression

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]

extension_aggregate

ancestor_part

expression

by:

extension_aggregate

ancestor_part

expression

Replace paragraph 5: [AI95-00306-01]

ancestor_part

subtype_mark

extension_aggregate

ancestor_part

by:

ancestor_part

subtype_mark

ancestor_part

expression

extension_aggregate

ancestor_part

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:

expression

array_component_association

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

Replace paragraph 30: [AI95-00231-01]

The tested type is not scalar, and the value of the @nt<simple_expression

satisfies any constraints of the named subtype, and, if the type of the @nt<simple_expression> is class-wide, the value has a tag that identifies a type covered by the tested type.>

by:

The tested type is not scalar, and the value of the @nt<simple_expression

satisfies any constraints of the named subtype, and:>

if the type of the simple_expression is class-wide, the value has a tag that identifies a type covered by the tested type;

if the tested type is an access type and the named subtype excludes null, the value of the simple_expression is not null.

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; AI95-00416-01]

allocator

by:

allocator

subtype_indication

qualified_expression

allocator

subtype_indication

qualified_expression

allocator

Replace paragraph 6: [AI95-00363-01]

allocator

by:

allocator

Replace paragraph 7: [AI95-00344-01; AI95-00416-01]

allocator

subtype_indication

qualified_expression

by:

allocator

subtype_indication

qualified_expression

allocator

qualified_expression

allocator

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 10: [AI95-00395-01]

operator_symbol

by:

operator_symbol

other_format

graphic_character

operator_symbol

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; AI95-00407-01]

a subprogram declared immediately within a protected_body.

by:

a subprogram declared immediately within a protected_body;

any prefixed view of a subprogram (see 4.1.3).

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

The default calling convention is entry for an entry.

the new paragraph:

The calling convention for an access parameter or access result 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 15: [AI95-00409-01]

type conformant

by:

type conformant

Replace paragraph 16: [AI95-00318-02; AI95-00409-01]

mode conformant

by:

mode conformant

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

discrete_subtype_definition

fully conformant

subtype_indication

range

subtype_mark

simple_expression

range

the new paragraph:

prefixed view profile

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

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

name

prefix

parameter_association

default_expression

parameter_association

subprogram_body

the new paragraph:

name

prefix

actual_parameter_part

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; AI95-00416-01]

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

return_subtype_indication

Static Semantics

extended_return_statement

return object

return_subtype_indication

Replace paragraph 6: [AI95-00318-02; AI95-00416-01]

return_statement

expression

by:

extended_return_statement

subtype_indication

access_definition

handled_sequence_of_statements

simple_return_statement

expression

return object

If the return object has any parts that are tasks, the activation of those tasks does not occur until after the function returns (see 9.2).

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; AI95-00402-01; AI95-00416-01]

The exception Program_Error is raised if this check fails.

by:

return_subtype_indication

Delete paragraph 21: [AI95-00318-02]

return_statement

Replace paragraph 22: [AI95-00318-02; AI95-00416-01]

return_statement

by:

return_statement

function_call

Implementation Permission

return_subtype_indication

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; AI95-00414-01]

pragma

Syntax

pragma

pragma

local_

name

local_

name

Legality Rules

local_

name

local_

name

return_statement

A procedure shall be non-returning if it overrides a dispatching non-returning procedure. 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 a renaming-as-body completes a non-returning procedure declaration, then the renamed procedure shall be non-returning.

Static Semantics

If a generic procedure is non-returning, then so are its instances. If a procedure declared within a generic unit is non-returning, then so are the corresponding copies of that procedure in instances.

Dynamic Semantics

If the body of a non-returning procedure completes normally, Program_Error is raised at the point of the call.

Erroneous Execution

If an imported non-returning procedure returns normally, execution is erroneous.

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; AI95-00419-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] [limited] new ancestor_subtype_indication [and interface_list] with private;

Replace paragraph 6: [AI95-00419-01]

limited

by:

limited

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

ancestor subtype

private_extension_declaration

ancestor_subtype_indication

the new paragraph:

limited

private_extension_declaration

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

If a private extension inherits known discriminants from the ancestor subtype, then the full view shall also inherit its discriminants from the ancestor subtype, and the parent subtype of the full view shall be constrained if and only if the ancestor subtype is constrained.

the new paragraph:

limited

full_type_declaration

private_extension_declaration

Replace paragraph 16: [AI95-00401-01]

discriminant_part

by:

discriminant_part

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

7 The ancestor type specified in a private_extension_declaration and the parent type specified in the corresponding declaration of a record extension given in the private part need not be the same — the parent type of the full view can be any descendant of the ancestor type. In this case, for a primitive subprogram that is inherited from the ancestor type and not overridden, the formal parameter names and default expressions (if any) come from the corresponding primitive subprogram of the specified ancestor type, while the body comes from the corresponding primitive subprogram of the parent type of the full view. See 3.9.2.

the new paragraph:

8 The progenitor types specified in a private_extension_declaration and the progenitor types specified in the corresponding declaration of a record extension given in the private part need not be the same — the only requirement is that the private extension must be descended from each interface from which the record extension is descended.

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 5: [AI95-00385-01]

The deferred and full constants shall have the same type;

by:

The deferred and full constants shall have the same type, or shall have statically matching anonymous access subtypes;

Replace paragraph 6: [AI95-00385-01]

If the subtype defined by the subtype_indication in the deferred declaration is constrained, then the subtype defined by the subtype_indication in the full declaration shall match it statically. On the other hand, if the subtype of the deferred constant is unconstrained, then the full declaration is still allowed to impose a constraint. The constant itself will be constrained, like all constants;

by:

If the deferred constant declaration includes a subtype_indication that defines a constrained subtype, then the subtype defined by the subtype_indication in the full declaration shall match it statically. On the other hand, if the subtype of the deferred constant is unconstrained, then the full declaration is still allowed to impose a constraint. The constant itself will be constrained, like all constants;

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.

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

limited

record_type_definition

by:

limited

record_type_definition

limited

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)

Replace paragraph 3: [AI95-00419-01]

limited

by:

limited

Replace paragraph 4: [AI95-00411-01; AI95-00419-01]

a type with the reserved word limited in its definition;

by:

a type with the reserved word limited, synchronized, task, or protected in its definition;

Delete paragraph 5: [AI95-00419-01]

a task or protected type;

Replace paragraph 6: [AI95-00419-01]

a composite type with a limited component.

the new paragraph:

a composite type with a limited component;

a derived type whose parent is limited and is not an interface.

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; AI95-00416-01]

left

task_body

block_statement

subprogram_body

entry_body

accept_statement

by:

left

package_body

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.2 Scope of Declarations

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

library_item

the new paragraph:

attribute_definition_clause

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; AI95-00412-01]

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. Where the declaration of the limited view of a package is visible, any name that denotes the package denotes the limited view, including those provided by a package renaming.

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; AI95-00408-01]

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

the new paragraph:

attribute_definition_clause

visible

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; AI95-00409-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;

access_definition

null_exclusion

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

object_name

subtype_mark

by:

object_name

subtype_mark

access_definition

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

The renamed entity shall be an object.

by:

access_definition

shall both be access-to-object types with statically matching designated subtypes and with both or neither being access-to-constant types; or

shall both be access-to-subprogram types with subtype conformant designated profiles.

Replace paragraph 5: [AI95-00363-01]

slice

by:

slice

Replace paragraph 6: [AI95-00230-01; AI95-00409-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

Insert after paragraph 3: [AI95-00217-06; AI95-00412-01]

The renamed entity shall be a package.

the new paragraph:

package_

name

package_renaming_declaration

with_clause

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

package_renaming_declaration

the new paragraph:

name

package_renaming_declaration

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 20: [AI95-00231-01]

expected type

expression

name

type resolution rules

by:

expected type

expression

name

type resolution rules

Replace paragraph 25: [AI95-00230-01; AI95-00231-01; AI95-00254-01; AI95-00409-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; or

when T is an anonymous access-to-subprogram type (see 3.10), to an access-to-subprogram type whose designated profile is type-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];

Replace paragraph 3: [AI95-00399-01]

single_task_declaration ::=
   task defining_identifier [is task_definition];

by:

single_task_declaration ::=
   task defining_identifier [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; AI95-00397-01; AI95-00401-01]

task_definition

task_item

the new paragraphs:

task_type_declaration

entry_declaration

task_type_declaration

implemented

Legality Rules

task_body

interface_subtype_mark

interface_list

task_type_declaration

the inherited subprogram is 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 prefixed view profile shall be subtype conformant with that of the task entry.

If neither applies, the inherited subprogram shall be a null procedure. In addition to the places where Legality Rules normally apply (see 12.3), these rules also apply in the private part of an instance of a generic unit.

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

9.2 Task Execution - Task Activation

Replace paragraph 2: [AI95-00416-01]

object_declaration

allocator

object_declaration

allocator

object_declaration

by:

allocator

object_declaration

generic_association

Replace paragraph 3: [AI95-00416-01]

object_declaration

handled_sequence_of_statements

exception_handler

_sequence

handled_sequence_of_statements

null_statement

by:

handled_sequence_of_statements

exception_handler

_sequence

handled_sequence_of_statements

null_statement

Replace paragraph 4: [AI95-00416-01]

allocator

by:

allocator

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

Replace paragraph 3: [AI95-00399-01]

single_protected_declaration ::=
   protected defining_identifier is protected_definition;

by:

single_protected_declaration ::=
   protected defining_identifier is
     [new interface_list with]
     protected_definition;

Delete paragraph 10: [AI95-00345-01]

Legality Rules

protected_body

Insert after paragraph 11: [AI95-00345-01; AI95-00397-01; AI95-00401-01]

protected_definition

protected_operation_declaration

protected_definition

known_discriminant_part

protected_element_declaration

private

the new paragraphs:

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 prefixed view profile shall be subtype conformant with that of the protected subprogram or entry.

out

in out

overriding_indicator

if the overriding_indicator is overriding, then the subprogram shall implement an inherited subprogram, at the point of the declaration;

if the overriding_indicator is not overriding, then the subprogram shall not implement any inherited subprogram (at any point).

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.5.2 Entries and Accept Statements

Replace paragraph 2: [AI95-00397-01]

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

by:

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

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

entry_declaration

the new paragraphs:

entry_declaration

overriding_indicator

if the overriding_indicator is overriding, then the entry shall implement an inherited subprogram, at the point of the declaration;

if the overriding_indicator is not overriding, then the operation shall not implement any inherited subprogram (at any point).

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

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; AI95-00412-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

library_unit_renaming_declaration

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.

Replace paragraph 10: [AI95-00403-01]

A generic body is preelaborable only if elaboration of a corresponding instance body would not perform any such actions, presuming that the actual for each formal private type (or extension) is a private type (or extension), and the actual for each formal subprogram is a user-defined subprogram.

by:

A generic body is preelaborable only if elaboration of a corresponding instance body would not perform any such actions, presuming that:

the actual for each formal private type (or extension) declared within the formal part of the generic unit is a private type (or extension) that does not have preelaborable initialization;

the actual for each formal type is nonstatic;

the actual for each formal object is nonstatic; and

the actual for each formal subprogram is a user-defined subprogram.

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; AI95-00400-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;
    function Wide_Exception_Name(Id : Exception_Id) return Wide_String;
    function Wide_Wide_Exception_Name(Id : Exception_Id) return Wide_Wide_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 5: [AI95-00400-01]

   function Exception_Identity(X : Exception_Occurrence)
                                return Exception_Id;
   function Exception_Name(X : Exception_Occurrence) return String;
       -- Same as Exception_Name(Exception_Identity(X)).
   function Exception_Information(X : Exception_Occurrence) return String;

by:

   function Exception_Identity(X : Exception_Occurrence)
                                return Exception_Id;
   function Exception_Name(X : Exception_Occurrence) return String;
       -- Same as Exception_Name(Exception_Identity(X)).
   function Wide_Exception_Name(X : Exception_Occurrence)
       return Wide_String;
       -- Same as Wide_Exception_Name(Exception_Identity(X)).
   function Wide_Wide_Exception_Name(X : Exception_Occurrence)
       return Wide_Wide_String;
       -- Same as Wide_Wide_Exception_Name(Exception_Identity(X)).
   function Exception_Information(X : Exception_Occurrence) return String;

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; AI95-00400-01; AI95-00417-01]

defining_identifier

block_statement

by:

block_statement

The functions Exception_Name (respectively, Wide_Exception_Name) return the same sequence of graphic characters as that defined for Wide_Wide_Exception_Name, if all the graphic characters are defined in Character (respectively, Wide_Character); otherwise, the sequence of characters is implementation defined, but no shorter than that returned by Wide_Wide_Exception_Name for the same value of the argument.

The string returned by the functions Exception_Name, Wide_Exception_Name, and Wide_Wide_Exception_Name has lower bound 1.

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; AI95-00419-01]

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

by:

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

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

ancestor subtype

subtype_mark

formal_derived_type_definition

with private

abstract

by:

ancestor subtype

subtype_mark

formal_derived_type_definition

with private

interface_list

abstract

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

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.

Replace paragraph 20: [AI95-00233-01]

discriminant_part

derived_type_definition

by:

discriminant_part

derived_type_definition

Replace paragraph 21: [AI95-00233-01; AI95-00401-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

For the purposes of defining the primitive operations of the formal type, each of the primitive operations of the actual type is considered to be a subprogram (with an intrinsic calling convention -- see 6.3.1) whose body consists of a dispatching call upon the corresponding operation of T, with its formal parameters as the actual parameters. If it is a function, the result of the dispatching call is returned.

If the corresponding operation of T has no controlling formal parameters, then the controlling tag value is determined by the context of the call, according to the rules for tag-indeterminate calls (see 3.9.2 and 5.2). In the case where the tag would be statically determined to be that of the formal type, the call raises Program_Error. If such a function is renamed, any call on the renaming raises Program_Error.

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; AI95-00401-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 progenitor 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-02; 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.

International Standard ISO/IEC 8652:1995

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

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

1.3 Definitions

Section 2: Lexical Elements

2.1 Character Set

2.2 Lexical Elements, Separators, and Delimiters

2.3 Identifiers

2.4.1 Decimal Literals

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 Names

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

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

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