Version 1.1 of ais/ai-00437.txt

Unformatted version of ais/ai-00437.txt version 1.1
Other versions for file ais/ai-00437.txt

!standard N (01)          05-10-17 AI95-00437/01
!standard N (03)
!standard N (08)
!standard N (12)
!standard N (13)
!standard N (15)
!standard N (20)
!standard N (21)
!standard N (23)
!standard N (24)
!standard N (25)
!standard N (30)
!standard N (36)
!standard N (38)
!standard N (42)
!class presentation 05-10-17
!status Amendment 200Y 05-10-17
!comment This AI is not yet approved, but is included in the Amendment.
!status work item 05-10-17
!status received 05-10-17
!priority High
!difficulty Easy
!subject Glossary updates for the Amendment
!summary
The Glossary is updated to add various new terms, and to improve the wording of others.
!question
Many of the definitions in the Glossary need updates for the Amendment.
!recommendation
(See summary.)
!wording
Add after N(1):
Abstract type. An abstract type is a tagged type intended for use as ancestor of other types, but which it not allowed to have objects of its own.
Add after N(3):
Ancestor. An ancestor of a type is the type itself or, in the case of a derived type, its parent type or one of its progenitor types or one of their ancestors.
Delete N(12).
Replace N(13) by:
Derived type. A derived type is a type defined in terms of one or more other types given in a derived type definition. The first type given is the parent type of the derived type, while any others are progenitor types. Each class containing the parent type or a progenitor type also contains the derived type. The derived type inherits properties such as components and primitive operations from the parent and progenitors. A type together with the types derived from it (directly or indirectly) form a derivation class.
Descendant. A descendant of a type is any type of which the given type is an ancestor type. Note that a type is a descendant of itself.
Replace N(15) by:
Discriminant. A discriminant is a parameter of a composite type. It can control, for example, the bounds of a component of the type if the component type is an array type. A discriminant of a task type can be used to pass data to a task of the type upon creation.
Add after N(20):
Incomplete type. An incomplete type is a incomplete view of a type whose complete view is given elsewhere. Incomplete types are valuable for defining recursive data structures.
Add after N(21):
Interface type. An interface type is a form of abstract tagged type which has no components or concrete operations except possibly null procedures. Interface types are used for composing other interfaces and tagged types and thereby provide multiple inheritance. Only an interface type can be used as a progenitor of a derived type.
Replace N(23) by:
limited type. 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.
Add after N(24):
Overriding operation. Overriding operation. An overriding operation is one that replaces an inherited operation. Operations may be marked explicitly as overriding or not overriding.
Add after N(25):
Parent. The parent type of a derived type is the first type mentioned in the definition of the derived type. The parent type can be any type, including an interface type.
Add after N(30):
Progenitor. A progenitor type of a derived type is one of the types mentioned in the definition of the derived type other than the first. A progenitor type is always an interface type.
Add after N(36):
Renaming. A renaming_declaration is a declaration that does not define a new entity, but instead defines a view of an existing entity (see 8.5).
Add after N(38):
Synchronized type. A synchronized type is a task type or a protected type.
Replace N(42) by:
View. A view consists of an identification of an entity (the entity of the view), plus view-specific characteristics that affect the use of the entity through that view (such as mode of access to an object, formal parameter names and defaults for a subprogram, or visibility to components of a type).
!discussion
(See summary.)
!corrigendum N(01)
Insert after the paragraph:
This Annex contains informal descriptions of some terms used in this International Standard. To find more formal definitions, look the term up in the index.
the new paragraph:
Abstract type.
An abstract type is a tagged type intended for use as ancestor of other types, but which it not allowed to have objects of its own.
!corrigendum N(03)
Insert after the paragraph:
Aliased.
An aliased view of an object is one that can be designated by an access value. Objects allocated by allocators are aliased. Objects can also be explicitly declared as aliased with the reserved word aliased. The Access attribute can be used to create an access value designating an aliased object.
the new paragraph:
Ancestor.
An ancestor of a type is the type itself or, in the case of a derived type, its parent type or one of its progenitor types or one of their ancestors.
!corrigendum N(12)
Delete the paragraph:
Definition.
All declarations contain a definition for a view of an entity. A view consists of an identification of the entity (the entity of the view), plus view-specific characteristics that affect the use of the entity through that view (such as mode of access to an object, formal parameter names and defaults for a subprogram, or visibility to components of a type). In most cases, a declaration also contains the definition for the entity itself (a renaming_declaration is an example of a declaration that does not define a new entity, but instead defines a view of an existing entity (see 8.5)).
!corrigendum N(13)
Replace the paragraph:
Derived type.
A derived type is a type defined in terms of another type, which is the parent type of the derived type. Each class containing the parent type also contains the derived type. The derived type inherits properties such as components and primitive operations from the parent. A type together with the types derived from it (directly or indirectly) form a derivation class.
by:
Derived type.
A derived type is a type defined in terms of one or more other types given in a derived type definition. The first type given is the parent type of the derived type, while any others are progenitor types. Each class containing the parent type or a progenitor type also contains the derived type. The derived type inherits properties such as components and primitive operations from the parent and progenitors. A type together with the types derived from it (directly or indirectly) form a derivation class.
Descendant.
A descendant of a type is any type of which the given type is an ancestor type. Note that a type is a descendant of itself.
!corrigendum N(15)
Replace the paragraph:
Discriminant.
A discriminant is a parameter of a composite type. It can control, for example, the bounds of a component of the type if that type is an array type. A discriminant of a task type can be used to pass data to a task of the type upon creation.
by:
Discriminant.
A discriminant is a parameter of a composite type. It can control, for example, the bounds of a component of the type if the component type is an array type. A discriminant of a task type can be used to pass data to a task of the type upon creation.
!corrigendum N(20)
Insert after the paragraph:
Generic unit.
A generic unit is a template for a (nongeneric) program unit; the template can be parameterized by objects, types, subprograms, and packages. An instance of a generic unit is created by a generic_instantiation. The rules of the language are enforced when a generic unit is compiled, using a generic contract model; additional checks are performed upon instantiation to verify the contract is met. That is, the declaration of a generic unit represents a contract between the body of the generic and instances of the generic. Generic units can be used to perform the role that macros sometimes play in other languages.
the new paragraph:
Incomplete type.
An incomplete type is a incomplete view of a type whose complete view is given elsewhere. Incomplete types are valuable for defining recursive data structures.
!corrigendum N(21)
Insert after the paragraph:
Integer type.
Integer types comprise the signed integer types and the modular types. A signed integer type has a base range that includes both positive and negative numbers, and has operations that may raise an exception when the result is outside the base range. A modular type has a base range whose lower bound is zero, and has operations with "wraparound" semantics. Modular types subsume what are called "unsigned types" in some other languages.
the new paragraph:
Interface type.
An interface type is a form of abstract tagged type which has no components or concrete operations except possibly null procedures. Interface types are used for composing other interfaces and tagged types and thereby provide multiple inheritance. Only an interface type can be used as a progenitor of a derived type.
!corrigendum N(23)
Replace the paragraph:
Limited type.
A limited type is (a view of) a type for the assignment operation is not allowed. A nonlimited type is a (view of a) type for which the assignment operation is allowed.
by:
Limited type.
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.
!corrigendum N(24)
Insert after the paragraph:
Object.
An object is either a constant or a variable. An object contains a value. An object is created by an object_declaration or by an allocator. A formal parameter is (a view of) an object. A subcomponent of an object is an object.
the new paragraph:
Overriding operation.
Overriding operation. An overriding operation is one that replaces an inherited operation. Operations may be marked explicitly as overriding or not overriding.
!corrigendum N(25)
Insert after the paragraph:
Package.
Packages are program units that allow the specification of groups of logically related entities. Typically, a package contains the declaration of a type (often a private type or private extension) along with the declarations of primitive subprograms of the type, which can be called from outside the package, while their inner workings remain hidden from outside users.
the new paragraph:
Parent.
The parent type of a derived type is the first type mentioned in the definition of the derived type. The parent type can be any type, including an interface type.
!corrigendum N(30)
Insert after the paragraph:
Private type.
A private type is a partial view of a type whose full view is hidden from its clients.
the new paragraph:
Progenitor.
A progenitor type of a derived type is one of the types mentioned in the definition of the derived type other than the first. A progenitor type is always an interface type.
!corrigendum N(36)
Insert after the paragraph:
Record type.
A record type is a composite type consisting of zero or more named components, possibly of different types.
the new paragraph:
Renaming.
A renaming_declaration is a declaration that does not define a new entity, but instead defines a view of an existing entity (see 8.5).
!corrigendum N(38)
Insert after the paragraph:
Subtype.
A subtype is a type together with a constraint, which constrains the values of the subtype to satisfy a certain condition. The values of a subtype are a subset of the values of its type.
the new paragraph:
Synchronized type.
A synchronized type is a task type or a protected type.
!corrigendum N(42)
Replace the paragraph:
View.
(See Definition.)
by:
View.
A view consists of an identification of an entity (the entity of the view), plus view-specific characteristics that affect the use of the entity through that view (such as mode of access to an object, formal parameter names and defaults for a subprogram, or visibility to components of a type).
!ACATS test
None needed.
!appendix

****************************************************************

Questions? Ask the ACAA Technical Agent