Digital PDFs

AA-EG29B-TE

May 1989

684 pages

Original

102MB

Document:	VAX Ada Language Reference Manual
Order Number:	AA-EG29B-TE
Revision:	0
Pages:	684
Original Filename:	AA-EG29B-TE_VAX_Ada_Language_Reference_Manual_May89.pdf

OCR Text

VAX Ada

Language Reference Manual

Order Number: AA—EG29B-TE

VAX Ada Language Reference Manual
Order Number: AA~-EG29B-TE

May 1989
This manual represents the Digital-supplemented text of ANSI/MIL-STD-1815A-1983,
Reference Manual for the Ada Programming Language. Textual insertions (printed
in color) describe the Digital interpretation of implementation-dependent language
features, as well as allowed implementation-specific additions to the language (pragmas,
attributes, input-output features, and so on).

Revision/Update Information:

This revised manual supersedes the VAX Ada
Language Reference Manual (Order No.
AA-EG29A-—TE)

Operating System and Version: VMS Version 5.0 and higher
Software Version:

VAX Ada Version 2.0

VA DAdTEaL
THIS PRODUCT CONFORMS
To ANSMLSTD-si SAAS
DETERMINED BY
AJPO
UNDERITS CURRENT
TESTING PROCEDURES

digital equipment corporation
maynard, massachusetts

First edition, February 1985
Revised, May 1989
The information in this document is subject to change without notice and should not
be construed as a commitment by Digital Equipment Corporation. Digital Equipment
Corporation assumes no responsibility for any errors that may appearin this document.
The software described in this document is furnished under a license and may be used
or copied only in accordance with the terms of such license.
No responsibility is assumed for the useor reliability of software on equipment that is
not supplied by Digital Equipment Corporation orits affiliated companies.
© Digital Equipment Corporation 1985, 1989.
All Rights Reserved.
Printed in U.S.A.
The postpaid Reader’s Comments forms at the end of this document request your
critical evaluation to assist in preparing future documentation.
Copyright 1985, 1989 Digital Equipment Corporation (insertions).
Copyright 1980, 1982, 1983 owned by the United States Government as represented
by the Under Secretary of Defense, Research and Engineering. All rights reserved.
Provided that notice of copyright is included on thefirst page, this document may be
copied in its entirety without alteration or as altered by (1) adding text that is clearly
marked as an insertion; (2) shading or highlighting existing text; (3) deleting examples.
Permission to publish other excerpts should be obtained from the Ada Joint Program
Office, OUSDRE(R&AT), the Pentagon, Washington, D.C. 20301, U.S.A.
The following are trademarks of Digital Equipment Corporation:
ALL—IN—1

EduSystem

DEC
DEC/CMS
DEC/MMS
DECnet
DECmate

IAS
MASSBUS
PDP
PDT
P/OS

ULTRIX
UNIBUS
VAX
VAXcluster
VMS

DECSYSTEM-—20
DECUS
DECwriter

Q—bus
Rainbow
RSTS

Work Processor
VAXELN

DECsystem—10

DIBOL

Professional

RSX

ASA
ZK3227

Contents
Preface .. 1... eee eee ee eee ee

New and Changed Features ...... 0... . cece eee eee teens

xix

Chapter 1

Introduction

1.1

Scope of the Standard ............. 0... 00 cee eee eee eee
1.1.1
Extent of the Standard ............. 0.0. eee eee ees
1.1.2
Conformity of an Implementation With the Standard........

1-1
1-2
1-3

1.2

Structure of the Standard .............. 0... 0.2.0... 0 cee eee

1-3

1.3

Design Goals and Sources ............ 00.00 cece eee eee {+4

1.4

Language Summary ............. 0. eee te eens

1-5

14a

VAX Ada ..... cc eee teens

1-9

1.5

Method of Description and Syntax Notation ...................

1-9

1.6

Classification of Errors... 2.0... . ee eee

1-11

Chapter 2

Lexical Elements

2.1

Character Set... 0.0... ee eens

2-1

2.2

Lexical Elements, Separators, and Delimiters ..................

2-3

2.3

Identifiers ©... 0... eee

2-5

2.4

Numeric LiteralS............0..... 0.0.00. ee eee eee eee eee

2-6

Decimal Literals... 2... ee ee
Based Literals .. 1... . ee ee

2-6
2-7

2.9

Character Literals........ 20... ... 2 eee ee eee

2-8

2.6

String Literals .. 10... . 0... nes

2-8

2.7

Comments ......... 0... cc eee eee ee eee

2-9

2.8

PragmaS .... 0... . ee ee eee eee

2-10

2.9

Reserved Words. ........... 0.0. ec eee tes

2-11

2.10

Allowable Replacements of Characters ..................000- |

2-12

Chapter 3

2.4.1
2.4.2

Declarations and Types

3.1

DeclarationS ......... 0... cc ee ee eee eee

3-1

3.2

“Objects and Named Numbers ................ 2.0000 ce ewes
3.2.1
Object Declarations ........ 0.0... ccc ee ee ne
3.2.2
Number Declarations ......... 0.2... eee ee es

3-3.
3—4
3-7

3.3

Types and Subtypes.......... 0... 0... cee ee ns
3.3.1
Type Declarations ........ 0... ccc eee eee eens
3.3.2
Subtype Declarations ...........0 00. eee eee eee_—
3.3.3
Classification of Operations ........... 0.002

3-8
3-9
3-11
a

3.4

Derived TypeS ........ 0.0... ce eee ee ee eee eee eee

3-13

3.5

Scalar TypeS .... 0... 0.0.0. ee eee eens
3.5.1
Enumeration Types ......... 0.00 eee eee ete ees
3.5.2
Character Types .... 0... .. cece ee ee et ens
3.5.3
Boolean TypeS ......... 0. cee ee ee ee eee
3.5.4
Integer Types .. 10... . ee ee ee te te ees
3.5.5
Operations of Discrete Types............. 22.00. aee
3.5.6
Real Types... .. ee ee ees
3.5.7
Floating Point Types..... 20... ... 0. cee ee ee ees
3.5.7a
Pragma LONG_FLOAT ............. 2c eee e eens
3.5.8
Operations of Floating Point Types ...................
3.5.9
Fixed Point Types ........... Lee eee eee
3.5.10
Operations of Fixed Point Types..............00000ee

3-17
3-18
3-19
3-20
3-20
3-22
3-25
3-27
3-31
3-32
3-34
3-38

3.6

Array TypeS ... 0... 0... . cc ee ee eee tee eee
3.6.1
Index Constraints and Discrete Ranges ................
3.6.2
Operations of Array Types....... ee eee eee
3.6.3
The Type String... . 2... eee ee ee ees

3—40
3-42
3-44
3—46

3.7

Record TypeS.... 1... 0... ce ee ee eee eee
3.7.1
DiscriminantS. 2.0... 0. ee ee ee eee
3.7.2. Discriminant Constraints ............. 2... eee ee
3.7.3
Variant Parts... 2... ee ee ns
3.7.4
Operations of Record Types .............0 00 ee ee aee

3—47
3—49
3-51
3-54
3-56

3.8

Access TypeS .......... 0... ccc eee ee eee eee teens
3.8.1
Incomplete Type Declarations ................-0-00%
3.8.2
Operations of Access Types ............00 ee eters

3-57
3-58
3-60

3.9

Declarative Parts ....... 0.0... . cee ee eee eee

3-61

Chapter 4

Names and Expressions

4.1

Names... 0... et ee eee nee
4.1.1
Indexed Components ........... 000 ee eee eee eens
4.1.2
SIICES 2 Le ee ee ee eee eee
4.1.3
Selected Components............ 0.0 eee eee ee ee ene
4.1.4
Attributes 2... ee et eee

4-1
4-2
4-3
4-5
4-8

4.2

Literals ©... een

4-9

4.3

Aggregates ............. cc eee es ec cueeeuueees
4.3.1
Record Aggregates ............ cc eee ees
4.3.2
Array AggregateS.... 2... ce ee ees

4—10
4—11
4-12

4.4

ExpreSSIONS... 1... 0... ce ee ee ee eee eee

4-15

4.5

Operators and Expression Evaluation .....................4.
4.5.1
Logical Operators and Short-circuit Control Forms.........
4.5.2
Relational Operators and Membership Tests.............
4.5.3
Binary Adding Operators .............00 0c cee ueeeee
4.5.4
Unary Adding Operators ............ 2.0. e eee eens
4.5.5
Multiplying Operators ......... 0.00 cece ee ee tee
4.5.6
Highest Precedence Operators..............00000 00.
4.5.7
Accuracy of Operations with Real Operands.............

4-17
4-18
4-20
4-22
4-24
4-24
4-28
4-29

4.6

Type Conversions ............ 0.0. eee eee eee ee ee eens

4-31

4.7

Qualified Expressions..........0.. 0.0.0.0: ee ee ee

4-34

4.8

Allocators ...... 0... 0... cee ee ees

4-36

Static Expressions and Static Subtypes......................

4-38

4.10

Universal Expressions .......... 000. eee eee

4—40

Chapter 5
5.1

Simple and Compound Statements—Sequences of Statements .....

5—1

5.2

Assignment Statement ............ 0.00. ce ee eens
5.2.1
Array Assignments ......... 2.0.0 cee eee ee ee eee

5-3
5-5

5.3

If Statements ......... 0... 00... eee eseee.

5-5

5.4

Case Statements ........... 0.0... . eee eee

5-6

3.5

Loop Statements ........... 0... 00. ee eee cea

5-9

5.6

Block Statements ........ 0... 0... cee ee ee ee

5-11

5.7

Exit Statements .......0. 0.2... 0.0. eee

5-12

5.8

Return Statements .........0.0.. 0.000 eee eee

5-13

5.9

Goto Statements ........ 20.0.0... cece eee

5-14

Chapter 6

Statements

Subprograms

6.1

Subprogram Declarations .............. 0.0 eee eens

6-1

6.2

Formal Parameter Modes ................ 2.2.2.0: cee eee eee

6-3

6.3

Subprogram Bodies ............. 0... cece eens
6.3.1
Conformance Rules ......... 0... eee eee eee eee
6.3.2
Inline Expansion of Subprograms ..............-..40%

6-5
6-7
6-8

6.4

Subprogram Calls ....... 0.0.0... cc eee ens
6.4.1
Parameter AssociationS.......... 0... 2... cee eee ees
6.4.2
Default Parameters ....... 0... cee ee ee es

6-9
6-11
6-12

6.5

Function Subprograms ........... 0... 0c cee eee ees

6-13

6.6

Parameter and Result Type Profile—Overloading of Subprograms...

6-14

6.7

Overloading of Operators ............ 0.0... cee ee ee ee

6-15

Chapter 7

Packages

7.1

Package Structure ................00 cee eeeeeeeaee Deas

7-1

7.2

Package Specifications and Declarations .....................

7-3

7.3

Package Bodies ............ 0... cee ee ee tees

7-4

7.4

Private Type and Deferred Constant Declarations ...............
7.4.1
Private Types .. 0... . ec ee eee ees
7.4.2
Operations of a Private Type .............0 00 eee7
7.4.3
Deferred Constants ..........0 0c cece eee eee eens
7.4.4
Limited Types ... 2... .... cee ee ee ee

7-6
7-7
7-8
7-11
7-12

7.5

Example of a Table Management Package ....................

7-14

7.6

Example of a Text Handling Package ....................006-

7-16

Chapter 8

Visibility Rules

8.1

Declarative Region ............ 0... cee ee eee

8—1

8.2

Scope of Declarations ............0 0.0... cee es

8-3

8.3

Visibility 2... ee ee eee ees

8-4

8.4

Use Clauses ........ 0... . ec ee ee eens

8-8

8.5

Renaming Declarations........... 0... 0.0.0 ccc eee eee

8—11

8.6

The Package Standard ............ 0... 00.

8-14

8.7

The Context of Overload Resolution ..................0220505

8-15

vil

Chapter 9
9.1

Task Specifications and Task Bodies .....................4.4.

9-2

9.2

Task Types and Task Objects ................ 000 e eee e eee

9-5

9.3

Task Execution—Task Activation .................. 0000 eae,

9-6

9.4

Task Dependence—Termination of Tasks ...................--.

9-8

9.5

Entries, Entry Calls, and Accept Statements...................

9-11

9.6

Delay Statements, Duration, and Time .....................2-.

9-14

9.7

Select Statements ............ 2.2.2... ee eee eens
9.7.1
Selective Waits .. 2... ee
9.7.2
Conditional Entry Calls ........... 0... eee eee eee
9.7.3
Timed Entry Calls ....... 0... 0... ce eee ens

9-17
9-17
9-20
9-21

9.8

Priorities .. 0... ee eee eee

9-22

9.8a

Time Slicing... 0... ce et ee eee teens

9-23

9.9

Task and Entry Attributes ........... 0... 2.0.0.0. 0c eee eee

9-24

9.10

Abort Statements ....... 0.0... 0... ee eee

9-25

9.11

Shared Variables ........... 0... . cee eee

9-27

9.12

Example of Tasking ............ 0.00 cece ee eee eee ee eee

9-30

9.12a

Task Entries and VMS Asynchronous System Traps .............

9-32

Chapter 10

vill

Tasks

Program Structure and Compilation Issues

10.1

Compilation Units—Library Units...........................
10.1.1
Context Clauses—With Clauses .................000-.
10.1.2
Examples of Compilation Units...............0200 00

10-1
10-4
10-6

10.2

Subunits of Compilation Units.............. 0.0.0... 000s
10.2.1
Examples of Subunits... ..... 2... 0... eee ee ee ees

10-8
10-9

10.3

Order of Compilation ........ 0.0... 0. cc es

10-12

10.4

The Program Library ............. 0... cece ees

10-15

10.5

Elaboration of Library Units ............. 0... 0.0. ee eee eee

10-15

10.6

Program Optimization.............. Lee ee eee

10-16

Chapter 11

Exceptions

11.1

Exception Declarations .............0. 0.0... eee eee eee

11-1

11.2

Exception Handlers ............ 0... cee eee ee ees

11-5

11.3

Raise Statements ...........0. 0.0. eee ee ee eee

11-6

11.4

Exception Handling .........-.0cccccccececcecsuceeseee.
11.4.1
Exceptions Raised During the Execution of Statements .....
11.4.2
Exceptions Raised During the Elaboration of Declarations ...

11-7
11-7
11-10

11.5

Exceptions Raised During Task Communication ................

11-12

11.6

Exceptions and Optimization. ............ 2... 0... cee eee eens

11-13

11.7

Suppressing Checks............. 0... ccc eee eee eee ees

11-15

Chapter 12

Generic Units

12.1

Generic Declarations ........... 0... 00. eee ene
12.1.1
Generic Formal Objects .......... 0... cee ee ee ees
12.1.2
Generic Formal Types .......... 0.0: eee eee eens
12.1.3
Generic Formal Subprograms ..............0000 02 ee

12-1
12-4
12-5
12-7

12.1a

Pragma INLINEGENERIC ............ 0.0.0... cc cc eee ee ee

12-8

12.15

Pragma SHARE_GENERIC................ 0.0... cc cee ee eee

12-10

12.2

Generic Bodies ........... 0... ccc eee ee eens

12-11

12.3

Generic Instantiation ........ 0... 0... cee ee ee eens
12.3.1
Matching Rules for Formal Objects ..............-000%
12.3.2
Matching Rules for Formal Private Types...............
12.3.3
Matching Rules for Formal Scalar Types ...............
12.3.4
Matching Rules for Formal Array Types................

12-12
12-16
12-16
12-17
12-18

12.3.5
12.3.6
12.4

Chapter 13

Matching Rules for Formal Access Types...............
Matching Rules for Formal Subprograms ...............

12-19
12-20

Example of a Generic Package .............. 0... e eens

12-21

Representation Clauses and Implementation-Dependent
Features

13.1

Representation Clauses ............. 00. ee ens

13-1

13.2

Length Clauses ........ 0... 0... ce ee ee ne

13-4

13.2a

Pragma TASK_STORAGE .............. 0.00.0 eee eee

13-8

13.26

Pragma MAIN_STORAGE .................. 0.000 cece eeae

13-9

13.3

Enumeration Representation Clauses......................0..

13-10

13.4

Record Representation Clauses.............. 00.000 e een neue

13-11

13.5

Address Clauses ............... 2... cee eee
13.5.1
Interrupts 2... eee

13-16
13-18

13.6

Change of Representation... .......... 0... eee eee eee

13-19

13.7

The Package System .........0 0... 0... cc ee ns
13.7.1
System-Dependent Named Numbers..................
13.7.2
Representation Attributes ....... 0... 0. ee ee eee
13.7.3
Representation Attributes of Real Types ...............

13-20
13-22
13-23
13-27

13.7a

VAX Ada Additions to the Package System ...................
13.7a.1
Properties of the Type ADDRESS....................
13.7a.2
Enumeration Type for Identifying Type Classes ...........
13.7a.3
Floating Point Type Declarations .................00.
13.7a.4
Asynchronous-System-Trap-Related Declarations .........
13.7a.5
Non-Ada Exception .......... 0.00. cece eee ee eee
13.7a.6
VAX Hardware-Oriented Types and Functions............
13.7a.7
Conventional Names for Unsigned Longwords ...........
13.7a.8
Global Symbol Values...............0.......00004
13.7a.9
VAX Processor and Device Register Operations ..........
13.7a.10 VAX Interlocked-Instruction Procedures ................

13-29
13-30
13-31
13-32
13-32
13-34
13-35
13-37
13-38
13-38
13-39

13.8

Machine Code Insertions

13-41

13.9

Interface to Other Languages ...............2 0... e eee eee

13-43

13.9a

VAX Ada Import and Export Pragmas .......................
13.9a.1
Importing and Exporting Subprograms .................
13.9a.1.1 Importing Subprograms................013.9a.1.2 Controlling the Passing Mechanisms for Parameters
and Function Results ....................
13.9a.1.3 Attribute for Optional Parameters in Imported VMS
Routines... ... ee ee ne
13.9a.1:4 Exporting Subprograms...................
13.9a.2
Importing and Exporting Objects................--06.
13.9a.2.1 Importing Objects....................06.
13.9a.2.2 Exporting Objects...................20813.9a.2.3 Importing and Exporting Objects with the Pragma
PSECT_OBJECT...............22-2-2008%
13.9a.3
Importing and Exporting Exceptions ..................
13.9a.3.1 Importing Exceptions .................0-.
13.9a.3.2 Exporting Exceptions ....................

13—46
13-48
13-48

13-64
13-65
13-66
13-67

Unchecked Programming ............... 0... ee eee eee eee
13.10.1
Unchecked Storage Deallocation ....................
13.10.2
Unchecked Type Conversions ..............0 ee eens

13-68
13-68
13-69

13.10

Chapter 14

13-53
13-56
13-58
13-61
13-62
13-63

Input-Output

14.1

External Files and File Objects ....................-00-0 0200

14-2

14.1a

Elements and Records ............. 0... ccc ee eens

14-6

14.1b

Specification of the FORM Parameter in VAX Ada...............

14-7

14.2

Sequential and Direct Files ........... 0... 0... eee ee eee
14.2.1
File Management... ....... 2... ce ween eee ee eee eee
14.2.2
Sequential Input-Output... ..... 0.0.0... eee ees
14.2.3
Specification of the Package Sequential_lO .............
14.2.4
Direct Input-Output... 2... 0... ee ee ee es
14.2.5
Specification of the Package Direct_LlIO ................

14-8
14-9
14-12
14-13
14-14
14-16

14.2a Relative and Indexed Files ..................-.-5-eee.

14-17

14.2a.1
14.2a.2
14.2a.3
14.2a.4
14.2a.5

File Management .......... 0... cee eee ee eee eee
Relative Input-Output ...............2. 002 eee eee
Specification of the Package RelativeIO...............
Indexed Input-Output ........... 0.0.0.0 cee eee eee
Specification of the Package Indexed_IO...............

14-20
14-21
14-23
14—25
14-28
xi

14.2b

Mixed-Type Input-Output............... 0.2... cece ee ee ees
14.2b.1
File Management... .......... 0.0... e eee eee eee,
14.2b.2
Item Input-Output... 2... 0.0.0.0... eee ee ee eee
14.2b.3
Sequential Mixed Input-Output .................000 0
14.2b.4
Specification of the Package Sequential_Mixed_IO ........
14.2b.5
Direct Mixed Input-Output ............ 0... eee eee
14.2b.6
Specification of the Package Direct_Mixed_IO ...........
14.2b.7
Relative Mixed Input-Output...................2008.%
14.2b.8
Specification of the Package Relative_Mixed_lIO..........
14.2b.9
Indexed Mixed Input-Output................00 ce eee
14.2b.10 Specification of the Package Indexed_Mixed_IO ..........

14—30
14-30
14-31
14-34
14—35
14-36
14-38
1440
14-43
14-45
1448

14.3

Text Input-Output ........0. 2... 0... ee ees
14.3.1
File Management............ 0.2 eee eee eee ees
14.3.2
Default Input and Output Files ......................
14.3.3
Specification of Line and Page Lengths................
14.3.4
Operations on Columns, Lines, and Pages..............
14.3.5
Get and Put Procedures .............. 0.0 eee nee
14.3.6
Input-Output of Characters and Strings ................
14.3.7
Input-Output for Integer Types .......-........-2200-14.3.8
Input-Output for Real Types...............0 00 eeeeee
14.3.9
Input-Output for Enumeration Types ................-.
14.3.10
Specification of the Package Text_LlIO .................

14-50
14-53
14-54
14-55
14—56
14—60
14-63
14-65
14-67
14-70
14-73

14.4

Exceptions in Input-Output .................0 02. eee ee eee

14-78

14.5

Specification of the Package IOExceptions...................

14-80

14.5a

Specification of the Package Aux_IOExceptions ...............

14-80

14.6

Low Level Input-Output ........... 0... 0. ee ees

14-81

14.7

Example of Input-Output............. 0.0.0... cee ee es

14-82

14.7a

Example of Additional VAX Ada Input-Output ..................

14-83

Annex A

Xil

Predefined Language Attributes

Annex B

Predefined Language Pragmas

Annex C

Predefined Language Environment

Appendix D

Glossary

Appendix E

Syntax Summary

Appendix F

Implementation-Dependent Characteristics

F.1

implementation-Dependent Pragmas ..................00000:5

F—1

F.2

Iimplementation-Dependent Attributes...................0000-

F-2

F.3

Specification of the Package System ................ 2c eeeee

F—3

F.4

Restrictions on Representation Clauses................050 00

F—7

F.5

Restrictions on Unchecked Type Conversions .................

F—7

F.6

Conventions for Implementation-Generated Names Denoting
implementation-Dependent Components in Record Representation
Clauses .. 0... ee ee eee ee tee eee ee aes

F—8

F.7

Interpretation of Expressions Appearing in Address Clauses.......

F-8

F.8

implementation-Dependent Characteristics of Input-Output
PackageS... 1.0... cc ee ee eee tence eee nes
F.8.1
Additional VAX Ada Input-Output Packages .............
F.8.2
Auxiliary Input-Output Exceptions ........... ee eee
F.8.3
Interpretation of theFORM Parameter.................
F.8.4
Implementation-Dependent Input-Output Error Conditions ....

F—9
F-9
F-9
F—-10
F—10

F.9

Other Implementation Characteristics ...................0008.
F.9.1
Definition of a Main Program ........... 0.0. ee ee eee
F.9.2
Values of Integer Attributes ...... eee ee eee tonnes
F.9.3
Values of Floating Point Attributes ................00.
F.9.4
Attributes of Type DURATION ........... ee ee ee

F—11
F—11
F—12
F-12
F-15
xiil

F.9.5

Appendix G

XIV

Implementation Limits ..............0 cc ee eee ees

Ada LanguageInterpretations

Preface
The entire text of the Reference Manualfor the Ada Programming Language
(ANSI/MIL-STD-1815A-1983, ISO/8652-1987) is reprinted in this manual.
In addition, this manual contains VAX Ada implementation information and
Digital-supplied supplementary examples andtext.
VAX Ada information appears in chapters 1, 2, 3, 4, 6, 9, 10, 11, 12, 18, and
14, Annexes A, B, and C, and Appendices D and F. Appendix G, added by

Digital for this edition of the VAX Ada Language Reference Manual, lists any
further interpretations of the standard Ada language that have been made
between the publication of the standard and the publication of this manual.
Footnotes referring to that appendix appear throughout this manual.

Intended Audience
This manual is intended for all programmers. who are designing or implementing applications using Ada. Its readers should understand the concepts
of programming in Ada and have somefamiliarity with the VMS operating
system.

Structure of This Document
This manual has fourteen chapters, three annexes, and four appendices.
¢

Chapter 1 contains a description of the Ada language standard, a language overview, a characterization of VAX Ada, and a description of the
syntax notation.

Chapter 2 provides detailed information on the lexical elements.

Chapter 3 describes Ada types and the rules for declaring constants,
variables, and named numbers. It gives the additional VAX Ada integer
and floating point types, and describes the VAX Ada pragma LONG_
FLOAT.
Chapter 4 gives the rules for names and expressions.
Chapter 5 gives the general rules that apply to all Ada statements, as
well as the syntax and semantics of most of those statements.
Chapter 6 gives the rules relating to subprograms, and notes the VAX
Ada implementation of the pragma INLINE.
Chapter 7 gives the rules relating to packages.
Chapter 8 gives the rules defining the scope of declarations, as well as
the rules defining thevisibility of identifiers at various points in the text
of a program.
Chapter 9 explains Ada tasks. It also notes the VAX Ada implementation
of the pragma SHAREDand describes the VAX Ada pragmas TIME_
SLICE and VOLATILE,as well as the VAX Ada pragma andattribute
AST_ENTRY.
Chapter 10 explains the overall structure of programs andthe facilities
for separate compilation.
Chapter 11 defines the facilities for dealing with errors or exceptions
that arise during program execution. It notes the VAX Ada treatment of
the pragma SUPPRESSand presents the VAX Ada pragma SUPPRESS_
ALL.
Chapter 12 explains the use of generic units and the process of instantiation. It also presents the VAX Ada pragmas INLINE_GENERIC and
SHARE_GENERIC.
Chapter 13 describes representation clauses and certain VAX Ada
features for systems programming. It describes the VAX Adainterpretations of the pragma PACK, theattributes SIZE, STORAGE_SIZE, and
SMALL, and presents the VAX Ada pragmas MAIN_STORAGE and

TASK_STORAGE.It also gives the VAX Ada additions to the package
SYSTEM, the VAX Ada interpretations of the representation attributes
ADDRESSand SIZE, and describes the VAX Ada representation attributes BIT and MACHINE_SIZE.Finally, chapter 13 presents the
VAX Adainterpretation of the pragma INTERFACEanddescribes the
VAX Ada pragmas IMPORT_FUNCTION, IMPORT_PROCEDURE,
IMPORT_VALUED_PROCEDURE, EXPORT_FUNCTION, EXPORT_
PROCEDURE, EXPORT_VALUED_PROCEDURE, IMPORT_OBJECT,
EXPORT_OBJECT, PSECT_OBJECT, IMPORT_EXCEPTION,and
EXPORT_EXCEPTION.
Xvi

Chapter 14 gives detailed information on all input and output packages.
In addition to the standard input-output packages (SEQUENTIAL_IO,
DIRECT_IO, and TEXT_IO), it presents the VAX Ada input-output
packages (RELATIVE_IO, INDEXED_IO, SEQUENTIAL_MIXED_IO,
RELATIVE_MIXED_IO, INDEXED_MIXED_IO, and DIRECT_MIXED_
IO) and the VAX Ada package AUX_IO_EXCEPTIONS.

Annex A summarizes the language attributes.

Annex B summarizes all pragmas and defines the pragmas IDENT,
LIST, OPTIMIZE, PAGE,and TITLE.

Annex C presents the specification of the package STANDARD.

Appendix D is a glossary of Ada terms. It is not part of the standard
definition of the Ada language.

Appendix E contains a syntax summary of the Ada language. It is not
part of the standard definition of the Ada language.

Appendix F lists the VAX Ada implementation-dependent characteristics.
It is not part of the standard definition of the Ada language.

Appendix G presents summaries of any Ada language interpretations
made or recommended between the publication of the Reference Manual
for the Ada Programming Language and the publication of this edition of
the VAX Ada Language Reference Manual.

Associated Documents
The following VAX Ada and VMS documents contain information of interest
to Ada programmers.
VAX Ada Documentation

Developing Ada Programs on VMS Systems shows howto compile, link, run,
and debug Ada programs. It also gives information on the VAX Ada program
library manager and its commands and suggests waysof structuring and
managing Ada program libraries.
The VAX Ada Run-Time Reference Manual gives system-related information.
It presents information on VAX Adastorage allocation and object representations, and explains how to use operating system components external to
the language (for example, system services). It also explains how to use Ada
features related to the operating system (such as multitasking and inputoutput), how to use code written in other VAX languages in an Ada program,
and how to improve the run-time performance of VAX Ada programs.

xvii

The VAX Ada Installation Guide gives step-by-step instructionsfor installing
the VAX Ada compiler and the VAX Ada HELPfile.
The VAX Ada and VAXELN Ada Technical Summary characterizes VAX
Ada and VAXELN Adaby answering a series of questions familiar to the
general Ada community and published as the Ada-Europe Guidelines for
Ada compiler specification andselection.
VMS Documentation

The Guide to Using VMS or VMS General User’s Manual gives information
useful to those who are new to the VMSoperating system. These manuals discuss using the terminal, creating and handlingfiles, editing and
formatting, and specifying device, directory, and file names.
Other pertinent reference material can be found in the Guide to VMS File
Applications, VMS Run-Time Library Routines Volume, and Introduction to
VMS System Routines.
For a complete list of all documents in the VMS documentation set, see the
VMS Master Index.

Conventions
This manual uses the conventions described in section 1.5. The Ada lan-

guage syntax is described using a simple variant of Backus-Naur-Form.
Colored print distinguishes VAX Adainsertions.

XVili

New and Changed Features
The following features have changed or have been added to VAX Adasince
Version 1.0:
The DEC Multinational Character Set is allowed in VAX Ada comments
(see 2.7).

The size of a fixed point type is now determinedby its delta and range,
and rounded up to an 8-, 16-, or 32-bit boundary (see 3.5.9 and 13.2).
The use of renamed subprogramsis allowed with the pragmas INLINE,
INTERFACE, IMPORT_FUNCTION, IMPORT_PROCEDURE,and
IMPORT_VALUED_PROCEDURE(see 6.3.2, 13.9, and 13.9a.1.1).
The definitions or interpretations of the pragmas VOLATILE and
INTERFACE have been amended(see 9.11 and 13.9).
Support has been added for the pragma SHARED(see 9.11).
A procedure declared with the pragma EXPORT_VALUED_

PROCEDUREthat has one formal out parameter that is of a
discrete type can be a main program (see 10.1 and Appendix F).

In response to Ada interpretation AI-00387, VAX Ada raises
CONSTRAINT_ERROR wherever the standard requires that
NUMERIC_ERRORberaised (see 11.1).
Support has been added for the pragma SUPPRESS(see 11.7).
Five new implementation defined pragmas—INLINE_GENERIC,
SHARE_GENERIC, MAIN_STORAGE, EXPORT_VALUED._

PROCEDURE, and IDENT—have been added (see 12.1a, 12.1b,
13.2b, 13.9a.1.4, and Annex B).

Record component values may be biased when a component clause
requires a very small component storage space (see 13.4).
Address clauses are allowed for objects (see 13.5).

XIX

The enumeration literal VAXELN has been addedto the type
SYSTEM.NAME (see 13.7). Also, an enumeration representation clause
has been addedfor this type (see 13.7 and Appendix F).
Two conversion operations—TO_UNSIGNED_LONGWORDand

TO_ADDRESS—havebeen addedto the package SYSTEM (see 13.7.6).
A function—IMPORT_VALUE—for importing link-time global symbols
has been addedto the package SYSTEM (see 13.7a.8).
A number of hardware-related types and operations have been
added to the package SYSTEM:the type ALIGNED_WORD,and the
operations READ_REGISTER, WRITE_REGISTER, MFPR, MTPR,
ADD_INTERLOCKED, CLEAR_INTERLOCKED, SET_INTERLOCKED,
INSQ_STATUS, REMQ_STATUS, INSQHI, INSQTI, REMQHI, and
REMQTI(see 13.7a.9 and 13.7a.10).
A FIRST_OPTIONAL_PARAMETERoption has been added to the
pragmas IMPORT_FUNCTION, IMPORT_PROCEDURE, and IMPORT_
VALUED_PROCEDURE(see 13.9a.1.1).
A RESULT_MECHANISMoption has been added to the pragma
IMPORT_FUNCTION(see 13.9a.1.1).
The VAX Ada defined enumeration type RELATION_TYPE has been
respecified to accommodate the use of descending keys with indexed
input-outputfiles (see 14.2a).
Length clauses have been addedfor the types STANDARD.CHARACTER
and STANDARD.DURATION(see AnnexC).
The maximum numberof characters in an identifier and a source line

has been increased to 255 (see Appendix F).

Chapter 1

Introduction

1.1

Ada is a programming language designed in accordance with requirements
defined by the United States Department of Defense: the so-called Steelman
requirements. Overall, these requirementscall for a language with
considerable expressive power covering a wide application domain. As a
result, the language includesfacilities offered by classical languages such
as Pascal as well as facilities often found only in specialized languages.
Thus the language is a modern algorithmic language with the usual control
structures, and with the ability to define types and subprograms. It also
serves the need for modularity, whereby data, types, and subprograms can
be packaged. It treats modularity in the physical sense as well, with a
facility to support separate compilation.

In addition to these aspects, the language covers real-time programming,
with facilities to model parallel tasks and to handle exceptions. It also
covers systems programming; this requires precise control over the
representation of data and access to system-dependent properties. Finally,
both application-level and machine-level input-output are defined.

Scope of the Standard
1

1-1

This standard specifies the form and meaning of program units written in
Ada. Its purpose is to promote the portability of Ada programsto a variety
of data processing systems.

Scope of the Standard

1.1

1.1.1

Extent of the Standard
This standard specifies:

(a)

The form of a program unit written in Ada.

(b)

The effect of translating and executing such a program unit.

(c)

The mannerin which program units may be combined to form Ada
programs.

(d)

The predefined program units that a conforming implementation must
supply.

(e)

The permissible variations within the standard, and the manner in
which they must be specified.

(f)

Those violations of the standard that a conforming implementation is
required to detect, and the effect of attempting to translate or execute
a program unit containing such violations.

(g)

Those violations of the standard that a conforming implementation is
not required to detect.

This standard does not specify:

(h)
(1)

The means whereby a program unit written in Ada is transformed into
object code executable by a processor.
The means whereby translation or execution of program units is

invoked and the executing units are controlled.

The size or speed of the object code, or the relative execution speed of
different language constructs.

(k)

The form or contents of any listings produced by implementations; in
particular, the form or contents of error or warning messages.

(I)

The effect of executing a program unit that contains any violation that
a conforming implementation is not required to detect.

(m) The size of a program or program unit that will exceed the capacity of
a particular conforming implementation.
Wherethis standard specifies that a program unit written in Ada has an
exact effect, this effect is the operational meaning of the program unit and
must be produced by all conforming implementations. Where this standard
specifies permissible variations in the effects of constituents of a program
unit written in Ada, the operational meaning of the program unit as a whole
is understood to be the range of possible effects that result from all these

1.1.1.

Extent of the Standard

1-2

variations, and a conforming implementation is allowed to produce any of
these possible effects. Examples of permissible variations are:
17

The represented values of fixed or floating numeric quantities, and the

The order of execution of statements in different parallel tasks, in the
absence of explicit synchronization.

1.1.2

1.2

results of operations upon them.

Conformity of an Implementation With the Standard
1

A conforming implementation is one that:!

(a)

Correctly translates and executes legal program units written in Ada,
provided that they are not so large as to exceed the capacity of the
implementation.

(b)

Rejects all program units that are so large as to exceed the capacity of
the implementation.

(c)

Rejects all program units that contain errors whose detection is
required by the standard.

(d)

Supplies all predefined program units required by the standard.

(e)

Contains no variations except where the standard permits.

(f)

Specifies all such permitted variations in the manner prescribed by the
standard.

Structure of the Standard
1

This reference manual contains fourteen chapters, three annexes, three
appendices, and an index.

Each chapter is divided into sections that have a commonstructure.

Examples are meant to illustrate the possible forms of the constructs
described. Notes are meant to emphasize consequencesof the rules
described in the section or elsewhere. References are meant to attract the
attention of readers to a term or phrase having a technical meaning defined
in anothersection.

Each section introduces its subject, gives any necessary syntax rules, and
describes the semantics of the corresponding language constructs. Examples
and notes, and then references, may appear at the end ofa section.

1 See also Appendix G, AI-00325.

1-3

Structure of the Standard

1.2

The standard definition of the Ada programming languageconsists of the
fourteen chapters and the three annexes, subject to the following restriction:
the material in each of the items listed below is informative, and not part of
the standard definition of the Ada programming language:

Section 1.3 Design goals and sources

Section 1.4 Language summary

The examples, notes, and references given at the end of each section

Each section whosetitle starts with the word “Example” or “Examples”

1.3 Design Goals and Sources
1

Ada was designed with three overriding concerns: program reliability and

The need for languages that promote reliability and simplify maintenance is
well established. Hence emphasis was placed on program readability over

maintenance, programming as a humanactivity, and efficiency.

ease of writing. For example, the rules of the language require that program

variables be explicitly declared and that their type be specified. Since
the type of a variable is invariant, compilers can ensure that operations
on variables are compatible with the properties intended for objects of
the type. Furthermore, error-prone notations have been avoided, and the
syntax of the language avoids the use of encoded forms in favor of more
English-like constructs. Finally, the language offers support for separate
compilation of program units in a way that facilitates program development
and maintenance, and which provides the same degree of checking between
units as within a unit.

1.3.

Concern for the human programmerwasalso stressed during the design.
Aboveall, an attempt was madeto keep the language as small as possible,
given the ambitious nature of the application domain. We have attempted
to cover this domain with a small numberof underlying concepts integrated
in a consistent and systematic way. Nevertheless we havetried to avoid
the pitfalls of excessive involution, and in the constant search for simpler
designs we havetried to provide language constructs that correspond
intuitively to what the users will normally expect.

Like many other humanactivities, the development of programs is becoming
ever more decentralized and distributed. Consequently, the ability to
assemble a program from independently produced software components
has been a central idea in this design. The concepts of packages, of private
types, and of generic units are directly related to this idea, which has
ramifications in many other aspects of the language.

Design Goals and Sources

1-4

No language can avoid the problem ofefficiency. Languages that require
over-elaborate compilers, or that lead to the inefficient use of storage
or execution time, force these inefficiencies on all machines and on all

programs. Every construct of the language was examined inthelight
of present implementation techniques. Any proposed construct whose
implementation was unclear or that required excessive machine resources
wasrejected.
Noneof the above design goals was considered as achievable after the fact.
The design goals drove the entire design process from the beginning.
A perpetual difficulty in language design is that one must both identify
the capabilities required by the application domain and design language
features that provide these capabilities. The difficulty existed in this
design, although to a lesser degree than usual because of the Steelman
requirements. These requirements often simplified the design process by
allowing it to concentrate on the design of a given system providing a well
defined set of capabilities, rather than on the definition of the capabilities

themselves.

Anothersignificant simplification of the design work resulted from earlier
experience acquired by several successful Pascal derivatives developed with
similar goals. These are the languages Euclid, Lis, Mesa, Modula, and Sue.

Manyof the key ideas and syntactic forms developed in these languages
have counterparts in Ada. Several existing languages such as Algol 68
and Simula, and also recent research languages such as Alphard and Clu,
influenced this language in several respects, although to a lesser degree
than did the Pascal family.

Finally, the evaluation reports received on an earlier formulation (the
Green language), and on alternative proposals (the Red, Blue, and Yellow
languages), the language reviews that took place at different stages of
this project, and the thousands of comments received from fifteen different
countries during the preliminary stages of the Ada design and during the
ANSI canvass,all had a significant impact on the standard definition of the
language.

1.4 Language Summary
1

An Ada program is composed of one or more program units. These program
units can be compiled separately. Program units may be subprograms
(which define executable algorithms), package units (which define collections
of entities), task units (which define parallel computations), or generic
units (which define parameterized forms of packages and subprograms).
Each unit normally consists of two parts: a specification, containing the
Language Summary

1.4

information that must be visible to other units, and a body, containing the

implementation details, which need not be visible to other units.
2

This distinction of the specification and body, and the ability to compile units
separately, allows a program to be designed, written, and tested as a set of
largely independent software components.

An Ada program will normally make use of a library of program units

Program Units

A subprogram is the basic unit for expressing an algorithm. There are
two kinds of subprograms: procedures and functions. A procedureis the
means of invoking a series of actions. For example, it may read data, update

of general utility. The language provides means whereby individual
organizations can construct their own libraries. The text of a separately
compiled program unit must namethe library units it requires.

variables, or produce some output. It may have parameters, to provide a

controlled means of passing information between the procedure and the
point ofcall.

A function is the meansof invoking the computation of a value. It is similar
to a procedure, but in addition will return a result.

A packageis the basic unit for defining a collection of logically related
entities. For example, a package can be used to define a common pool

of data and types, a collection of related subprograms, or a set of type
declarations and associated operations. Portions of a package can be hidden
from the user, thus allowing access only to the logical properties expressed
by the package specification.

1.4

A task unit is the basic unit for defining a task whose sequence of actions
may be executed in parallel with those of other tasks. Such tasks may
be implemented on multicomputers, multiprocessors, or with interleaved
execution on a single processor. A task unit may define either a single
executing task or a task type permitting the creation of any number of
similar tasks.

Declarations and Statements

The body of a program unit generally contains two parts: a declarative part,
which defines the logical entities to be used in the program unit, and a
sequence of statements, which defines the execution of the program unit.

The declarative part associates names with declared entities. For example,
a name may denote a type, a constant, a variable, or an exception. A
declarative part also introduces the names and parameters of other nested

Language Summary

1-6

subprograms, packages, task units, and generic units to be used in the
program unit.
The sequence of statements describes a sequence of actions that are to

be performed. The statements are executed in succession (unless an exit,
return, or goto statement, or the raising of an exception, causes execution to

continue from anotherplace).

An assignment statement changes the value of a variable. A procedurecall
invokes execution of a procedure after associating any actual parameters
provided at the call with the corresponding formal parameters.
Case statements andif statements allow the selection of an enclosed se-

quence of statements based on the value of an expression or on the value of
a condition.

The loop statement provides the basic iterative mechanism in the language.
A loop statement specifies that a sequence of statements is to be executed
repeatedly as directed by an iteration scheme, or until an exit statementis

encountered.

A block statement comprises a sequence of statements preceded by the
declaration of local entities used by the statements.
Certain statements are only applicable to tasks. A delay statement delays
the execution of a task for a specified duration. An entry call statement
is written as a procedure call statement; it specifies that the task issuing
the call is ready for a rendezvous with another task that has this entry.
The called task is ready to accept the entry call when its execution reaches
a corresponding accept statement, which specifies the actions then to be
performed. After completion of the rendezvous, both the calling task and the
task having the entry may continue their execution in parallel. One form
of the select statement allows a selective wait for one of several alternative
rendezvous. Other formsof the select statement allow conditional or timed
entry calls.
18

Execution of a program unit may encountererror situations in which normal
program execution cannot continue. For example, an arithmetic computation
may exceed the maximum allowed value of a number, or an attempt may
be madeto access an array component by using an incorrect index value.

To deal with such error situations, the statements of a program unit can be
textually followed by exception handlers that specify the actions to be taken
whentheerror situation arises. Exceptions can be raised explicitly by a
raise statement.

Language Summary

1.4

Data Types
20

Every object in the language has a type, which characterizes a set of values
and a set of applicable operations. The main classes of types are scalar types
(comprising enumeration and numeric types), composite types, access types,
and private types.
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 and CHARACTERare predefined.
Numeric types provide a means of performing exact or approximate numerical computations. Exact computations use integer types, which denote
sets of consecutive integers. Approximate computations use either fixed

point types, with absolute bounds on theerror, or floating point types, with
relative bounds on the error. The numeric types INTEGER, FLOAT, and

DURATIONare predefined.
23

Composite types allow definitions of structured objects with related components. The composite types in the language provide for 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. The array type
STRING is predefined.
A record may have special components called discriminants. Alternative
record structures that depend on the values of discriminants can be defined
within a record type.
Access types allow the construction of linked data structures created by
the evaluation of allocators. They allow several variables of an access type
to designate the same object, and components of one object to designate the
sameor other objects. Both the elements in such a linked data structure and
their relation to other elements can be altered during program execution.
Private types can be defined in a package that conceals structural details

that are externally irrelevant. Only the logically necessary properties

(including any discriminants) are madevisible to the users of such types.

1.4

The concept of a type is refined by the concept of a subtype, whereby a user
can constrain the set of allowed values of a type. Subtypes can be used to
define subrangesof scalar types, arrays with a limited set of index values,
and records andprivate types with particular discriminant values.

Language Summary

1-8

28
29

Other Facilities

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

Input-output is defined in the language by meansof predefined library
packages. Facilities are provided for input-output of values of user-defined
as well as of predefined types. Standard means of representing values in
display form are also provided.
Finally, the language provides a powerful means of parameterization of

program units, called generic program units. The generic parameters can be

types and subprograms(as well as objects) and so allow general algorithms
to be appliedto all types of a given class.

1.4a VAX Ada
All of the language elements specified by the ANSI or [SO standard
definition for the Ada language are provided by VAX Ada. In addition,
VAX Ada implements certain options and makescertain interpretations,
as permitted by the standard. Material has been inserted throughoutthis
manual to describe and explain these permitted options and interpretations.
The term “VAX Ada” and colored print are used to distinguish the VAX Ada
material.

1.5 Method of Description and Syntax Notation
1

The form of Ada program units is described by meansof a context-free
syntax together with context-dependent requirements expressed by narrative
rules.
|
The meaning of Ada program units is described by meansof narrative rules
defining both the effects of each construct and the composition rules for
constructs. This narrative employs technical terms whose precise definition
is given in the text (references to the section containing the definition of a
technical term appear at the end of each section that uses the term).

Method of Description and Syntax Notation

1.5

All other terms are in the English language and bear their natural meaning,
as defined in Webster’s Third New International Dictionary of the English
Language.

The context-free syntax of the language is described using a simple variant

(a)

of Backus-Naur-Form. In particular,

Lower case words, some containing embedded underlines, are used to
denote syntactic categories, for example:
addingoperator

Wheneverthe nameof a syntactic category is used apart from the
syntax rules themselves, spaces take the place of the underlines (thus:
adding operator).

(b)

Boldface words are used to denote reserved words, for example:
array

(ec)

Square brackets enclose optional items. Thus the two following rules
are equivalent.
returnstatement
returnstatement

(d)

::
::

return

return;

[expression];

return expression;

Braces enclose a repeated item. The item may appear zero or more
times; the repetitions occur from left to right as with an equivalent
left-recursive rule. Thus the two following rules are equivalent.
term ::= factor {multiplyingoperator factor}
term ::= factor | term multiplyingoperator factor

(e)

A vertical bar separates alternative items unless it occurs immediately
after an opening brace, in which case it stands foritself: _
letterordigit ::= letter | digit
component_association ::=
[choice {|

1.5

(f)

choice} =>]

expression

If the name of any syntactic category starts with an italicized part,
it is equivalent to the category name withoutthe italicized part. The
italicized part is intended to convey some semantic information. For
example type_name and task_nameare both equivalent to namealone.

Method of Description and Syntax Notation

1-10

Note:
12

The syntax rules describing structured constructs are presented in a form
that corresponds to the recommended paragraphing. For example, an if
statement is defined as
ifstatement ::=
if condition then

sequenceofstatements

{elsif condition then

sequenceofstatements}
[else
sequenceofstatements]

end if;

1.6

Different lines are used for parts of a syntax rule if the corresponding
parts of the construct described by the rule are intended to be on different
lines. Indentation in the rule is a recommendation for indentation of the
corresponding part of the construct. It is recommendedthat all indentations
be by multiples of a basic step of indentation (the numberof spaces for the
basic step is not defined). The preferred places for other line breaks are
after semicolons. On the other hand, if a complete construct can fit on one
line, this is also allowed in the recommendedparagraphing.

Classification of Errors
The languagedefinition classifies errors into several different categories:
(a)

Errors that must be detected at compilation time by every Ada
compiler.
These errors correspond to any violation of a rule given in this
reference manual, other than the violations that correspondto (b)
or (c) below. In particular, violation of any rule that uses the terms
must, allowed, legal, or illegal belongs to this category. Any program
that contains such an erroris not a legal Ada program; on the other
hand, the fact that a program is legal does not mean,perse, that the
program is free from other formsoferror.

(b)

Errors that must be detected at run time by the execution of an Ada
program.
The correspondingerror situations are associated with the names of
the predefined exceptions. Every Ada compiler is required to generate
code that raises the corresponding exception if such an error situation
arises during program execution. If an exception is certain to be raised

1-11

Classification of Errors

1.6

in every execution of a program, then compilers are allowed (although
not required) to report this fact at compilation time.
6

(c)

Erroneous execution.

The language rules specify certain rules to be obeyed by Ada programs,

although there is no requirement on Ada compilers to provide either
a compilation-time or a run-time detection of the violation of such
rules. The errors of this category are indicated by the use of the word
erroneous to qualify the execution of the corresponding constructs. The
effect of erroneous execution is unpredictable.
(d)

Incorrect order dependences.

Wheneverthe reference manual specifies that different parts of a given
construct are to be executed in some order that is not defined by the
language, this means that the implementation is allowed to execute
these parts in any given order, following the rules that result from that
given order, but not in parallel. Furthermore, the construct is incorrect

if execution of these parts in a different order would have a different
effect. Compilers are not required to provide either compilation-time
or run-time detection of incorrect order dependences. The foregoing
is expressed in terms of the process that is called execution; it applies
equally to the processes that are called evaluation and elaboration.
10

Ifacompiler is able to recognize at compilation time that a construct is
erroneous or contains an incorrect order dependence, then the compiler
is allowed to generate, in place of the code otherwise generated for the
construct, code that raises the predefined exception PROGRAM_ERROR.
Similarly, compilers are allowed to generate code that checks at run time

for erroneous constructs, for incorrect order dependences, or for both. The

predefined exception PROGRAM_ERRORisraised if such a checkfails.

1.6

Classification of Errors

1-12

Chapter 2

Lexical Elements

The text of a program consists of the texts of one or more compilations.
The text of a compilation is a sequence oflexical elements, each composed
of characters; the rules of composition are given in this chapter. Pragmas,
which provide certain information for the compiler, are also described in this
chapter.
References: character 2.1, compilation 10.1, lexical element 2.2, pragma 2.8

2.1

Character Set
1

The only characters allowed in the text of a program are the graphic
characters and format effectors. Each graphic character corresponds to
a unique code of the [SO seven-bit coded character set (SO standard
646), and is represented (visually) by a graphical symbol. Some graphic
characters are represented by different graphical symbols in alternative
national representations of the [SO character set. The description of the
language definition in this standard reference manual uses the ASCII
graphical symbols, the ANSI graphical representation of the [SO character
set. 1

graphiccharacter ::= basicgraphiccharacter
| lower_case_letter | other_specialcharacter

basicgraphiccharacter ::=
|

upper_caseletter
specialcharacter

|
|

digit
spacecharacter

basiccharacter ::=
basicgraphiccharacter

format_effector

1 See also Appendix G, AI-00339.
2-1

Character Set

2.1

The basic character set is sufficient for writing any program. The characters
included in each of the categories of basic graphic characters are defined as

follows:
(a)

uppercase lettersABCDEFGHIJKLMNOPQRSTUVW
XYZ

(b)

digits0123456789

(c)

special characters" #&’'()*+,-./:3;<=>_ |

(d)

the space character

Format effectors are the JSO (and ASCID) characters called horizontal
tabulation, vertical tabulation, carriage return, line feed, and form feed.

The characters included in each of the remaining categories of graphic
characters are defined as follows:
(e)

lower case lettersabcdefghijklmnopqrstuvwxyz

(f)

other special characters! $%? @[\ ]4°* {}~

Allowable replacements for the special characters vertical bar ( | ), sharp
(#), and quotation (") are defined in section 2.10.
Notes:
13

The JSO character that corresponds to the sharp graphical symbol in the
ASCII representation appears as a pound sterling symbol in the French,
German, and United Kingdom standard national representations. In any
case, the font design of graphical symbols (for example, whether they are in
italic or bold typeface) is not part of the ISO standard.
The meanings of the acronyms usedin this section are as follows: ANSI
stands for American National Standards Institute, ASCH stands for

American Standard Code for Information Interchange, and JSO stands
for International Organization for Standardization.
15

2.1

The following names are used whenreferring to special characters and other
special characters:
symbol

name

symbol

name

quotation

greater than

sharp

underline

ampersand

vertical bar

’

apostrophe

Character Set

exclamation mark

2-2

symbol

name

symbol

name

(

left parenthesis

dollar

)

right parenthesis

percent

star, multiply

question mark

plus

commercial at

;

comma

[

left square bracket

hyphen, minus

back-slash

dot, point, period

]

right square bracket

slash, divide

circumflex

colon

grave accent

;

semicolon

{

left brace

less than

}

right brace

equal

tilde

2.2 Lexical Elements, Separators, and Delimiters
1

The text of a program consists of the texts of one or more compilations. The
text of each compilation is a sequence of separate lexical elements. Each
lexical element is either a delimiter, an identifier (which may be a reserved
word), a numericliteral, a characterliteral, a string literal, or a comment.

The effect of a program dependsonly on the particular sequencesof lexical
elements that form its compilations, excluding the comments,if any.
In some cases an explicit separator is required to separate adjacent lexical
elements (namely, when without separation, interpretation as a single
lexical element is possible). A separator is any of a space character, a format
effector, or the end of a line. A space character is a separator except within a
comment, a string literal, or a space characterliteral. Format effectors other
than horizontal tabulation are always separators. Horizontal tabulation is a
separator except within a comment.
The end of a line is always a separator. The language does not define what
causes the end of a line. Howeverif, for a given implementation, the end of
a line is signified by one or more characters, then these characters must be
format effectors other than horizontal tabulation. In any case, a sequence of
one or more formateffectors other than horizontal tabulation must cause at
least one end ofline.

Lexical Elements, Separators, and Delimiters

2.2

In VAX Ada, source files are read using VAX Record Management Services

(RMS). Each RMSrecord is considered to contain at least one line, and

the end of a line is implied by the record boundary. If the record returned
by RMScontains a sequence of one or more format effectors other than
horizontal tabulation, the sequence is interpreted as the endof theline.
However, no characters, other than a space or a horizontal tabulation

character, are allowed in a record following a format effector sequenceif the
sequence occurs in a comment.
4

One or more separators are allowed between any two adjacent lexical
elements, before the first of each compilation, or after the last. At least
one separator is required between an identifier or a numeric literal and an
adjacent identifier or numericliteral.

A delimiter is either one of the following special characters (in the basic
character set)

&'()*+4+,-./:5<=> |
6

or one of the following compound delimiters each composed of two adjacent
special characters
=>

j%**

Each of the special characters listed for single character delimiters is a
single delimiter except if this character is used as a character of a compound
delimiter, or as a character of a comment, string literal, character literal, or

numeric literal.
8

The remaining formsof lexical element are described in other sections of
this chapter.
Notes:

Each lexical element must fit on oneline, since the end of a line is a separator. The quotation, sharp, and underline characters, likewise two adjacent
hyphens, are not delimiters, but may form part of other lexical elements.

The following names are used when referring to compound delimiters:
delimiter
=>

name
arrow
double dot

2.2

“RH

double star, exponentiate

assignment (pronounced: “becomes”)

Lexical Elements, Separators, and Delimiters

2-4

delimiter

name

inequality (pronounced: “not equal”)

greater than or equal

less than or equal

left label bracket

right label bracket

box

References: character literal 2.5, comment 2.7, compilation 10.1, format effector

2.1, identifier 2.3, numeric literal 2.4, reserved word 2.9, space character 2.1, special

character 2.1, string literal 2.6

2.3

Identifiers
1

Identifiers are used as names and also as reserved words.
identifier ::=
letter {[underline] letter_ordigit}
letter_ordigit ::= letter | digit
letter ::= uppercaseletter

lower_caseletter

All characters of an identifier are significant, including any underline
character inserted between a letter or digit and an adjacentletter or digit.
Identifiers differing only in the use of corresponding upper and lower case
letters are considered as the same.
Examples:
COUNT

get_symbol

Ethelyn

Marion

SNOBOL4

PageCount

STORENEXTITEM

Note:
No space is allowed within an identifier since a space is a separator.
References: digit 2.1, lower case letter 2.1, name 4.1, reserved word 2.9, separator

2.2, space character 2.1, upper case letter 2.1

2-5

Identifiers

2.3

2.4

Numeric Literals
1

There are two classes of numeric literals: real literals and integerliterals.

A real literal is a numericliteral that includes a point; an integer literal is
a numeric literal without a point. Real literals are the literals of the type
universal_real. Integer literals are the literals of the type universal_integer.

2
3

2.4.1

numericliteral ::= decimalliteral | basedliteral
References: literal 4.2, universal_integer type 3.5.4, universal_real type 3.5.6

Decimal Literals
1

A decimalliteral is a numeric literal expressed in the conventional decimal
notation (that is, the baseis implicitly ten).

decimalliteral ::= integer

[.integer]

integer

::= digit {[underline]

exponent

::= E

[+]

integer

[exponent]

digit}

| E - integer

An underline character inserted between adjacent digits of a decimal literal
does not affect the value of this numeric literal. The letter E of the exponent,
if any, can be written either in lower case or in upper case, with the same
meaning.

An exponent indicates the power of ten by which the value of the decimal
literal without the exponent is to be multiplied to obtain the value of the
decimalliteral with the exponent. An exponentfor an integerliteral must
not have a minussign.

Examples:
12

1E6

123456

integer literals

12.0

0.0

0.456

3.1415926

real literals

1.34E-12

1.0E+6

real literals with exponent

Notes:

2.4.1

Leading zeros are allowed. No spaceis allowed in a numeric literal, not even
between constituents of the exponent, since a space is a separator. A zero
exponent is allowed for an integerliteral.

References: digit 2.1, lower case letter 2.1, numeric literal 2.4, separator 2.2,
space character 2.1, upper case letter 2.1

Decimal Literals

2-6

2.4.2

Based Literals
1

A basedliteral is a numeric literal expressed in a form that specifies the
base explicitly. The base must be at least two and at most sixteen.
basedliteral ::=
base # based_integer

[.based_integer]

[exponent]

base ::= integer
based_integer ::=

extendeddigit {[{underline] extendeddigit}

extendeddigit

::= digit

letter

An underline character inserted between adjacent digits of a basedliteral
does not affect the value of this numeric literal. The base and the exponent,
if any, are in decimal notation. The only letters allowed as extended digits

are the letters A through F for the digits ten through fifteen. A letter in a
based literal (either an extended digit or the letter E of an exponent) can be
written either in lower case or in upper case, with the same meaning.

The conventional meaning of based notation is assumed; in particular the
value of each extended digit of a based literal must be less than the base.
An exponentindicates the power of the base by which the value of the based
literal without the exponent is to be multiplied to obtain the value of the
based literal with the exponent.2
Examples:
2#11111111#

LO#EF #

1L6#E#EL1

16O#F .FFFE+2

O16#0FF#

integer literals

of value 255

2#1110O000#

---

integer literals
of value 224

2#1.11111111111#E11

---

real literals

of value 4095.0

References: digit 2.1, exponent 2.4.1, letter 2.3, lower case letter 2.1, numeric

literal 2.4, upper case letter 2.1

2 See also Appendix G, AI-00008.

2—-/

Based Literals

2.4.2

2.5

Character Literals
A characterliteral is formed by enclosing one of the 95 graphic characters
(including the space) between two apostrophe characters. A character literal
has a value that belongs to a character type.
characterliteral ::= ’graphic_character’

Examples:
‘A!

‘re

References: character type 3.5.2, graphic character 2.1, literal 4.2, space
character 2.1

2.6 String Literals
1

A string literal is formed by a sequence of graphic characters (possibly none)
enclosed between two quotation characters used as string brackets.
stringliteral ::= "{graphic_character}"

A string literal has a value that is a sequence of character values corresponding to the graphic characters of the string literal apart from the
quotation characteritself. If a quotation character value is to be represented
in the sequence of character values, then a pair of adjacent quotation characters must be written at the corresponding place within thestringliteral.
(This meansthat a string literal that includes two adjacent quotation
characters is never interpreted as two adjacentstringliterals.)
The length of a string literal is the number of character values in the
sequence represented. (Each doubled quotation character is counted as a
single character.)
Examples:
"Message of the day:"
wom

man

ITE

"Characters such as $,

2.6

String Literals

an empty string literal

—_—

three

and

}

string

literals

length

are allowed in string literals"

2-8

Note:
6

A string literal must fit on one line since it is a lexical element (see 2.2).

Longer sequences of graphic character values can be obtained by catenation
of string literals. Similarly catenation of constants declared in the package
ASCII can be used to obtain sequences of character values that include
nongraphic character values (the so-called control characters). Examples of
such uses of catenation are given below:
"FIRST PART OF A SEQUENCE OF CHARACTERS
"THAT CONTINUES ON THE NEXT LINE"
"sequence that

includes the"

& ASCII.ACK &

&
"control character"

References: ascii predefined package C, catenation operation 4.5.3, character
value 3.5.2, constant 3.2.1, declaration 3.1, end of a line 2.2, graphic character 2.1,
lexical element 2.2

2./

Comments
1

A comment starts with two adjacent hyphens and extendsup to the end of

the line. A comment can appear on anyline of a program. The presence
or absence of comments has no influence on whether a program is legal or

illegal. Furthermore, comments do not influence the effect of a program;

their sole purposeis the enlightenment of the human reader.

Examples:
--

the last sentence above echoes the Algol 68 report

end;
--

processing of LINE is complete

a long comment may be split onto

two or more consecutive lines

~~----- ~~

the first two hyphens start the comment

Note:

Horizontal tabulation can be used in comments, after the double hyphen,
and is equivalent to one or more spaces (see 2.2).
The DEC Multinational Character Set can be used in VAX Ada comments.
This character set has 256 characters, each with a decimal equivalent
numberin the range 0 to 255. The first 128 characters in the set correspond
to the characters in the ASCI/ character set. The DEC Multinational

3 See also Appendix G, AI-00339.
4 See also Appendix G, AI-00339.
2-9

Comments

2.7

Character Set is documented in the Guide to Using VMS and in several
other manuals in the VMS documentation set; see the VMS Master Index for
more information.
References: end of a line 2.2, illegal 1.6, legal 1.6, space character 2.1

2.8 Pragmas
A pragmais used to convey information to the compiler. A pragma starts

with the reserved word pragma followed by an identifier that is the name
of the pragma.
pragma ::=
pragma identifier

[ (argumentassociation
{,

argument_association}) ];

argument_association ::=
|

[argumentidentifier =>]

[argument_identifier =>]

name

expression

Pragmasare only allowed at the following places in a program:
e

After a semicolon delimiter, but not within a formal part or discriminant

At any place where the syntax rules allow a construct defined by a
syntactic category whose name ends with “declaration”, “statement”,
“clause”, or “alternative”, or one of the syntactic categories variant and
exception handler; but not in place of such a construct. Also at any place
where a compilation unit would be allowed.

part.°

Additional restrictions exist for the placement of specific pragmas.
Some pragmas have arguments. Argument associations can be either
positional or named as for parameter associations of subprogram calls
(see 6.4). Named associations are, however, only possible if the argument
identifiers are defined. A namegiven in an argument mustbe either a name
visible at the place of the pragmaor an identifier specific to the pragma.
The pragmas defined by the language are described in Annex B: they must
be supported by every implementation. In addition, an implementation may
provide implementation-defined pragmas, which must then be described

in Appendix F. An implementation is not allowed to define pragmas whose
presence or absence influences the legality of the text outside such pragmas.

Consequently, the legality of a program does not depend on the presence or
absence of implementation-defined pragmas.

5 See also Appendix G, AI-00388.
2.8

Pragmas

2-10

A pragmathat is not language-defined has noeffect if its identifier is
not recognized by the (current) implementation. Furthermore, a pragma
(whether language-defined or implementation-defined) has no effect if its
placement or its arguments do not correspond to whatis allowed for the
pragma. The region of text over which a pragma has an effect depends on
the pragma®
Examples:
pragma LIST (OFF) ;
pragma OPTIMIZE (TIME) ;
pragma INLINE (SETMASK) ;
pragma SUPPRESS (RANGECHECK,

ON => INDEX) ;

Note:

It is recommended(but not required) that implementations issue warnings
for pragmasthat are not recognized and therefore ignored.
References: compilation unit 10.1, delimiter 2.2, discriminant part 3.7.1, exception
handler 11.2, expression 4.4, formal part 6.1, identifier 2.3, implementation-defined
pragma F, language-defined pragma B, legal 1.6, name 4.1, reserved word 2.9,
statement 5, static expression 4.9, variant 3.7.3, visibility 8.3

Categories ending with “declaration” comprise: basic declaration 3.1, compo-

nent declaration 3.7, entry declaration 9.5, generic parameter declaration 12.1

Categories ending with “clause” comprise: alignment clause 13.4, component

clause 13.4, context clause 10.1.1, representation clause 13.1, use clause 8.4, with
clause 10.1.1
15

2.9

Categories ending with “alternative” comprise: accept alternative 9.7.1, case

statement alternative 5.4, delay alternative 9.7.1, select alternative 9.7.1, selective
wait alternative 9.7.1, terminate alternative 9.7.1

Reserved Words
The identifiers listed below are called reserved words and are reserved for
special significance in the language. For readability of this manual, the
reserved words appear in lower case boldface.
abort

declare

generic

select

abs

delay

goto

separate

6 See also Appendix G, AI-00186, AI-00242, AI-00306, AI-00322, and AI-00371.

2-11

Reserved Words

2.9

delta

access

digits

all

and

others

array
at

else
elsif

limited

end

loop

task
package

terminate

pragma

then

private

type

procedure

begin

entry

raise

body

exception

range

exit

mod

subtype

out

use

record

when

rem

while

new

renames

with

case

for

not

return

constant

function

null

reverse

xor

A reserved word must not be used as a declared identifier.
Notes:

Reserved words differing only in the use of corresponding upper and lower
case letters are considered as the same (see 2.3). In some attributes the
identifier that appears after the apostrophe is identical to some reserved
word.

References: attribute 4.1.4, declaration 3.1, identifier 2.3, lower case letter 2.1,
upper case letter 2.1

2.10 Allowable Replacements of Characters

2.10

The following replacements are allowed for the vertical bar, sharp, and
quotation basic characters:

A vertical bar character ( | ) can be replaced by an exclamation mark
(!) where used as a delimiter.

The sharp characters (#) of a based literal can be replaced by colons(:)
provided that the replacement is done for both occurrences.

Allowable Replacements of Characters

2-12

The quotation characters (") used as string brackets at both endsof a
string literal can be replaced by percent characters (%) provided that
the enclosed sequence of characters contains no quotation character, and
provided that both string brackets are replaced. Any percent character
within the sequence of characters must then be doubled and each such
doubled percent character is interpreted as a single percent character
value.

These replacements do not change the meaning of the program.’
Notes:

It is recommendedthat use of the replacements for the vertical bar, sharp,

and quotation characters be restricted to cases where the corresponding
graphical symbols are not available. Note that the vertical bar appears as
a broken bar on some equipment; replacement is not recommendedin this
case.

The rules given for identifiers and numeric literals are such that lower
case and uppercaseletters can be used indifferently; these lexical elements
can thus be written using only characters of the basic character set. If
a string literal of the predefined type STRING contains characters that
are not in the basic character set, the same sequence of character values
can be obtained by catenating string literals that contain only characters
of the basic character set with suitable character constants declared in

the predefined package ASCII. Thusthe string literal "AB$CD" could be

replaced by "AB" & ASCITI.DOLLAR & "CD". Similarly, the string literal
"ABcd" with lower case letters could be replaced by "AB" & ASCII.LC_C &
ASCII.LC_D.
8

References: ascii predefined package C, based literal 2.4.2, basic character 2.1,
catenation operation 4.5.3, character value 3.5.2, delimiter 2.2, graphic character
2.1, graphical symbol 2.1, identifier 2.3, lexical element 2.2, lower case letter 2.1,
numeric literal 2.4, string bracket 2.6, string literal 2.6, upper case letter 2.1

7 See also Appendix G, AI-00350.

2-13

Allowable Replacements of Characters

2.10

Chapter 3

Declarations and Types
This chapter describes the types in the language andthe rules for declaring
constants, variables, and named numbers.

3.1

Declarations
The language defines several kinds of entities that are declared, either
explicitly or implicitly, by declarations. Such an entity can be a numeric

literal, an object, a discriminant, a record component, a loop parameter, an

exception, a type, a subtype, a subprogram, a package, a task unit, a generic
unit, a single entry, an entry family, a formal parameter (of a subprogram,
entry, or generic subprogram), a generic formal parameter, a namedblock or
loop, a labeled statement, or an operation (in particular, an attribute or an
enumeration literal; see 3.3.3).
There are several forms of declaration. A basic declaration is a form of
declaration defined as follows.
basicdeclaration ::=
object_declaration
|

typedeclaration

| numberdeclaration
|

subtypedeclaration

subprogram_declaration | packagedeclaration

| task_declaration
| exception_declaration
| renamingdeclaration

| genericdeclaration
| generic_instantiation
| deferred_constant_declaration

Certain forms of declaration always occur (explicitly) as part of a basic
declaration; these forms are discriminant specifications, component
declarations, entry declarations, parameter specifications, generic parameter
declarations, and enumeration literal specifications. A loop parameter
specification is a form of declaration that occurs only in certain forms of loop
statement.

Declarations

3.1

The remaining forms of declaration are implicit: the nameof a block, the
nameof a loop, and a statement label are implicitly declared. Certain
operations are implicitly declared (see 3.3.3).

For each form of declaration the language rules define a certain region of
text called the scope of the declaration (see 8.2). Several forms of declaration
associate an identifier with a declared entity. Within its scope, and only
there, there are places where it is possible to use the identifier to refer to
the associated declared entity; these places are defined by thevisibility rules
(see 8.3). At such places the identifier is said to be a nameoftheentity (its
simple name); the nameis said to denote the associated entity.

Certain forms of enumeration literal specification associate a character
literal with the corresponding declared entity. Certain forms of declaration
associate an operator symbol or some other notation with an explicitly or
implicitly declared operation.

The process by which a declaration achievesits effect is called the elaboration of the declaration; this process happens during program execution.

After its elaboration, a declaration is said to be elaborated. Prior to

Object, number, type, and subtype declarations are described here. The
remaining basic declarations are described in later chapters.

the completion of its elaboration (including before the elaboration), the
declaration is not yet elaborated. The elaboration of any declaration has
always at least the effect of achieving this change of state (from not yet
elaborated to elaborated). The phrase “the elaboration has no other effect”
is used in this manual wheneverthis changeof state is the only effect of
elaboration for some form of declaration. An elaboration process is also
defined for declarative parts, declarative items, and compilation units (see
3.9 and 10.5).

Note:

3.1

11.

The syntax rules use the term identifier for the first occurrence of an identifier in some form of declaration; the term simple nameis used for any
occurrence of an identifier that already denotes some declared entity.

References: attribute 4.1.4, block name 5.6, block statement 5.6, characterliteral
2.5, component declaration 3.7, declarative item 3.9, declarative part 3.9, deferred
constant declaration 7.4, discriminant specification 3.7.1, elaboration 3.9, entry
declaration 9.5, enumeration literal specification 3.5.1, exception declaration 11.1,
generic declaration 12.1, generic instantiation 12.3, generic parameter declaration
12.1, identifier 2.3, label 5.1, loop name 5.5, loop parameter specification 5.5, loop
statement 5.5, name 4.1, number declaration 3.2.2, numeric literal 2.4, object declaration 3.2.1, operation 3.3, operator symbol 6.1, package declaration 7.1, parameter
specification 6.1, record component 3.7, renaming declaration 8.5, representation

Declarations

3-2

clause 13.1, scope 8.2, simple name 4.1, subprogram body 6.3, subprogram declaration 6.1, subtype declaration 3.3.2, task declaration 9.1, type declaration 3.3.1,
visibility 8.3

3.2 Objects and Named Numbers
1

An object is an entity that contains (has) a value of a given type. An object
is one of the following:
e

an object declared by an object declaration or by a single task
declaration,

a formal parameter of a subprogram, entry, or generic subprogram,

a generic formal object,

a loop parameter,

an object designated by a value of an access type,

acomponentora slice of another object.

A numberdeclaration is a special form of object declaration that associates
an identifier with a value of type universal_integer or universal_real:
object_declaration ::=
identifierlist : [constant] subtypeindication
| identifierlist :

[:= expression];

[constant] constrainedarraydefinition
[:= expression];

numberdeclaration ::

identifierlist : constant := universal_static_expression;

identifierlist ::=

identifier {, identifier}

An object declaration is called a single object declaration if its identifier
list has a single identifier; it is called a multiple object declaration if the
identifier list has two or more identifiers. A multiple object declaration
is equivalent to a sequence of the corresponding numberof single object
declarations. For each identifier of the list, the equivalent sequence has a
single object declaration formed bythis identifier, followed by a colon and by
whatever appears at the right of the colon in the multiple object declaration;
the equivalent sequenceis in the sameorderasthe identifierlist.

1 See also Appendix G, AI-00263.
3-3

Objects and Named Numbers

3.2

A similar equivalence applies also for the identifier lists of number

declarations, component declarations, discriminant specifications, parameter

specifications, generic parameter declarations, exception declarations, and
deferred constant declarations.
12

In the remainder of this reference manual, explanations are given for

declarations with a single identifier; the corresponding explanations for
declarations with several identifiers follow from the equivalence stated

above.

Example:
--

the multiple object declaration

JOHN,

--JOHN
PAUL
14

PAUL

PERSONNAME

:= new PERSON(SEX => M);

see 3.8.1

is equivalent to the two single object declarations
in the order given
:
:

PERSONNAME
PERSONNAME

new PERSON (SEX => M);
new PERSON (SEX => M);

References: access type 3.8, constrained array definition 3.6, component 3.3,

declaration 3.1, deferred constant declaration 7.4, designate 3.8, discriminant
specification 3.7.1, entry 9.5, exception declaration 11.1, expression 4.4, formal

parameter 6.1, generic formal object 12.1.1, generic parameter declaration 12.1,

generic unit 12, generic subprogram 12.1, identifier 2.3, loop parameter 5.5, numeric

type 3.5, parameter specification 6.1, scope 8.2, simple name 4.1, single task

declaration 9.1, slice 4.1.2, static expression 4.9, subprogram 6, subtype indication

3.3.2, type 3.3, universal_integer type 3.5.4, universal_real type 3.5.6

3.2.1.

Object Declarations
1

An object declaration declares an object whose type is given either by

a subtype indication or by a constrained array definition. If the object

declaration includes the assignment compounddelimiter followed by an
expression, the expression specifies an initial value for the declared object;
the type of the expression must be that of the object.
The declared object is a constant if the reserved word constant appears

in the object declaration; the declaration must then include an explicit
initialization. The value of a constant cannot be modified after initialization.
Formal parameters of mode in of subprograms and entries, and generic
formal parameters of mode in, are also constants; a loop parameter is
a constant within the corresponding loop; a subcomponentorslice of a
constant is a constant.

3.2.1.

Object Declarations

3—4

An object that is not a constant is called a variable (in particular, the object
declared by an object declaration that does not include the reserved word

constantis a variable). The only ways to change the value of a variable
are either directly by an assignment, or indirectly when the variable is

updated (see 6.2) by a procedure or entry call statement (this action can be

performed either on the variable itself, on a subcomponentof the variable,
or on another variable that has the given variable as subcomponent).

The elaboration of an object declaration proceeds as follows:
(a)

The subtype indication or the constrained array definition is first
elaborated. This establishes the subtype of the object.

(b)

Ifthe object declaration includes an explicit initialization, the initial value is obtained by evaluating the corresponding expression.
Otherwise any implicit initial values for the object or for its subcomponents are evaluated.

(c)

The object is created.

(d)

Anyinitial value (whether explicit or implicit) is assigned to the object
or to the corresponding subcomponent.

Implicit initial values are defined for objects declared by object declarations,
and for components of such objects, in the following cases:

If the type of an object is an access type, the implicit initial value is the

null value of the access type.

Ifthe type of an object is a task type, the implicit initial (and only) value
designates a corresponding task.

Ifthe type of an object is a type with discriminants and the subtype of
the object is constrained, the implicit initial (and only) value of each
discriminant is defined by the subtype of the object.

If the type of an object is a composite type, the implicit initial value

of each component that has a default expression is obtained by eval-

uation of this expression, unless the component is a discriminant of a
constrained object (the previous case).
14

In the case of a componentthatis itself a composite object and whose value

is defined neither by an explicit initialization nor by a default expression,
any implicit initial values for components of the composite object are defined
by the samerules as for a declared object.

Object Declarations

3.2.1

The steps (a) to (d) are performedin the order indicated. For step (b), if the
default expression for a discriminant is evaluated, then this evaluation is
performed before that of default expressions for subcomponents that depend
on discriminants, and also before that of default expressions that include
the nameof the discriminant. Apart from the previousrule, the evaluation
of default expressions is performed in someorderthat is not defined by the
language.

The initialization of an object (the declared object or one of its subcomponents) checks that the initial value belongs to the subtype of the object;

for an array object declared by an object declaration, an implicit subtype
conversion is first applied as for an assignment statement, unless the object
is a constant whose subtype is an unconstrained array type. The exception

CONSTRAINT_ERRORisraised if this check fails.”

The value of a scalar variable is undefined after elaboration of the corresponding object declaration unless an initial value is assigned to the variable
by an initialization (explicitly or implicitly).
If the operand of a type conversion or qualified expression is a variable that
has scalar subcomponents with undefined values, then the values of the
corresponding subcomponents of the result are undefined. The execution
of a program is erroneousif it attempts to evaluate a scalar variable with
an undefined value. Similarly, the execution of a program is erroneousif
it attempts to apply a predefined operator to a variable that has a scalar
subcomponent with an undefined value.”
Examples of variable declarations:
COUNT,

SIZE

SUM

SORTED

INTEGER;

INTEGER range 0 ..

: BOOLEAN := FALSE;

10000 := 0;

COLORTABLE : array(l ..N) of COLOR;
OPTION
: BITVECTOR(1 .. 10) := (others => TRUE);
20

Examples of constant declarations:
LIMIT

: constant INTEGER := 10000;

LOW_LIMIT : constant INTEGER := LIMIT/10;

TOLERANCE : constant REAL := DISPERSION (1.15);

2 See also Appendix G, AI-00308.
3 See also Appendix G, AI-00155, AI-00356, AI-00374, and AI-00426.

3.2.1

Object Declarations

3-6

Note:
21

The expression initializing a constant object need not be a static expression
(see 4.9). In the above examples, LIMIT and LOW_LIMITareinitialized
with static expressions, but TOLERANCEis not if DISPERSIONis a
user-defined function.

3.2.2

References: access type 3.8, assignment 5.2, assignment compound delimiter 5.2,
component 3.3, composite type 3.3, constrained array definition 3.6, constrained
subtype 3.3, constraint_error exception 11.1, conversion 4.6, declaration 3.1, default
expression for a discriminant 3.7, default initial value for an access type 3.8, depend
on a discriminant 3.7.1, designate 3.8, discriminant 3.3, elaboration 3.9, entry 9.5,
evaluation 4.5, expression 4.4, formal parameter 6.1, generic formal parameter 12.1
12.3, generic unit 12, in some order 1.6, limited type 7.4.4, mode in 6.1, package
7, predefined operator 4.5, primary 4.4, private type 7.4, qualified expression 4.7,
reserved word 2.9, scalar type 3.5, slice 4.1.2, subcomponent 3.3, subprogram 6,
subtype 3.3, subtype indication 3.3.2, task 9, task type 9.2, type 3.3, visible part 7.2

Number Declarations
A numberdeclaration is a special form of constant declaration. The type

of the static expression given for the initialization of a number declaration
must be either the type wniversal_integer or the type universal_real. The
constant declared by a numberdeclaration is called a named number and
has the type of the static expression.
Note:

The rules concerning expressions of a universal type are explained in section
4.10. It is a consequence of these rules that if every primary contained in
the expression is of the type universal_integer, then the named numberis
also of this type. Similarly, if every primary is of the type universal_real,
then the named numberis also of this type.
Examples of numberdeclarations:
PI
TWOPI
MAX

POWER_16
ONE,

UN,

> constant := 3.1415926536; -- a real number
> constant := 2.0*PI;
-- a real number
: constant := 500;
-- an integer number
EINS

> constant := 2**16;
:

constant

:= 1;

-- the integer 65536

-- three different
--

names

for

References: identifier 2.3, primary 4.4, static expression 4.9, type 3.3, universal_
integer type 3.5.4, universal_real type 3.5.6, universal type 4.10

3-/

Number Declarations

3.2.2

3.3 Types and Subtypes
1

A type is characterized by a set of values and a set of operations.

There exist several classes of types. Scalar types are integer types, real
types, and types defined by enumeration of their values; values of these

types have no components. Array and record types are composite; a value
of a composite type consists of component values. An access type is a type
whose values provide access to objects. Private types are types for which the
set of possible values is well defined, but not directly available to the users
of such types. Finally, there are task types. (Private types are described in

chapter 7, task types are described in chapter 9, the other classes of types
are described in this chapter.)
3

Certain record and private types have special componentscalled discriminants whose values distinguish alternative forms of values of one of these

types. If a private type has discriminants, they are known to users of the

type. Hence a private type is only known by its name, its discriminantsif
any, and by the corresponding set of operations.

The set of possible values for an object of a given type can be subjected to a
condition that is called a constraint (the case where the constraint imposes
no restriction is also included); a value is said to satisfy a constraint if it
satisfies the corresponding condition. A subtype is a type together with a
constraint; a value is said to belong to a subtype of a given typeif it belongs
to the type and satisfies the constraint; the given typeis called the base
type of the subtype. A type is a subtype of itself; such a subtypeis said to

be unconstrained: it corresponds to a condition that imposes norestriction.
The base type of a typeis the typeitself.
5

The set of operations defined for a subtype of a given type includes the
operations that are defined for the type; however the assignment operation
to a variable having a given subtype only assigns values that belong to
the subtype. Additional operations, such as qualification (in a qualified
expression), are implicitly defined by a subtype declaration.
Certain types have default initial values defined for objects of the type;

certain other types have default expressions defined for someorall of their

components. Certain operations of types and subtypes are called attributes;
these operations are denoted by the form of name described in section 4.1.4.
7

3.3

The term subcomponent is used in this manual in place of the term
componentto indicate either a component, or a component of another
component or subcomponent. Where other subcomponents are excluded, the
term componentis used instead.

Types and Subtypes

3-8

A given type must not have a subcomponent whosetypeis the given type

itself.

The nameofa class of types is used in this manual as a qualifier for objects
and values that have a type of the class considered. For example, the term

“array object” is used for an object whose type is an array type; similarly,
the term “access value” is used for a value of an access type.
Note:

The set of values of a subtype is a subset of the values of the base type. This

subset need not be a proper subset; it can be an empty subset.

References: access type 3.8, array type 3.6, assignment 5.2, attribute 4.1.4,
component of an array 3.6, component of a record 3.7, discriminant constraint 3.7.2,
enumeration type 3.5.1, integer type 3.5.4, object 3.2.1, private type 7.4, qualified
expression 4.7, real type 3.5.6, record type 3.7, subtype declaration 3.3.2, task type
9.1, type declaration 3.3.1

3.3.1

Type Declarations
A type declaration declares a type.
typedeclaration ::= full_typedeclaration
| incompletetypedeclaration | privatetypedeclaration
fulltypedeclaration ::=
type identifier [discriminantpart]

is typedefinition;

typedefinition ::=
|

enumerationtypedefinition | integertypedefinition
realtypedefinition

| recordtypedefinition

derivedtypedefinition

arraytypedefinition

| accesstypedefinition

The elaboration of a full type declaration consists of the elaboration of the
discriminantpart, if any (except in the case of the full type declaration for
an incomplete or private type declaration), and of the elaboration of the type
definition.
The types created by the elaboration of distinct type definitions are distinct
types. Moreover, the elaboration of the type definition for a numeric or
derived type creates both a base type and a subtype of the base type; the
same holds for a constrained array definition (one of the two forms of array
type definition).

Type Declarations

3.3.1

The simple name declared by a full type declaration denotes the declared

Examples of type definitions:

type, unless the type declaration declares both a base type and a subtype of
the base type, in which case the simple name denotes the subtype, and the
base type is anonymous. A typeis said to be anonymousif it has no simple
name. For explanatory purposes, this reference manual sometimesrefers
to an anonymoustype by a pseudo-name, written in italics, and uses such
pseudo-names at places where the syntax normally requires an identifier.

(WHITE, RED,
range 1

array(l1

YELLOW, GREEN, BLUE, BROWN, BLACK)

10)

of INTEGER

Examples of type declarations:
type COLOR

is (WHITE, RED, YELLOW, GREEN, BLUE, BROWN, BLACK) ;

type COLUMN is range 1
type TABLE is array(l

..
..

72;
10) of INTEGER;

Notes:
8

Two type definitions always define two distinct types, even if they are
textually identical. Thus, the array type definitions given in the declarations
of A and B below define distinct types.
A

array(1l

B : array(1

10)

of BOOLEAN;

If A and B are declared by a multiple object declaration as below, their types
are nevertheless different, since the multiple object declaration is equivalent
to the above two single object declarations.
A,

3.3.1.

array(1l

10)

of BOOLEAN;

Incomplete type declarations are used for the definition of recursive and
mutually dependent types (see 3.8.1). Private type declarations are used in
package specifications and in generic parameter declarations (see 7.4 and
12.1).

References: access type definition 3.8, array type definition 3.6, base type 3.3,
constrained array definition 3.6, constrained subtype 3.3, declaration 3.1, derived
type 3.4, derived type definition 3.4, discriminant part 3.7.1, elaboration 3.9,
enumeration type definition 3.5.1, identifier 2.3, incomplete type declaration 3.8.1,
integer type definition 3.5.4, multiple object declaration 3.2, numeric type 3.5,
private type declaration 7.4, real type definition 3.5.6, reserved word 2.9, type 3.3

Type Declarations

3-10

3.3.2

Subtype Declarations
1

A subtype declaration declares a subtype.
subtypedeclaration ::=

subtype identifier is subtypeindication;

subtypeindication ::=

typemark [constraint]

typemark

::= typename

constraint

subtypename

::=

rangeconstraint
| floatingpoint_constraint
| fixed_pointconstraint | indexconstraint
|

discriminantconstraint

A type mark denotes a type or a subtype. If a type mark is the name
of a type, the type mark denotes this type and also the corresponding
unconstrained subtype. The base type of a type markis, by definition, the
base type of the type or subtype denoted by the type mark.
|
A subtype indication defines a subtype of the base type of the type mark.
If an index constraint appears after a type mark in a subtype indication,
the type mark must not already impose an index constraint. Likewise
for a discriminant constraint, the type mark must not already impose a
discriminant constraint.
The elaboration of a subtype declaration consists of the elaboration of
the subtype indication. The elaboration of a subtype indication creates a
subtype. If the subtype indication does not include a constraint, the subtype
is the same as that denoted by the type mark. The elaboration of a subtype
indication that includes a constraint proceeds as follows:
(a)

The constraintis first elaborated.

(b)

Accheck is then madethat the constraint is compatible with the type or
subtype denoted by the type mark.

The condition imposed by a constraint is the condition obtained after
elaboration of the constraint. (The rules of constraint elaboration are
such that the expressions and ranges of constraints are evaluated by the
elaboration of these constraints.) The rules defining compatibility are given
for each form of constraint in the appropriate section. These rules are such
that if a constraint is compatible with a subtype, then the condition imposed
by the constraint cannot contradict any condition already imposed by the
subtype on its values. The exception CONSTRAINT_ERRORisraised if any

check of compatibility fails.

4 See also Appendix G, AI-00449.

3-11

Subtype Declarations

3.3.2

Examples of subtype declarations:
subtype RAINBOW
subtype REDBLUE

subtype INT

subtype
subtype
subtype
subtype

SMALLINT
UPTOK
SQUARE
MALE

is COLOR range RED .. BLUE;
is RAINBOW;

see 3.3.1

is INTEGER range -10 .. 10;
is COLUMN range 1 .. K;
-is MATRIX(1 .. 10, 1... 10); -is PERSON (SEX => M);
--

see 3.3.1
see 3.6
see 3.8

is INTEGER;

Note:
11
12

A subtype declaration does not define a new type.
References: base type 3.3, compatibility of discriminant constraints 3.7.2, compatibility of fixed point constraints 3.5.9, compatibility of floating point constraints
3.5.7, compatibility of index constraints 3.6.1, compatibility of range constraints 3.5,

constraint_error exception 11.1, declaration 3.1, discriminant 3.3, discriminant con-

straint 3.7.2, elaboration 3.9, evaluation 4.5, expression 4.4, floating point constraint
3.5.7, fixed point constraint 3.5.9, index constraint 3.6.1, range constraint 3.5,
reserved word 2.9, subtype 3.3, type 3.3, type name 3.3.1, unconstrained subtype 3.3

3.3.3

Classification of Operations
1

The set of operations of a type includes the explicitly declared subprograms that have a parameter or result of the type; such subprogramsare
necessarily declared after the type declaration?
The remaining operations are each implicitly declared for a given type
declaration, immediately after the type definition. These implicitly declared
operations comprise the basic operations, the predefined operators (see
4.5), and enumeration literals. In the case of a derived type declaration,
the implicitly declared operations include any derived subprograms. The

operations implicitly declared for a given type declaration occur after the
type declaration and before the next explicit declaration, if any. The implicit
declarations of derived subprogramsoccurlast.
A basic operation is an operation that is inherent in one of the following:
e

An assignment (in assignment statements and initializations), an

A selected component, an indexed component, ora slice.

A qualification (in qualified expressions), an explicit type conversion,
or an implicit type conversion of a value of type universal_integer or
universal_real to the corresponding value of another numeric type.

allocator, a membership test, or a short-circuit control form.

5 See also Appendix G, AI-00330.
3.3.3

Classification of Operations

3-12

A numeric literal (for a universal type), the literal null (for an access
type), a string literal, an aggregate, or an attribute.

For every type or subtype T, the following attribute is defined:
T’ BASE

The base type of T. This attribute is allowed only as the
prefix of the name of another attribute: for example,
T’ BASE’ FIRST.

Note:
10

Each literal is an operation whose evaluation yields the corresponding value
(see 4.2). Likewise, an aggregate is an operation whose evaluation yields
a value of a composite type (see 4.3). Some operations of a type operate on
values of the type, for example, predefined operators and certain subprograms and attributes. The evaluation of some operations of a type returns a
value of the type, for example, literals and certain functions, attributes, and

predefined operators. Assignmentis an operation that operates on an object
and a value. The evaluation of the operation corresponding to a selected
component, an indexed component, or a slice, yields the object or value
denoted by this form of name.

References: aggregate 4.3, allocator 4.8, assignment 5.2, attribute 4.1.4, character
literal 2.5, composite type 3.3, conversion 4.6, derived subprogram 3.4, enumeration
literal 3.5.1, formal parameter 6.1, function 6.5, indexed component 4.1.1, initial
value 3.2.1, literal 4.2, membership test 4.5 4.5.2, null literal 3.8, numericliteral
2.4, numeric type 3.5, object 3.2.1, 6.1, predefined operator 4.5, qualified expression
4,7, selected component 4.1.3, short-circuit control form 4.5 4.5.1, slice 4.1.2, string
literal 2.6, subprogram 6, subtype 3.3, type 3.3, type declaration 3.3.1, universal_
integer type 3.5.4, universal_real type 3.5.6, universal type 4.10

3.4 Derived Types
1

A derived type definition defines a new (base) type whose characteristics are
derived from those of a parent type; the new typeis called a derived type. A
derived type definition further defines a derived subtype, which is a subtype
of the derived type.
derivedtypedefinition ::= new subtypeindication

The subtype indication that occurs after the reserved word new defines
the parent subtype. The parent type is the base type of the parent subtype.
If a constraint exists for the parent subtype, a similar constraint exists
for the derived subtype; the only difference is that for a range constraint,
and likewise for a floating or fixed point constraint that includes a range
constraint, the value of each boundis replaced by the corresponding value
3-13

Derived Types

3.4

of the derived type. The characteristics of the derived type are defined as
follows:
4

The derived type belongs to the sameclass of types as the parent type.
The set of possible values for the derived type is a copy of the set of
possible values for the parent type. If the parent type is composite,
then the same components exist for the derived type, and the subtype of
corresponding components is the same.
For each basic operation of the parent type, there is a corresponding
basic operation of the derived type. Explicit type conversion of a value
of the parent type into the corresponding value of the derived type is
allowed and vice versa as explained in section 4.6.
For each enumeration literal or predefined operator of the parent type
there is a corresponding operation for the derived type.
If the parent type is a task type, then for each entry of the parent type
there is a corresponding entry for the derived type.
If a default expression exists for a component of an object having
the parent type, then the same default expression is used for the
corresponding component of an object having the derived type.
If the parent type is an access type, then the parent and the derived type
share the samecollection; there is a null access value for the derived

type andit is the default initial value of that type.
10

If an explicit representation clause exists for the parent type and if
this clause appears before the derived type definition, then there is a
corresponding representation clause (an implicit one) for the derived

type.®

Certain subprogramsthat are operations of the parent type are said to
be derivable. For each derivable subprogram of the parent type, there
is a corresponding derived subprogram for the derived type. Two kinds
of derivable subprogramsexist. First, if the parent type is declared
immediately within the visible part of a package, then a subprogram
that is itself explicitly declared immediately within the visible part
becomes derivable after the end of the visible part, if it is an operation
of the parent type. (The explicit declaration is by a subprogram
declaration, a renaming declaration, or a generic instantiation.) Second,
if the parent typeis itself a derived type, then any subprogram that
has been derived by this parent type is further derivable, unless the

' 6 See also Appendix G, AI-00138 and AI-00292.
3.4

Derived Types

3-14

parent type is declared in thevisible part of a package and the derived
subprogram is hidden by a derivable subprogram ofthe first kind.’
Each operation of the derived type is implicitly declared at the place of
the derived type declaration. The implicit declarations of any derived
subprogramsoccurlast.
13

The specification of a derived subprogram is obtained implicitly by systematic replacement of the parent type by the derived type in the specification
of the derivable subprogram. Any subtype of the parent type is likewise replaced by a subtype of the derived type with a similar constraint(as for the
transformation of a constraint of the parent subtype into the corresponding
constraint of the derived subtype). Finally, any expression of the parent type
is made to be the operand of a type conversion that yields a result of the
derived type.
Calling a derived subprogram is equivalent to calling the corresponding
subprogram of the parent type, in which each actual parameter that is of
the derived type is replaced by a type conversion of this actual parameter to
the parent type (this means that a conversion to the parent type happens
before the call for the modes in and in out; a reverse conversion to the

derived type happensafter the call for the modes in out and out, see 6.4.1).
In addition, if the result of a called function is of the parent type, this result
is converted to the derived type.
If a derived or private type is declared immediately within the visible part of
a package, then, within this visible part, this type must not be used as the
parent type of a derived type definition. (For private types, see also section
7.4.1.)
For the elaboration of a derived type definition, the subtype indicationis
first elaborated, the derived type is then created, and finally, the derived
subtype is created.
Examples:
type LOCALCOORDINATE is new COORDINATE;

type MIDWEEK is new DAY range TUE .. THU; -type COUNTER is new POSITIVE;
--

two different types

see 3.5.1
same range as

-- POSITIVE
type SPECIALKEY is new KEYMANAGER.KEY;

see 7.4.2

-- the derived subprograms have the following specifications:
-- procedure

GETKEY (K

-- function "<"(X,Y

out

SPECIALKEY);

SPECIALKEY)

return BOOLEAN;

7 See also Appendix G, AI-00367 and AI-00398.
3-15

Derived Types

3.4

Notes:

The rules of derivation of basic operations and enumeration literals imply
that the notation for any literal or aggregate of the derived type is the
same as for the parent type; such literals and aggregates are said to be

overloaded. Similarly, it follows that the notation for denoting a component,
a discriminant, an entry, a slice, or an attribute is the same for the derived
type as for the parent type.

Hiding of a derived subprogram is allowed even within the same declarative
region (see 8.3). A derived subprogram hides a predefined operator that has
the same parameter and result type profile (see 6.6).
20

A generic subprogram declaration is not derivable since it declares a generic
unit rather than a subprogram. On the other hand, an instantiation of a
generic subprogram is a (nongeneric) subprogram, which is derivable if it
satisfies the requirements for derivability of subprograms.

If the parent type is a boolean type, the predefined relational operators of
the derived type deliver a result of the predefined type BOOLEAN
(see 4.5.2).
If a representation clause is given for the parent type but appears after
the derived type declaration, then no corresponding representation clause
applies to the derived type; hence an explicit representation clause for such
a derived type is allowed.®
For a derived subprogram, if a parameter belongs to the derived type, the
subtype of this parameter need not have any value in common with the

derived subtype.

References: access value 3.8, actual parameter 6.4.1, aggregate 4.3, attribute

4.1.4, base type 3.3, basic operation 3.3.3, boolean type 3.5.3, bound of a range
3.5, class of type 3.3, collection 3.8, component 3.3, composite type 3.3, constraint
3.3, conversion 4.6, declaration 3.1, declarative region 8.1, default expression 3.2.1,
default initial value for an access type 3.8, discriminant 3.3, elaboration 3.9, entry

9.5, enumeration literal 3.5.1, floating point constraint 3.5.7, fixed point constraint

3.5.9, formal parameter 6.1, function call 6.4, generic declaration 12.1, immediately

within 8.1, implicit declaration 3.1, literal 4.2, mode 6.1, overloading 6.6 8.7,
package 7, package specification 7.1, parameter association 6.4, predefined operator
4.5, private type 7.4, procedure 6, procedure call statement 6.4, range constraint 3.5,
representation clause 13.1, reserved word 2.9, slice 4.1.2, subprogram 6, subprogram
specification 6.1, subtype indication 3.3.2, subtype 3.3, type 3.3, type definition 3.3.1,
visible part 7.2

8 See also Appendix G, AI-00138.
3.4

Derived Types

3-16

3.5 Scalar Types
1

Scalar types comprise enumeration types, integer types, and real types.

Enumeration types and integer types are called discrete types; each value

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

::=

range range

range ::= rangeattribute
| simpleexpression .. simpleexpression

A range specifies a subset of values of a scalar type. The range L.. R
specifies the values from L to R inclusive if the relation L <= R is true. The
values L and R are called the lower bound and upper boundof the range,
respectively. A value V is said to satisfy a range constraint if it belongs to
the range; the value V is said to belong to the range if the relations L <= V
and V <= R are both TRUE. A null range is a range for which the relation
R < Lis TRUE; no value belongs to a null range. The operators <= and < in
the above definitions are the predefined operators of the scalar type.
If a range constraint is used in a subtype indication, either directly or as

part of a floating or fixed point constraint, the type of the simple expressions

(likewise, of the bounds of a range attribute) must be the sameas the
base type of the type mark of the subtype indication. A range constraint
is compatible with a subtype if each bound of the range belongs to the
subtype, or if the range constraint defines a null range; otherwise the range
constraint is not compatible with the subtype.

The elaboration of a range constraint consists of the evaluation of the range.

The evaluation of a range defines its lower bound and its upper bound. If
simple expressions are given to specify the bounds, the evaluation of the

range evaluates these simple expressions in some order that is not defined
by the language.
Attributes:

For any scalar type T or for any subtype T of a scalar type, the following
attributes are defined:
T’ FIRST

Yields the lower bound of T. The value of this attribute has
the sametype as T.

T’ LAST

Yields the upper bound of T. The value of this attribute
has the sametype as T.

Scalar Types

3.5

Note:
10

Indexing and iteration rules use values of discrete types.

References: attribute 4.1.4, constraint 3.3, enumeration type 3.5.1, erroneous 1.6,
evaluation 4.5, fixed point constraint 3.5.9, floating point constraint 3.5.7, index
3.6, integer type 3.5.4, loop statement 5.5, range attribute 3.6.2, real type 3.5.6,
relational operator 4.5 4.5.2, satisfy a constraint 3.3, simple expression 4.4, subtype
indication 3.3.2, type mark 3.3.2

3.5.1

Enumeration Types
1
2

An enumeration type definition defines an enumeration type.
enumerationtypedefinition ::=
(enumerationliteralspecification
{, enumerationliteralspecification} )
enumerationliteralspecification ::=

enumerationliteral ::=
3

enumeration_literal

identifier | characterliteral

The identifiers and character literals listed by an enumeration type def-

inition must be distinct. Each enumeration literal specification is the
declaration of the corresponding enumerationliteral: this declaration ts
equivalent to the declaration of a parameterless function, the designator
being the enumeration literal, and the result type being the enumeration
type. The elaboration of an enumeration type definition creates an enumeration type; this elaboration includes that of every enumerationliteral
specification.”

Each enumeration literal yields a different enumeration value. The predefined order relations between enumeration values follow the order of
corresponding position numbers. The position numberof the value of the
first listed enumerationliteral is zero; the position number for each other
enumeration literal is one more than for its predecessor in thelist.

If the same identifier or character literal is specified in more than one
enumeration type definition, the corresponding literals are said to be
overloaded. At any place where an overloaded enumeration literal occurs
in the text of a program, the type of the enumeration literal must be
determinable from the context (see 8.7).

2 See also Appendix G, AI-00330 and AI-00430.
3.5.1

Enumeration Types

3-18

Examples:
type DAY

(MON,

type

SUIT

type GENDER is

(CLUBS,

TUE,

WED,

(M, F);

type

LEVEL

(LOW,

type COLOR
type LIGHT

is
is

(WHITE, RED,
(RED, AMBER,

type HEXA
type MIXED

is (’A’, 'B’, 'C’, 'D’, 'E’, 'EF’);
is (’A’, 'B’, '*’, B, NONE, '2?', '%');

MEDIUM,

subtype WEEKDAY is DAY
subtype MAJOR
is SUIT

THU,

DIAMONDS,

FRI,

HEARTS,

SAT,

SUN);

SPADES);

URGENT) ;

YELLOW,
GREEN);

GREEN, BLUE, BROWN, BLACK);
-- RED and GREEN are
-- overloaded

range MON .. FRI;
range HEARTS .. SPADES;

subtype RAINBOW is COLOR range RED

BLUE;

the color RED,

not the light

Note:
If an enumeration literal occurs in a context that does not otherwise suffice
to determine the typeof theliteral, then qualification by the nameof the
enumeration type is one way to resolve the ambiguity (see 8.7).
References: character literal 2.5, declaration 3.1, designator 6.1, elaboration 3.9,
6.1, function 6.5, identifier 2.3, name 4.1, overloading 6.6 8.7, position number3.5,
qualified expression 4.7, relational operator 4.5 4.5.2, type 3.3, type definition 3.3.1

3.5.2

Character Types
1

An enumeration type is said to be a character type if at least one of its enumeration literals is a characterliteral. The predefined type CHARACTERis
a character type whose values are the 128 characters of the ASCII character
set. Each of the 95 graphic characters of this character set is denoted by the
corresponding characterliteral.
Example:

type ROMANDIGIT is (’I’, ‘Vv’, 'X’, ‘'L’, 'C’, 'D’, 'M’);
Notes:
The predefined package ASCII includesthe declaration of constants denoting
control characters and of constants denoting graphic characters that are not
in the basic characterset.
A conventional character set such as EBCDIC can be declared as a character
type; the internal codes of the characters can be specified by an enumeration
representation clause as explained in section 13.3.

3-19

Character Types

3.5.2

References: ascii predefined package C, basic character 2.1, character literal

2.5, constant 3.2.1, declaration 3.1, enumeration type 3.5.1, graphic character 2.1,

identifier 2.3, literal 4.2, predefined type C, type 3.3

3.5.3

Boolean Types
q

There is a predefined enumeration type named BOOLEAN.It contains the
two literals FALSE and TRUEordered with the relation FALSE < TRUE. A
boolean type is either the type BOOLEAN ora typethat is derived,directly
or indirectly, from a boolean type.

References: derived type 3.4, enumeration literal 3.5.1, enumeration type 3.5.1,
relational operator 4.5 4.5.2, type 3.3

3.5.4

Integer Types
1

An integer type definition defines an integer type whose set of values
includes at least those of the specified range.
integertypedefinition ::=

rangeconstraint

If a range constraint is used as an integer type definition, each bound of
the range must be defined by a static expression of some integer type, but
the two bounds need not have the sameinteger type. (Negative bounds are
allowed.)!°
A type declaration of the form:!!
type T is range L .. R;

is, by definition, equivalent to the following declarations:
type integertype is new predefinedintegertype;
subtype T is integertype
range integertype(L) .. integer_type(R);

where integer_type is an anonymoustype, and where the predefined integer
type is implicitly selected by the implementation, so as to contain the
values L to R inclusive. The integer type declaration is illegal if none of
the predefined integer types satisfies this requirement, excepting wniversal_
integer. The elaboration of the declaration of an integer type consists of the
elaboration of the equivalent type and subtype declarations.

10 See also Appendix G, AI-00240.
11 See also Appendix G, AI-00023.
3.5.4

Integer Types

3-20

The predefined integer types include the type INTEGER. An implementation
may also have predefined types such as SHORT_INTEGER and LONG_
INTEGER, which have (substantially) shorter and longer ranges, respectively, than INTEGER. The range of each of these types must be symmetric
about zero, excepting an extra negative value which may exist in some

implementations. The base type of each of these types is the typeitself.
VAX Ada provides the following predefined integer types:
Predefined type

Range of values

INTEGER

231, 231_]
(or —2,147,483,648..2,147,483,647)

SHORT_INTEGER

—2)° 9'5_1
(or -32768..32767)

SHORT_SHORT_LINTEGER

-2”..2"-1
(or -128..127)

Integer literals are the literals of an anonymous predefined integer type that

is called wniversal_integer in this reference manual. Other integer types

have no literals. However, for each integer type there exists an implicit
conversion that converts a universal_integer value into the corresponding
value (if any) of the integer type. The circumstances under which these
implicit conversions are invoked are described in section 4.6.
The position numberof an integer value is the corresponding value of the

type universal_integer.

The same arithmetic operators are predefined for all integer types (see 4.5).
The exception NUMERIC_ERRORis raised by the execution of an operation

(in particular an implicit conversion) that cannot deliver the correct result
(that is, if the value corresponding to the mathematical result is not a value
of the integer type). However, an implementation is not required to raise the
exception NUMERIC_ERRORif the operation is part of a larger expression
whoseresult can be computedcorrectly, as described in section 11.6. 12
Examples:
type PAGENUM

is range 1

type LINESIZE is range 1

.. 2 000;
..

MAXLINESIZE;

subtype SMALLINT
is INTEGER
range -10 .. 10;
subtype COLUMNPTR is LINESIZE range 1 .. 10;
subtype BUFFERSIZE is INTEGER
range 0 .. MAX;

12 See also Appendix G, AI-00267 and AI-00387.
3-21

Integer Types

3.5.4

Notes:

The name declared by an integer type declaration is a subtype name. On the
other hand, the predefined operators of an integer type deliver results whose
range is defined by the parent predefined type; such a result need not belong
to the declared subtype, in which case an attempt to assign the result to a
variable of the integer subtype raises the exception CONSTRAINT_ERROR.
13

3.5.5

The smallest (most negative) value supported by the predefined integer
types of an implementation is the named number SYSTEM.MIN_INT and
the largest (most positive) value is SYSTEM.MAX_INT (see 13.7).
References: anonymoustype 3.3.1, belong to a subtype 3.3, bound of a range
3.5, constraint_error exception 11.1, conversion 4.6, identifier 2.3, integer literal
2.4, literal 4.2, numeric_error exception 11.1, parent type 3.4, predefined operator
4.5, range constraint 3.5, static expression 4.9, subtype declaration 3.3.2, system
predefined package 13.7, type 3.3, type declaration 3.3.1, type definition 3.3.1,
universal type 4.10

Operations of Discrete Types
1

The basic operations of a discrete type include the operations involved in
assignment, the membership tests, and qualification; for a boolean type they
include the short-circuit control forms; for an integer type they include the
explicit conversion of values of other numeric types to the integer type, and
the implicit conversion of values of the type uwniversal_integer to the type.
Finally, for every discrete type or subtype T, the basic operations include
the attributes listed below. In this presentation, T is referred to as being
a subtype (the subtype T) for any property that depends on constraints
imposed by T; other properties are stated in termsof the base typeof T.
The first group of attributes yield characteristics of the subtype T. This
group includes the attribute BASE (see 3.3.2), the attributes FIRST and
LAST (see 3.5), the representation attribute SIZE (see 13.7.2), and the

attribute WIDTH defined asfollows:

T’ WIDTH

3.5.5

Yields the maximum image length overall values of
the subtype T (the image is the sequence of characters
returned by the attribute IMAGE,see below). Yields zero
for a null range. The valueof this attribute is of the type
universal_integer.

Operations of Discrete Types

3-22

All attributes of the second group are functions with a single parameter.
The corresponding actual parameter is indicated below by X.

T’ POS

This attribute is a function. The parameter X must be
a value of the base type of T. The result type is the type
universal_integer. The result is the position numberof the
value of the parameter.

T’ VAL

This attribute is a special function with a single parameter
which can be of any integer type. The result type is the
base type of T. The result is the value whose position
numberis the universal_integer value corresponding to X.
The exception CONSTRAINT_ERRORisraised if the
universal_integer value corresponding to X is not in the
range T’ POS(T’ BASE’ FIRST) .. T’ POS(T’ BASE’ LAST).

T’-SUCC

This attribute is a function. The parameter X must be a
value of the base type of T. The result type is the base
type of T. The result is the value whose position numberis
one greater than that of X. The exception CONSTRAINT_

ERRORis raised if X equals T’ BASE’ LAST.
9

T’ PRED

This attribute is a function. The parameter X must be a
value of the base type of T. The result type is the base type
of T. The result is the value whose position numberis one
less than that of X. The exception CONSTRAINT_ERROR
is raised if X equals T’ BASE’ FIRST.

T IMAGE

This attribute is a function. The parameter X must

be a value of the base type of T. The result type is the
predefined type STRING. The result is the image of the
value of X, that is, a sequence of characters representing
the value in display form. 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. The lower boundof the imageis one:
The image of an enumeration value is either the corresponding identifier in upper case or the corresponding
characterliteral (including the two apostrophes); neither leading nortrailing spaces are included. The

13 See also Appendix G, AI-00234.
3-23

Operations of Discrete Types

3.5.5

image of a character C, other than a graphic character, is implementation-defined; the only require-

ment is that the image must be such that C equals

CHARACTER’ VALUE(CHARACTER’ IMAGE(C)). **
In VAX Ada, the image of a character C that is not a
graphic characteris defined as a string of two or three
uppercase letters, without enclosing quotation marks
or apostrophes. The upper case letters used are those
shown in italics as theliterals of the predefined type
CHARACTERin Annex C (package STANDARD).

T’ VALUE

This attribute is a function. The parameter X must be a
value of the predefined type STRING. The result typeis
the base type of T. Any leading and any trailing spaces
of the sequence of characters that corresponds to the
parameter are ignored.
For an enumeration type, if the sequence of characters

has the syntax of an enumeration literal and if this literal
exists for the base type of T, the result is the corresponding

enumeration value. For an integer type,if the sequence
of characters has the syntax of an integer literal, with an
optional single leading character that is a plus or minus
sign, and if there is a corresponding value in the base
type of T, the result is this value. In any other case, the
exception CONSTRAINT_ERRORisraised.

In addition, the attributes A’SIZE and A’ ADDRESSaredefined for an
object A of a discrete type (see 13.7.2).

Besides the basic operations, the operations of a discrete type include the
predefined relational operators. For enumeration types, operations include
enumeration literals. For boolean types, operations include the predefined
unary logical negation operator not, and the predefined logical operators.
For integer types, operations include the predefined arithmetic operators:
these are the binary and unary adding operators — and +, all multiplying
operators, the unary operator abs, and the exponentiating operator.

The operations of a subtype are the corresponding operations of its base
type except for the following: assignment, membership tests, qualification,
explicit type conversions, and the attributes of the first group; the effect of

each of these operations depends on the subtype (assignments, membership
tests, qualifications, and conversions involve a subtype check; attributes of
the first group yield a characteristic of the subtype).
14 See also Appendix G, AI-00239.
3.5.5

Operations of Discrete Types

3-24

Notes:
17

For a subtype of a discrete type, the results delivered by the attributes
SUCC, PRED, VAL, and VALUEneed not belong to the subtype; similarly,
the actual parameters of the attributes POS, SUCC, PRED, and IMAGE

need not belong to the subtype. The following relations are satisfied (in the
absence of an exception) by these attributes:

T’ POS (T’ SUCC (X))
T’ POS (T’ PRED (X))

= T’POS(X)
= T’POS(X)

T’VAL(T’POS(X))
T’POS(T’VAL(N))

= X
=N

Examples:
--

For the types and subtypes declared

---

COLOR’ FIRST
= WHITE,
RAINBOW’FIRST = RED,

----

COLOR’ SUCC (BLUE)
COLOR’POS (BLUE)
COLOR’ VAL (0)

+ 1
- 1

in section 3.5.1 we have:

COLOR’ LAST
= BLACK
RAINBOW’ LAST = BLUE

= RAINBOW’ SUCC (BLUE)
= RAINBOW’POS(BLUE)
= RAINBOW’ VAL (0)

= BROWN
= 4
= WHITE

References: abs operator 4.5 4.5.6, assignment 5.2, attribute 4.1.4, base type 3.3,

basic operation 3.3.3, binary adding operator 4.5 4.5.3, boolean type 3.5.3, bound

of a range 3.5, character literal 2.5, constraint 3.3, constraint_error exception 11.1,

conversion 4.6, discrete type 3.5, enumeration literal 3.5.1, exponentiating operator
4.5 4.5.6, function 6.5, graphic character 2.1, identifier 2.3, integer type 3.5.4, logical
operator 4.5 4.5.1, membership test 4.5 4.5.2, multiplying operator 4.5 4.5.5, not
operator 4.5 4.5.6, numeric literal 2.4, numeric type 3.5, object 3.2, operation 3.3,

position number 3.5, predefined operator 4.5, predefined type C, qualified expression
4.7, relational operator 4.5 4.5.2, short-circuit control form 4.5 4.5.1, string type
3.6.3, subtype 3.3, type 3.3, unary adding operator 4.5 4.5.4, universal_integer type
3.5.4, universal type 4.10
character 2.1, character type 3.5.2, standard predefined package 8.6 C

3.5.6

Real Types
1

Real types provide approximations to the real numbers, with relative bounds
on errorsfor floating point types, and with absolute boundsfor fixed point

types.
2

3-25

realtypedefinition ::=
floatingpointconstraint | fixed_pointconstraint

Real Types

3.5.6

A set of numbers called model numbers is associated with each real type.

An implementation-dependent set of numbers, called the safe numbers, is
also associated with each real type. The set of safe numbers of a real type
must include at least the set of model numbers of the type. The range of
safe numbersis allowed to be larger than the range of model numbers,
but error bounds on the predefined operations for safe numbers are given
by the same rules as for model numbers. Safe numbers therefore provide
guaranteed error bounds for operations on an implementation-dependent
range of numbers; in contrast, the range of model numbers depends only on
the real type definition andis therefore independent of the implementation.

Real literals are the literals of an anonymous predefined real type that is
called universal_real in this reference manual. Other real types have no
literals. However, for each real type, there exists an implicit conversion that

Error bounds on the predefined operations are given in terms of the model
numbers. An implementation of the type must include at least these model
numbers and represent them exactly.

converts a universal_real value into a value of the real type. The conditions

under which these implicit conversions are invoked are described in section
4.6. If the universal_real value is a safe number, the implicit conversion
delivers the corresponding value; if it belongs to the range of safe numbers
but is not a safe number, then the converted value can be any value within
the range defined by the safe numbers next above and below the wniversal_
real value.
6

The execution of an operation that yields a value of a real type may
raise the exception NUMERIC_ERROR,as explained in section 4.5.7, if
it cannot deliver a correct result (that is, if the value corresponding to
one of the possible mathematical results does not belong to the range of
safe numbers); in particular, this exception can be raised by an implicit
conversion. However, an implementation is not required to raise the
exception NUMERIC_ERRORif the operation is part of a larger expression
whose result can be computed correctly (see 11.6).!°

The elaboration of a real type definition includes the elaboration of the
floating or fixed point constraint and creates a real type.

15 See also Appendix G, AI-00387.
3.5.6

Real Types

3-26

Note:

An algorithm written to rely only upon the minimum numerical properties
guaranteed by the type definition for model numbers will be portable without
further precautions.

References: conversion 4.6, elaboration 3.9, fixed point constraint 3.5.9, floating
point constraint 3.5.7, literal 4.2, numeric_error exception 11.1, predefined operation
3.3.3, real literal 2.4, type 3.3, type definition 3.3.1, universal type 4.10

3.5.7

Floating Point Types
1
2

For floating point types, the error boundis specified as a relative precision
by giving the required minimum numberofsignificant decimal digits.
floatingpointconstraint

::=

floatingaccuracydefinition

[rangeconstraint]

::=

digits staticsimpleexpression

The minimum numberofsignificant decimal digits is specified by the value
of the static simple expression of the floating accuracy definition. This
value must belong to some integer type and must be positive (nonzero);
it is denoted by D in the remainderof this section. If the floating point
constraint is used as a real type definition and includes a range constraint,
then each bound of the range must be defined by a static expression of some
real type, but the two bounds need not have the samereal type.

For a given radix, the following canonical form is defined for any floating
point model numberother than zero:
sign * mantissa *

(radix ** exponent)

In this form: sign is either +1 or —1; mantissa is expressed in a number base
given by radix; and exponent is an integer number(possibly negative) such
that the integer part of mantissa is zero and thefirst digit of its fractional
part is not a zero.

The specified number D is the minimum numberof decimal digits required
after the point in the decimal mantissa (that is, if radix is ten). The value
of D in turn determines a corresponding numberB that is the minimum
number of binary digits required after the point in the binary mantissa
(that is, if radix is two). The number B associated with D is the smallest

value such that the relative precision of the binary form is no less than that
specified for the decimal form. (The numberB is the integer next above

(D*log(10)/log(2)) + 1.)2©

16 See also Appendix G, AI-00205.
3-27

Floating Point Types

3.5.7

The model numbers defined by a floating accuracy definition comprise zero
and all numbers whose binary canonical form has exactly B digits after
the point in the mantissa and an exponent in the range —4*B .. +4*B. The
guaranteed minimum accuracy of operations of a floating point typeis
defined in terms of the model numbers ofthe floating point constraint that
forms the corresponding real type definition (see 4.5.7).

The predefined floating point types include the type FLOAT. An implementation may also have predefined types such as SHORT_FLOAT and LONG_
FLOAT, which have (substantially) less and more accuracy, respectively,
than FLOAT. The basetype of each predefined floating point type is the type
itself. The model numbers of each predefined floating point type are defined
in terms of the number D of decimal digits returned by the attribute DIGITS
(see 3.5.8).
In addition to the type FLOAT, VAX Ada provides the types LONG_FLOAT

and LONG_LONG_FLOAT (declared in the package STANDARD) and the
types F_FLOAT, D_FLOAT, G_FLOAT, and H_FLOAT(declared in the

package SYSTEM).

Each VAX Adafloating point type is represented by one of four internal
floating point data representations:
Representation

Size

Digits of precision

F_floating

32 bits

D_floating

64 bits

G_floating

64 bits

H_floating

128 bits

In VAX Ada, the type FLOAT is implemented. using the F_floating representation. The type LONG_FLOATis implemented using either the D_floating
or G_floating representation; the pragma LONG_FLOAT(see 3.5.7a) is
provided to allow control over the representation (the default is G_floating).
The type LONG_LONG_FLOATis implemented using the H_floating representation. The types F_FLOAT, D_FLOAT, G_FLOAT, and H_FLOAT

correspond exactly to the F_floating, D_floating, G_floating, and H_floating
representations, respectively.
The predefined attributes that yield the characteristics of each floating point
type are described in section 3.5.8; values of these attributes for the four
VAX floating point data representations are listed in Appendix F. The VAX
Ada Run-Time Reference Manual gives more information on the internal
representation of VAX Ada floating point types.

3.5.7

Floating Point Types

3-28

For each predefined floating point type (consequently also for each type

derived therefrom), a set of safe numbersis defined as follows. The safe

numbers have the same numberB of mantissa digits as the model num-

bers of the type and have an exponent in the range —E .. +E where E is

implementation-defined and at least equal to the 4*B of model numbers.
(Consequently, the safe numbers include the model numbers.) The rules

defining the accuracy of operations with model and safe numbers are given7
in section 4.5.7. The safe numbers of a subtype are thoseof its base type.
10

A floating point type declaration of one of the two forms(that is, with or
without the optional range constraint indicated by the square brackets):
type T is digits D

[range L .. R];

+18, by definition, equivalent to the following declarations:
type floatingpointtype is new predefinedfloatingpointtype;
subtype T is floatingpointtype digits D
[range floatingpointtype(L) .. floatingpoint_type(R)];

where floating_point_type is an anonymous type, and where the predefined
floating point type is implicitly selected by the implementation so that its
model numbers include the model numbers defined by D; furthermore,if a
range L.. Ris supplied, then both L and R must belong to the range of safe
numbers. Thefloating point declaration is illegal if none of the predefined
floating point types satisfies these requirements, excepting universal_real.
The maximum numberof digits that can be specified in a floating accuracy
definition is given by the system-dependent named number SYSTEM.MAX_
DIGITS(see 13.7.1).
The predefined attributes that yield the safe numbercharacteristics of each
floating point type are described in section 3.5.8; values of these attributes
for the four VAX floating point representations are listed in Appendix F.

The elaboration of a floating point type declaration consists of the elaboration of the equivalent type and subtype declarations.

Ifa floating point constraint follows a type mark in a subtype indication, the
type mark must denote a floating point type or subtype. Thefloating point
constraint is compatible with the type mark only if the number D specified
in the floating accuracy definition is not greater than the corresponding
number D for the type or subtype denoted by the type mark. Furthermore,
if the floating point constraint includes a range constraint, the floating point
constraint is compatible with the type mark only if the range constraintis,
itself, compatible with the type mark.

17 See also Appendix G, AI-00217 and AI-00314.
18 See also Appendix G, AI-00023.
3-29

Floating Point Types

3.5.7

The elaboration of such a subtype indication includes the elaboration of the
range constraint, if there is one; it creates a floating point subtype whose
model numbers are defined by the corresponding floating accuracy definition.
A value of a floating point type belongs to a floating point subtype if and
only if it belongs to the range defined by the subtype.

The same arithmetic operators are predefined for all floating point types
(see 4.5).
Notes:

A range constraint is allowed in a floating point subtype indication, either
directly after the type mark,or as part of a floating point constraint. In
either case the bounds of the range must belong to the base type of the type
mark (see 3.5). The imposition of a floating point constraint on a type mark
in a subtype indication cannot reduce the allowed range of values unless it
includes a range constraint (the range of model numbers that correspond to
the specified number of digits can be smaller than the range of numbers of
the type mark). A value that belongsto a floating point subtype need not be
a model numberof the subtype.?9

Examples:
type COEFFICIENT is digits 10 range -1.0
type REAL is digits 8;
type MASS is digits 7 range 0.0

1.0;

1.0E35;

subtype SHORTCOEFF is COEFFICIENT digits 5;

-- a subtype with
-- less accuracy

subtype PROBABILITY is REAL range 0.0

1.0; -- a subtype with
-- a smaller range

Notes on the examples:
19

The implemented accuracy for COEFFICIENTis that of a predefined type
having at least 10 digits of precision. Consequently the specification of 5
digits of precision for the subtype SHORT_COEFFis allowed. The largest
model number for the type MASSis approximately 1.27E30 and henceless
than the specified upper bound (1.0E35). Consequently the declaration of
this type is legal only if this upper boundis in the range of the safe numbers
of a predefined floating point type having at least 7 digits of precision.

19 See also Appendix G, AI-00375.
3.5.7.

Floating Point Types

3-30

References: anonymous type 3.3.1, arithmetic operator 3.5.5 4.5, based literal
2.4.2, belong to a subtype 3.3, bound of a range 3.5, compatible 3.3.2, derived type
3.4, digit 2.1, elaboration 3.1 3.9, error bound 3.5.6, exponent 2.4.1 integer type
3.5.4, model number 3.5.6, operation 3.3, predefined operator 4.5, predefined type
C, range constraint 3.5, real type 3.5.6, real type definition 3.5.6, safe number
3.5.6, simple expression 4.4, static expression 4.9, subtype declaration 3.3.2, subtype
indication 3.3.2, subtype 3.3, type 3.3, type declaration 3.3.1, type mark 3.3.2
long_float pragma 3.5.7a

3.5.7a Pragma LONG_FLOAT
The pragma LONG_FLOATis provided by VAX Adato allow control over the
internal representation chosen for the predefined type LONG_FLOAT and
for floating point type declarations with digits specified in the range 7..15.
The form of this pragmais asfollows:

pragma LONGFLOAT(DFLOAT | GFLOAT);
This pragmais only allowed at the start of a compilation, before thefirst
compilation unit (if any).
If D_FLOATis specified, and the range is adequate, then a D_floating
representation is used for the predefined type LONG_FLOATandfor
floating point types declared with digits in the range 7..9. Similarly,
if G_FLOATis specified, and the range is adequate, then a G_floating
representation is used for the predefined type LONG_FLOATandfor
floating point types declared with digits in the range 7..15. F_floating and
H_floating representations are used for floating point types with digits in
other rangesasfollows:
Pragma argument

Digits specified

Representation

D_FLOAT

1..6

F_floating

7.9

D_floating

10..33

H_floating

1..6

F_floating

7..15

G_floating

16..33

H_floating

G_FLOAT

Use of the pragma LONG_FLOATis interpreted as an implicit recompilation
of the predefined STANDARDenvironment. Therefore, all units in the
program library that depend on the pragma LONG_FLOAT must be

3-31

Pragma LONG_FLOAT

3.5.7a

recompiled. Whenevera program library is reinitialized, the G_floating
representation is established by default.
Notes:

Ffloating is the representation chosen for digits in the range 1..6, and
H_floating is the representation chosen for digits in the range 16..33; these
choices are not affected by pragma LONG_FLOAT.
All representation choices also depend on the range of values to be represented. See the VAX Ada Run-Time Reference Manual for more information.
References: allow 1.6, compilation unit 10.1, d_float type 3.5.7, d_floating representation 3.5.7, f_float type 3.5.7, f_floating representation 3.5.7, floating point
type declaration 3.5.7, g_float type 3.5.7, gfloating representation 3.5.7, h_float type
3.5.7, h_floating representation 3.5.7, longfloat type 3.5.7, order of compilation 10.3,
pragma 2.8, program library 10.1, range 3.5, standard package 8.6 C

3.5.8

Operations of Floating Point Types
1

The basic operations of a floating point type include the operations involved
in assignment, membership tests, qualification, the explicit conversion of

values of other numeric types to the floating point type, and the implicit
conversion of values of the type wniversal_real to the type.

In addition, for every floating point type or subtype T, the basic operations

include the attributes listed below. In this presentation, T is referred to as

being a subtype (the subtype T) for any property that depends on constraints
imposed by T; other properties are stated in terms of the base type ofT.
Appendix F gives values for these attributes for each of the four VAX Ada
floating point representations (F_floating, D_floating, G_floating, and

H_floating).

The first group of attributes yield characteristics of the subtype T. The
attributes of this group are the attribute BASE (see 3.3.2), the attributes
FIRST and LAST (see 3.5), the representation attribute SIZE (see 13.7.2),
and the following attributes:

3.5.8

T’ DIGITS

Yields the number of decimal digits in the decimal
mantissa of model numbersof the subtype T. (This
attribute yields the numberD of section 3.5.7.) The value
of this attribute is of the type wniversal_integer.

T’MANTISSA

Yields the numberof binary digits in the binary mantissa
of model numbersof the subtype T. (This attribute yields
the numberB of section 3.5.7.) The value of this attribute
is of the type wniversal_integer.

Operations of Floating Point Types

3-32

T’ EPSILON

Yields the absolute value of the difference between the
model number 1.0 and the next model numberabove,for

the subtype T. The value of this attribute is of the type
universal_real.

T’ EMAX

Yields the largest exponent value in the binary canonical

form of model numbers of the subtype T. (This attribute

yields the product 4*B of section 3.5.7.) The value of this

attribute is of the type wniversal_integer.

T’ SMALL

Yields the smallest positive (nonzero) model numberof
the subtype T. The value of this attribute is of the type
universal_real.

T’ LARGE

Yields the largest positive model numberof the subtypeT.
The value of this attribute is of the type wniversal_real.

The attributes of the second group include the following attributes which
yield characteristics of the safe numbers:
T’SAFE_EMAX Yields the largest exponent value in the binary canonical
form of safe numbers of the base type of T. (This attribute
yields the number E of section 3.5.7.) The value of this
attribute is of the type universal_integer.
T’SAFE_SMALL Yields the smallest positive (nonzero) safe numberof the
base type of T. The value of this attribute is of the type
universal_real.

T’SAFE_LARGEYields the largest positive safe number of the base type of
T. The value of this attribute is of the type uwniversal_real.
In addition, the attributes A’ SIZE and A’ ADDRESSare defined for an

object A of a floating point type (see 13.7.2). Finally, for each floating
point type there are machine-dependent attributes that are not related to
model numbers and safe numbers. They correspondto the attribute designators MACHINE_RADIX, MACHINE_MANTISSA, MACHINE_EMAX,
MACHINE_EMIN, MACHINE_ROUNDS, and MACHINE_OVERFLOWS
(see 13.7.3).

Appendix F gives valuesfor all of the machine-dependent attributes for each
of the four VAX Adafloating point representations (F_floating, D_floating,
G_floating, and H_floating).
Besides the basic operations, the operations of a floating point type include
the relational operators, and the following predefined arithmetic operators:
the binary and unary adding operators — and +, the multiplying operators *
and /, the unary operator abs, and the exponentiating operator.

3-33

Operations of Floating Point Types

3.5.8

The operations of a subtype are the corresponding operations of the type
except for the following: assignment, membershiptests, qualification,
explicit conversion, and the attributes of the first group; the effects of these
operations are redefined in terms of the subtype.2°
Notes:
The attributes EMAX, SMALL, LARGE, and EPSILONare provided for

convenience. They are all related to MANTISSAbythe following formulas:
T’ EMAX
T’ EPSILON
T’SMALL
T’LARGE

=
=
=
=

4*T’MANTISSA
2.0**(1 - T’MANTISSA)
2.0**(-T’EMAX - 1)
2.0**T/EMAX * (1.0 - 2.0**(-T’MANTISSA) )

The attribute MANTISSA, giving the numberof binary digits in the mantissa, is itself related to DIGITS. The following relations hold between the
characteristics of the model numbers andthose of the safe numbers:
T’ BASE’ EMAX
<= T’SAFEEMAX
T’ BASE’ SMALL >= T’SAFESMALL
T’ BASE’ LARGE <= T’SAFELARGE
19

The attributes T’ FIRST and T’ LAST need not yield model or safe numbers.
If a certain numberof digits is specified in the declaration of a type or
subtype T, the attribute T’ DIGITSyields this number.
References: abs operator 4.5 4.5.6, arithmetic operator 3.5.5 4.5, assignment
5.2, attribute 4.1.4, base type 3.3, basic operation 3.3.3, binary adding operator 4.5
4.5.8, bound of a range 3.5, constraint 3.3, conversion 4.6, digit 2.1, exponentiating
operator 4.5 4.5.6, floating point type 3.5.7, membership test 4.5 4.5.2, model
number 3.5.6, multiplying operator 4.5 4.5.5, numeric type 3.5, object 3.2, operation
3.3, predefined operator 4.5, qualified expression 4.7, relational operator 4.5 4.5.2,
safe number 3.5.6, subtype 3.3, type 3.3, unary adding operator 4.5 4.5.4, universal
type 4.10, universal_integer type 3.5.4, universal_real type 3.5.6
floating point representation 3.5.7

3.5.9

Fixed Point Types
1

For fixed point types, the error boundis specified as an absolute value,
called the delta of the fixed point type.
fixedpointconstraint

::=

fixedaccuracydefinition [rangeconstraint]

fixedaccuracydefinition ::=

delta staticsimpleexpression

20 See also Appendix G, AI-00407.
3.5.9

Fixed Point Types

3-34

The delta is specified by the value of the static simple expression of the
fixed accuracy definition. This value must belong to some real type and
must be positive (nonzero). If the fixed point constraint is used as a real
type definition, then it must include a range constraint; each bound of the
specified range must be defined by a static expression of some real type
but the two bounds need not have the samereal type. If the fixed point
constraint is used in a subtype indication, the range constraint is optional.

A canonical form is defined for any fixed point model number other than
zero. In this form: sign is either +1 or —1; mantissa is a positive (nonzero)
integer; and any model numberis a multiple of a certain positive real
numbercalled small, as follows:
sign * mantissa * small

For the model numbersdefined by a fixed point constraint, the number
small is chosen as the largest power of two that is not greater than the delta
of the fixed accuracy definition. Alternatively, it is possible to specify the
value of small by a length clause (see 13.2), in which case model numbers
are multiples of the specified value. The guaranteed minimum accuracy of
operations of a fixed point type is defined in terms of the model numbers of
the fixed point constraint that forms the corresponding real type definition
(see 4.5.7).

For a fixed point constraint that includes a range constraint, the model
numbers comprise zero andall multiples of small whose mantissa can be
expressed using exactly B binary digits, where the value of B is chosen as
the smallest integer number for which each boundof the specified range is
either a model numberor lies at most small distant from a model number.
For a fixed point constraint that does not include a range constraint (this is
only allowed after a type mark, in a subtypeindication), the model numbers
are defined by the delta of the fixed accuracy definition and by the range of
the subtype denoted by the type mark.”

An implementation must have at least one anonymouspredefined fixed
point type. The base type of each such fixed point type is the typeitself.
The model numbers of each predefined fixed point type comprise zero and
all numbers for which mantissa (in the canonical form) has the number
of binary digits returned by the attribute MANTISSA, and for which the
number small has the value returned by the attribute SMALL.
To implement fixed point numbers, VAX Ada uses a set of anonymous
predefined fixed point types of the form:
type fixed_point_type is delta S range -L..L-S;

21 See also Appendix G, AI-00143.
3-35

Fixed Point Types

3.5.9

where S = 2.0" and L = 2.021*" for -62 <= n <= 31. Each fixed point type
has a size determined by its delta and range, rounded up to an 8-, 16-, or
32-bit boundary. The size may be changedby a representation clause
(see 13.1).

A fixed point type declaration of the form:22
type T is delta D range L .. R;

is, by definition, equivalent to the following declarations:2°
type fixed_point_type is new predefined_fixed_point_type;
subtype T is fixedpointtype
range fixedpoint_type(L) .. fixed_point_type(R);

In these declarations, fixed_point_type is an anonymoustype, and the
predefined fixed point type is implicitly selected by the implementation so
that its model numbers include the model numbers defined by the fixed
point constraint (that is, by D, L, and R, and possibly by a length clause

specifying small).24

The fixed point declaration is illegal if no predefined type satisfies these
requirements. The safe numbers of a fixed point type are the model

numbersof its base type. 2°

The elaboration of a fixed point type declaration consists of the elaboration
of the equivalent type and subtype declarations.
If the fixed point constraint follows a type mark in a subtype indication,
the type mark must denote a fixed point type or subtype. Thefixed point
constraint is compatible with the type mark only if the delta specified by
the fixed accuracy definition is not smaller than the delta for the type or
subtype denoted by the type mark. Furthermore,if the fixed point constraint
includes a range constraint, the fixed point constraint is compatible with the
type mark only if the range constraint is, itself, compatible with the type
mark.
14

The elaboration of such a subtype indication includes the elaboration of the
range constraint, if there is one; it creates a fixed point subtype whose model
numbers are defined by the corresponding fixed point constraint and also by
the length clause specifying small, if there is one. A value ofa fixed point
type belongs to a fixed point subtype if and only if it belongs to the range

defined by the subtype.2°

22 See also Appendix G, AI-00023.
23 See also Appendix G, AI-00144.
24 See also Appendix G, AI-00343.
25 See also Appendix G, AI-00508.
26 See also Appendix G, AI-00145 and AI-00146.
3.5.9

Fixed Point Types

3-36

The same arithmetic operators are predefined for all fixed point types
(see 4.5). Multiplication and division of fixed point values deliver results
of an anonymouspredefinedfixed point type that is called universal_fixed
in this reference manual; the accuracy of this type is arbitrarily fine. The

values of this type must be converted explicitly to some numeric type.

Notes:

If S is a subtype of a fixed point type or subtype T, then the set of model
numbers of S is a subset of those of T. If a length clause has been given for

T, then both S and T have the same value for small. Otherwise, since small

is a power of two, the small of S is equal to the small of T multiplied by a
nonnegative power of two.2!

A range constraint is allowed in a fixed point subtype indication, either
directly after the type mark, or as part of a fixed point constraint. In either
case the bounds of the range must belong to the base type of the type mark
(see 3.5).

Examples:
type VOLT is delta 0.125 range 0.0 .. 255.0;
subtype ROUGHVOLTAGE is VOLT delta 1.0;
--

same range as VOLT

---

A pure fraction which requires all the available space
in a word on a two’s complement machine can be declared

as the type FRACTION:

DEL : constant := 1.0/2** (WORDLENGTH - 1);
type FRACTION is delta DEL range -1.0 .. 1.0 - DEL;28
References: anonymoustype 3.3.1, arithmetic operator 3.5.5 4.5, base type 3.3,
belong to a subtype 3.3, bound of a range 3.5, compatible 3.3.2, conversion 4.6,
elaboration 3.9, error bound 3.5.6, length clause 13.2, model number 3.5.6, numeric
type 3.5, operation 3.3, predefined operator 4.5, range constraint 3.5, real type 3.5.6,
real type definition 3.5.6, safe number 3.5.6, simple expression 4.4, static expression
4.9, subtype 3.3, subtype declaration 3.3.2, subtype indication 3.3.2, type 3.3, type
declaration 3.3.1, type mark 3.3.2

27 See also Appendix G, AI-00146.
28 See also Appendix G, AI-00147.
3-37

Fixed Point Types

3.5.9

3.5.10

Operations of Fixed Point Types
1

The basic operations of a fixed point type include the operations involved
in assignment, membership tests, qualification, the explicit conversion
of values of other numeric typesto thefixed point type, and the implicit
conversion of values of the type universal_real to the type.
In addition, for every fixed point type or subtype T the basic operations
include the attributes listed below. In this presentation T is referred to as
being a subtype (the subtype T) for any property that depends on constraints
imposed by T; other properties are stated in terms of the base typeofT.
Thefirst group of attributes yield characteristics of the subtype T. The
attributes of this group are the attributes BASE (see 3.3.2), the attributes
FIRST and LAST (see 3.5), the representation attribute SIZE (see 13.7.2)
and the following attributes:
T’ DELTA

Yields the value of the delta specified in the fixed accuracy
definition for the subtype T. The value of this attribute is
of the type wniversal_real.

T’MANTISSA

Yields the numberof binary digits in the mantissa of
model numbersof the subtype T. (This attribute yields the
numberB of section 3.5.9.) The value of this attribute is
of the type universal_integer.

T’ SMALL

Yields the smallest positive (nonzero) model number of
the subtype T. The value of this attribute is of the type
universal_real.

T’ LARGE

Yields the largest positive model numberof the subtypeT.
The value of this attribute is of the type universal_real.

T’ FORE

Yields the minimum numberof characters needed for the
integer part of the decimal representation of any value of
the subtype T, assuming that the representation does not
include an exponent, but includes a one-character prefix
that is either a minus sign or a space. (This minimum
number does not include superfluous zeros or underlines,
and is at least two.) The value of this attribute is of the

type universal_integer.29

T’ AFT

)

Yields the number of decimal digits needed after the point
to accommodate the precision of the subtype T, unless the
delta of the subtype T is greater than 0.1, in which case

29 See also Appendix G, AI-00179.
3.5.10

Operations of Fixed Point Types

3-38

the attribute yields the value one. (T’ AFT is the smallest
positive integer N for which (10**N)*T’ DELTAis greater

than or equal to one.) The value of this attribute is of the
type universal_integer.

The attributes of the second group include the following attributes which
yield characteristics of the safe numbers:
T’ SAFE_SMALLYields the smallest positive (nonzero) safe numberof the
base type of T. The value of this attribute is of the type
universal_real.
T’ SAFE_LARGEYields the largest positive safe numberof the base type of
T. The value of this attribute is of the type wniversal_real.
In addition, the attributes A’ SIZE and A’ ADDRESSare defined for an

object A of a fixed point type (see 13.7.2). Finally, for each fixed point type
or subtype T, there are the machine-dependent attributes T’ MACHINE_
ROUNDSand T’ MACHINE_OVERFLOWS(see 13.7.3).
Besides the basic operations, the operations of a fixed point type include the
relational operators, and the following predefined arithmetic operators: the
binary and unary adding operators — and +, the multiplying operators * and
/, and the operator abs.
15

The operations of a subtype are the corresponding operations of the type
except for the following: assignment, membership tests, qualification,
explicit conversion, and the attributes of the first group; the effects of these
operations are redefined in terms of the subtype30
Notes:

The value of the attribute T’ FORE depends only on the range of the subtype
T. The value of the attribute T’ AFT depends only on the value of T’ DELTA.
The following relations exist between attributes of a fixed point type:
T’ LARGE
T’ SAFELARGE
T’ SAFESMALL

(2**T’MANTISSA - 1)
T’ BASE’ LARGE
T’ BASE’ SMALL

* T’ SMALL

References: abs operator 4.5 4.5.6, arithmetic operator 3.5.5 4.5, assignment
5.2, base type 3.3, basic operation 3.3.3, binary adding operator 4.5 4.5.3, bound
of a range 3.5, conversion 4.6, delta 3.5.9, fixed point type 3.5.9, membership test
4.5 4.5.2, model number 3.5.6, multiplying operator 4,5 4.5.5, numeric type 3.5,
object 3.2, operation 3.3, qualified expression 4.7, relational operator 4.5 4.5.2, safe
number 3.5.6, subtype 3.3, unary adding operator 4.5 4.5.4, universal_integer type
3.5.4, universal_real type 3.5.6

30 See also Appendix G, AI-00407.
3-39

Operations of Fixed Point Types

3.5.10

3.6 Array Types
1

An array object is a composite object consisting of components that have
the same subtype. The namefor a component of an array uses one or more
index values belonging to specified discrete types. The value of an array
object is a composite value consisting of the values of its components. —

arraytypedefinition ::=
|

unconstrainedarraydefinition
constrainedarraydefinition

unconstrainedarraydefinition ::=
array (indexsubtypedefinition

{, indexsubtypedefinition}) of

component_subtypeindication
constrainedarraydefinition

::=

array indexconstraint of component_subtypeindication

indexsubtypedefinition ::= typemark range <>
indexconstraint

::=

(discreterange {,

discrete_range})

discreterange ::= discretesubtypeindication

3.6

range

An array object is characterized by the numberof indices (the dimenstonality of the array), the type and position of each index, the lower and
upper bounds for each index, and the type andpossible constraint of the
components. The order of the indices is significant.

A one-dimensional array has a distinct component for each possible index
value. A multidimensional array has a distinct component for each possible
sequence of index values that can be formed by selecting one value for each
index position (in the given order). The possible values for a given index are
all the values between the lower and upper bounds,inclusive; this range of
values is called the index range.

An unconstrained array definition defines an array type. For each object
that has the array type, the numberof indices, the type and position of
each index, and the subtype of the componentsare as in the type definition;
the values of the lower and upper bounds for each index belong to the
corresponding index subtype, except for null arrays as explained in section
3.6.1. The index subtype for a given index position is, by definition, the
subtype denoted by the type mark of the corresponding index subtype
definition. The compound delimiter <> (called a box) of an index subtype
definition stands for an undefined range (different objects of the type
need not have the same bounds). The elaboration of an unconstrained
array definition creates an array type; this elaboration includes that of the
component subtype indication.

Array Types

3—40

A constrained array definition defines both an array type and a subtypeof
this type:

The array type is an implicitly declared anonymous type; this typeis
defined by an (implicit) unconstrained array definition, in which the
component subtype indication is that of the constrained array definition,
and in which the type mark of each index subtype definition denotes the
subtype defined by the corresponding discrete range.

The array subtype is the subtype obtained by imposition of the index
constraint on the array type.

If a constrained array definition is given for a type declaration, the simple
namedeclared by this declaration denotes the array subtype.

The elaboration of a constrained array definition creates the corresponding
array type and array subtype. For this elaboration, the index constraint and
the component subtype indication are elaborated. The evaluation of each
discrete range of the index constraint and the elaboration of the component
subtype indication are performed in someorder that is not defined by the
language.

Examples of type declarations with unconstrained array definitions:
type VECTOR
type MATRIX

is array(INTEGER range <>) of REAL;
is array(INTEGER range <>,
INTEGER range <>) of REAL;

type BITVECTOR is array(INTEGER

type ROMAN

range <>)

is array (POSITIVE range <>)

of BOOLEAN;

of ROMANDIGIT;

Examples of type declarations with constrained array definitions:
type TABLE

is array(1

type SCHEDULE is array (DAY)

type LINE

10)

of INTEGER;

of BOOLEAN;

is array(1 .. MAX_LINESIZE) of CHARACTER;

Examples of object declarations with constrained array definitions:
GRID
MIX

:
:

array(1 .. 80, 1 .. 100)
array(COLOR range RED ..

PAGE : array(1

50)

of LINE;

of BOOLEAN;
GREEN) of BOOLEAN;

an array of arrays

Note:
14

For a one-dimensional array, the rule given means that a type declaration
with a constrained array definition such as
type T is array(POSITIVE range MIN

3-41

MAX)

of COMPONENT;

Array Types’

3.6

is equivalent (in the absence of an incorrect order dependence) to the succession of declarations
subtype indexsubtype is POSITIVE range MIN .. MAX;
type arraytype is array(index_subtype range <>) of COMPONENT;
subtype T is arraytype(index_subtype);

where index_subtype and array_type are both anonymous. Consequently,
T is the name of a subtype andall objects declared with this type mark

are arrays that have the same bounds. Similar transformations apply to

multidimensional arrays.
17

A similar transformation applies to an object whose declaration includes
a constrained array definition. A consequence of this is that no two such
objects have the sametype.
References: anonymoustype 3.3.1, bound of a range 3.5, component 3.3, con-

straint 3.3, discrete type 3.5, elaboration 3.1 3.9, in some order 1.6, name 4.1, object
3.2, range 3.5, subtype 3.3, subtype indication 3.3.2, type 3.3, type declaration 3.3.1,

type definition 3.3.1, type mark 3.3.2

3.6.1.

Index Constraints and Discrete Ranges
1

An index constraint determines the range of possible values for every index
of an array type, and thereby the corresponding array bounds.
For a discrete range used in a constrained array definition and defined by a
range, an implicit conversion to the predefined type INTEGERis assumed

if each boundis either a numeric literal, a named number, or an attribute,

and the type of both bounds(prior to the implicit conversion) is the type
universal_integer. Otherwise, both bounds must be of the same discrete type,
other than universal_integer; this type must be determinable independently
of the context, but using the fact that the type must be discrete and that
both bounds must have the same type. These rules apply also to a discrete
range used in an iteration rule (see 5.5) or in the declaration of a family of
entries (see 9.5)?
If an index constraint follows a type mark in a subtypeindication, then the |
type or subtype denoted by the type mark must not already impose an index
constraint. The type mark must denote either an unconstrained array type
or an access type whose designated type is such an array type. In either
case, the index constraint must provide a discrete range for each index of
the array type andthe type of each discrete range must be the same as that
of the corresponding index.

31 See also Appendix G, AI-00148.
3.6.1.

Index Constraints and Discrete Ranges

3-42

An index constraint is compatible with the type denoted by the type mark if
and only if the constraint defined by each discrete range is compatible with
the corresponding index subtype. If any of the discrete ranges defines a null
range, any array thus constrainedis a null array, having no components.
An array value satisfies an index constraint if at each index position the
array value and the index constraint have the same index bounds. (Note,

however, that assignment and certain other operations on arrays involve an

implicit subtype conversion.) 22
5

The bounds of each array object are determinedasfollows:

For a variable declared by an object declaration, the subtype indication
of the corresponding object declaration must define a constrained array
subtype (and, thereby, the bounds). The same requirementexists for the
subtype indication of a component declaration, if the type of the record
componentis an array type; and for the component subtype indication of
an array type definition, if the type of the array componentsis itself an
array type.

For a constant declared by an object declaration, the bounds of the
constant are defined by the initial value if the subtype of the constantis
unconstrained; they are otherwise defined by this subtype (in the latter
case, the initial value is the result of an implicit subtype conversion).
The samerule applies to a generic formal parameter of modein.

For an array object designated by an access value, the bounds must be
defined by the allocator that creates the array object. (The allocated
object is constrained with the corresponding values of the bounds.)

For a formal parameter of a subprogram or entry, the bounds are obtained from the corresponding actual parameter. (The formal parameter
is constrained with the corresponding values of the bounds.)

For a renaming declaration and for a generic formal parameter of
mode in out, the bounds are those of the renamed object or of the
corresponding generic actual parameter.

+For the elaboration of an index constraint, the discrete ranges are evaluated
in some orderthat is not defined by the language.

Examples of array declarations including an index constraint:
BOARD
RECTANGLE

:
:

MATRIX(1
MATRIX(1

FILTER

BITVECTOR (0

INVERSE

: MATRIX(1

..
..

8,
20,

..N,

..-

1
1

..
..

8);
30);

...N);

see 3.6

#=--

N need not be static

31);

32 See also Appendix G, AI-00282.
3-43

Index Constraints and Discrete Ranges

3.6.1

Example of array declaration with a constrained array subtype:
MYSCHEDULE

SCHEDULE;

all arrays of type SCHEDULE

have the same bounds

Example of record type with a componentthat is an array:
type VARLINE(LENGTH
record
IMAGE

STRING(1

INTEGER)
..

LENGTH);

end record;
NULLLINE

VAR_LINE (0);

NULLLINE. IMAGE

null

array

Notes:

The elaboration of a subtype indication consisting of a type mark followed by
an index constraint checks the compatibility of the index constraint with the
type mark(see 3.3.2).

All components of an array have the same subtype. In particular, for an

array of components that are one-dimensional arrays, this meansthatall
components have the same bounds and hence the samelength.
References: access type 3.8, access type definition 3.8, access value 3.8, actual

parameter 6.4.1, allocator 4.8, array bound 3.6, array component 3.6, array type

3.6, array type definition 3.6, bound of a range 3.5, compatible 3.3.2, component
declaration 3.7, constant 3.2.1, constrained array definition 3.6, constrained array
subtype 3.6, conversion 4.6, designate 3.8, designated type 3.8, discrete range
3.6, entry 9.5, entry family declaration 9.5, expression 4.4, formal parameter6.1,
function 6.5, generic actual parameter 12.3, generic formal parameter 12.1 12.3,
generic parameter 12.1, index 3.6, index constraint 3.6.1, index subtype 3.6, initial

value 3.2.1, integer literal 2.4, integer type 3.5.4, iteration rule 5.5, mode 12.1.1,

name 4.1, null range 3.5, object 3.2, object declaration 3.2.1, predefined type C,
range 3.5, record component 3.7, renaming declaration 8.5, result subtype 6.1,
satisfy 3.3, subprogram 6, subtype conversion 4.6, subtype indication 3.3.2, type
mark 3.3.2, unconstrained array type 3.6, unconstrained subtype 3.3, universal type
4.10, universal_integer type 3.5.4, variable 3.2.1

3.6.2

Operations of Array Types
41

The basic operations of an array type include the operations involved in

assignment and aggregates (unless the array type is limited), membership

tests, indexed components, qualification, and explicit conversion; for one-

dimensional arrays the basic operations also include the operations involved
in slices, and also string literals if the component type is a charactertype.

3.6.2

Operations of Array Types

3-44

If A is an array object, an array value, or a constrained array subtype, the
basic operations also include the attributes listed below. These attributes
are not allowed for an unconstrained array type. The argument N used
in the attribute designators for the N-th dimension of an array must be a

static expression of type wniversal_integer. The value of N must be positive
(nonzero) and no greater than the dimensionality of the array.

A’ FIRST

Yields the lower boundof the first index range. The
value of this attribute has the sametypeasthis
lower bound.

A’ FIRST(N)

Yields the lower bound of the N-th index range. The
value of this attribute has the sametype as this
lower bound.

A’ LAST

Yields the upper boundof the first index range. The
value of this attribute has the same type asthis
upper bound.

A’ LAST(N)

Yields the upper bound of the N-th index range. The
value of this attribute has the same type asthis
upper bound.

A’ RANGE

Yields the first index range, that is, the range
A’ FIRST .. A’ LAST.

A’ RANGE(N)

Yields the N-th index range, that is, the range
A’ FIRST(N) .. A’ LAST(N).

A’ LENGTH

Yields the numberof values of the first index range ©

A’ LENGTH(N)

Yields the number of values of the N-th index range
(zero for a null range). The value of this attribute is
of the type universal_integer.

(zero for a null range). The value of this attribute is
of the type universal_integer.

In addition, the attribute T’ BASE is defined for an array type or subtype T
(see 3.3.3); the attribute T’ SIZE is defined for an array type or subtypeT,
and the attributes A’ SIZE and A’ ADDRESSare defined for an array object
A (see 13.7.2).
Besides the basic operations, the operations of an array type include the
predefined comparison for equality and inequality, unless the array type

is limited. For one-dimensional arrays, the operations include catenation,

unless the array type is limited; if the component type is a discrete type, the
operations also includeall predefined relational operators; if the component
type is a boolean type, then the operations also include the unary logical
negation operator not, and the logical operators.
3-45

Operations of Array Types

3.6.2

Examples using arrays declared in the examples of section 3.6.1:
------

FILTER’ FIRST
FILTER’ LAST
FILTER’ LENGTH
RECTANGLE’ LAST(1)
RECTANGLE’ LAST(2)

=
=
=
=
=

0
31
32
20
30

Notes:
14

The attributes A’ FIRST and A’ FIRST(1) yield the same value. A similar
relation exists for the attributes A’ LAST, A’ RANGE, and A’ LENGTH.

The following relations are satisfied (except for a null array) by the above
attributes if the index type is an integer type:
A’ LENGTH
A’ LENGTH (N)

= A’ LAST
= A’LAST(N)

- A’FIRST
- A’FIRST(N)

+ 1
+ 1

An array type is limited if its component type is limited (see 7.4.4).
References: aggregate 4.3, array type 3.6, assignment 5.2, attribute 4.1.4, basic
operation 3.3.3, bound of a range 3.5, catenation operator 4.5 4.5.3, character type
3.5.2, constrained array subtype 3.6, conversion 4.6, designator 6.1, dimension
3.6, index 3.6, indexed component 4.1.1, limited type 7.4.4, logical operator 4.5

4.5.1, membership test 4.5 4.5.2, not operator 4.5 4.5.6, null range 3.5, object 3.2,

operation 3.3, predefined operator 4.5, qualified expression 4.7, relational operator
4.5 4.5.2, slice 4.1.2, static expression 4.9, string literal 2.6, subcomponent 3.3, type
3.3, unconstrained array type 3.6, universal type 4.10, universal_integer type 3.5.4

3.6.3

The Type String
1

The values of the predefined type STRINGare one-dimensional arrays of the
predefined type CHARACTER,indexed by values of the predefined subtype
POSITIVE:
subtype POSITIVE is INTEGER range 1

INTEGER’ LAST;

type STRING is array (POSITIVE range <>) of CHARACTER;

In VAX Ada, the maximum numberof characters in any object or value of
the predefined type STRING(or any type derived therefrom) is 216 — 1 (or
65,535).

3.6.3

The Type String

3—46

Examples:
STARS
>: STRING(1 .. 120)
(1 .. 120 => '*!’ );
"HOW MANY CHARACTERS ?";
QUESTION
: constant STRING
-~QUESTION’FIRST = 1,
-QUESTION’ LAST = 20 (the number of characters)

ASKTWICE
: constant STRING
NINETYSIX : constant ROMAN

QUESTION & QUESTION;
"XCVIL";
-see 3.6

Notes:

String literals (see 2.6 and 4.2) are basic operations applicable to the type
STRING and to any other one-dimensional array type whose component type
is a character type. The catenation operator is a predefined operator for the
type STRING and for one-dimensional array types; it is represented
as &. The relational operators <, <=,>, and >= are defined for values of these
types, and correspondto lexicographic order (see 4.5.2).

References: aggregate 4.3, array 3.6, catenation operator 4.5 4.5.3, character type
3.5.2, component type (of an array) 3.6, dimension 3.6, index 3.6, lexicographic order
4.5.2, positional aggregate 4.3, predefined operator 4.5, predefined type C, relational
operator 4.5 4.5.2, string literal 2.6, subtype 3.3, type 3.3
character 2.1, object 3.2, string type 3.6.3

3./

Record Types
1

A record object is a composite object consisting of named components. The
value of a record object is a composite value consisting of the valuesof its
components.

recordtypedefinition ::=
record

componentlist

end record

componentlist ::=
component_declaration {componentdeclaration}
| {component_declaration} variant_part
|

null;

componentdeclaration ::=
identifierlist

: componentsubtypedefinition
[:= expression];

componentsubtypedefinition ::=

3-47

subtypeindication

Record Types

3.7

Each component declaration declares a component of the record type.
Besides components declared by component declarations, the components of
a record type include any components declared by discriminant specifications
of the record type declaration. The identifiers of all components of a record

type must be distinct. The use of a name that denotes a record component

other than a discriminantis not allowed within the record type definition
that declares the component.
4

A componentdeclaration with several identifiers is equivalent to a sequence
of single component declarations, as explained in section 3.2. Each single
component declaration declares a record component whose subtype is
specified by the component subtype definition.

If a component declaration includes the assignment compound delimiter
followed by an expression, the expression is the default expression of
the record component; the default expression must be of the type of the
component. Default expressions are not allowed for components that are of
a limited type.

If a record type does not have a discriminant part, the same components
are present in all values of the type. If the component list of a record type
is defined by the reserved word null and there is no discriminant part,
then the record type has no components andall records of the type are null
records.

The elaboration of a record type definition creates a record type; it consists
of the elaboration of any corresponding (single) component declarations, in
the order in which they appear, including any component declaration in a
variant part. The elaboration of a component declaration consists of the
elaboration of the component subtypedefinition.

For the elaboration of a component subtype definition, if the constraint does
not depend on a discriminant(see 3.7.1), then the subtype indication is
elaborated. If, on the other hand, the constraint depends on a discriminant,

then the elaboration consists of the evaluation of any included expression
that is not a discriminant?°

33 See also Appendix G, AI-00358.
3.7

Record Types

3-48

Examples of record type declarations:
type DATE is
record
DAY
: INTEGER range 1
MONTH : MONTHNAME;
YEAR
: INTEGER range 0

31;

4000;

end record;

type COMPLEX is
record
RE :

REAL

:= 0.0;

REAL

0.0;

end record;
10

Examples of record variables:
TOMORROW,
A, B, C :

YESTERDAY
COMPLEX;

DATE;

-~ both components of A,

and C

-- are implicitly initialized to zero

Notes:

The default expression of a record componentis implicitly evaluated by the
elaboration of the declaration of a record object, in the absence of an explicit
initialization (see 3.2.1). If a component declaration has several identifiers,

the expression is evaluated once for each such componentof the object (since

the declaration is equivalent to a sequence of single componentdeclarations).
Unlike the components of an array, the components of a record need not be
of the sametype.

References: assignment compound delimiter 2.2, component 3.3, composite value
3.3, constraint 3.3, declaration 3.1, depend on a discriminant 3.7.1, discriminant3.3,
discriminant part 3.7 3.7.1, elaboration 3.9, expression 4.4, identifier 2.3, identifier
list 3.2, limited type 7.4.4, name 4.1, object 3.2, subtype 3.3, type 3.3, type mark
3.3.2, variant part 3.7.3

3.7.1

Discriminants
A discriminant part specifies the discriminants of a type. A discriminant of
a record is a componentof the record. The type of a discriminant must be
discrete.
discriminant part

::5

(discriminant_specification {; discriminant_specification})

discriminantspecification ::=
identifierlist : typemark

3—49

[:= expression]

Discriminants

3.7.1

A discriminant part is only allowed in the type declaration for a record
type, in a private type declaration or an incomplete type declaration (the
corresponding full declaration must then declare a record type), and in the
generic parameter declaration for a formal private type.

A discriminant specification with several identifiers is equivalent to a
sequence of single discriminant specifications, as explained in section
3.2. Each single discriminant specification declares a discriminant. If a
discriminant specification includes the assignment compound delimiter
followed by an expression, the expression is the default expression of the
discriminant; the default expression must be of the type of the discriminant.
Default expressions must be provided either for all or for none of the
discriminants of a discriminant part.

The use of the nameof a discriminant is not allowed in default expressions
of a discriminant part if the specification of the discriminantis itself given
in the discriminant part.

Within a record type definition the only allowed uses of the nameof a
discriminant of the record type are: in the default expressions for record

components; in a variant part as the discriminant name; and in a component

subtype definition, either as a bound in an index constraint, or to specify
a discriminant value in a discriminant constraint. A discriminant name
used in these component subtype definitions must appearby itself, not as

part of a larger expression. Such component subtype definitions and such

constraints are said to depend on a discriminant.

3.7.1.

A componentis said to depend on a discriminant if it is a record component

Each record value includes a value for each discriminant specified for the
record type; it also includes a value for each record component that does not
depend on a discriminant. The values of the discriminants determine which
other component values are in the record value.

Direct assignment to a discriminant of an object is not allowed; furthermore
a discriminantis not allowed as an actual parameter of mode in out or out,
or as a generic actual parameter of mode in out. The only allowed way to
change the value of a discriminant of a variable is to assign a (complete)
value to the variable itself. Similarly, an assignment to the variable itself
is the only allowed way to change the constraint of one of its components,if
the component subtype definition depends on a discriminant of the variable.

The elaboration of a discriminant part has noothereffect.

declared in a variant part, or a record component whose component subtype
definition depends on a discriminant,or finally, one of the subcomponents of
a componentthat itself depends on a discriminant.

Discriminants

3-50

Examples:
type BUFFER(SIZE : BUFFERSIZE :
record
POS

VALUE

BUFFERSIZE

SQUARE (SIDE

-- see 3.5.4

SIZE );

STRING (1

end record;
type

100)

INTEGER)

record
MAT

MATRIX (1

SIDE,

SIDE) ;

-- see 3.6

end record;
type

DOUBLESQUARE (NUMBER

IN TEGER)

record
LEFT

SQUARE (NUMBER) ;

RIGHT

SQUARE (NUMBER) ;

end record;

type ITEM(NUMBER : POSITIVE) i Ss

record
CONTENT : INTEGER;
no component depends on the discriminant

end record;

References: assignment 5.2, assignment compound delimiter 2.2, bound of
a range 3.5, component 3.3, component declaration 3.7, component of a record
3.7, declaration 3.1, discrete type 3.5, discriminant 3.3, discriminant constraint
3.7.2, elaboration 3.9, expression 4.4, generic formal type 12.1, generic parameter
declaration 12.1, identifier 2.3, identifier list 3.2, incomplete type declaration
3.8.1, index constraint 3.6.1, name 4.1, object 3.2, private type 7.4, private type

declaration 7.4, record type 3.7, scope 8.2, simple name 4.1, subcomponent 3.3,
subtype indication 3.3.2, type declaration 3.3.1, type mark 3.3.2, variant part 3.7.3

3./.2

Discriminant Constraints
A discriminant constraint is only allowed in a subtype indication, after a
type mark. This type mark must denote either a type with discriminants,
or an access type whose designated type is a type with discriminants. A
discriminant constraint specifies the values of these discriminants.
discriminantconstraint

(discriminantassociation {,

discriminant _association})

discriminantassociation ::

[discriminantsimplename

{| discriminant_simple _name}

3-51

=>]

expression

Discriminant Constraints

3.7.2

Each discriminant association associates an expression with one or more

discriminants. A discriminant association is said to be named if the dis-

criminants are specified explicitly by their names; it is otherwise said to be

positional. For a positional association, the (single) discriminantis implicitly
specified by position, in textual order. Named associations can be given in

any order, but if both positional and named associations are used in the
same discriminant constraint, then positional associations must occurfirst,
at their normal position. Hence once a namedassociation is used, the rest of
the discriminant constraint must use only namedassociations.
4

For a named discriminant association, the discriminant names must
denote discriminants of the type for which the discriminant constraint
is given. A discriminant association with more than one discriminant

nameis only allowed if the named discriminantsare all of the same

type. Furthermore, for each discriminant association (whether named or

positional), the expression and the associated discriminants must have the
same type. A discriminant constraint must provide exactly one value for
each discriminant of the type.

A discriminant constraint is compatible with the type denoted by a type
mark, if and only if each discriminant value belongs to the subtype of the
corresponding discriminant. In addition, for each subcomponent whose
component subtype specification depends on a discriminant, the discriminant value is substituted for the discriminant in this component subtype
specification and the compatibility of the resulting subtype indication is
checked.34

A composite value satisfies a discriminant constraint if and only if each discriminant of the composite value has the value imposed by the discriminant
constraint.

The initial values of the discriminants of an object of a type with discriminants are determinedasfollows:

For a variable declared by an object declaration, the subtype indication
of the corresponding object declaration must impose a discriminant
constraint unless default expressions exist for the discriminants; the
discriminant values are defined either by the constraint or, in its
absence, by the default expressions. The same requirement exists for

the subtype indication of a component declaration, if the type of the
record component has discriminants; and for the component subtype
indication of an array type, if the type of the array componentsis a type
with discriminants.35
34 See also Appendix G, AI-00007, AI-00319, and AI-00358.
35 See also Appendix G, AI-00014.
3.7.2

Discriminant Constraints

3-52

For a constant declared by an object declaration, the values of the
discriminants are those of the initial value if the subtype of the constant
is unconstrained; they are otherwise defined by this subtype (in the
latter case, an exception is raised if the initial value does not belong to
this subtype). The same rule applies to a generic parameter of mode in.
For an object designated by an access value, the discriminant values

must be defined by the allocator that creates the object. (The allocated

object is constrained with the corresponding discriminant values.)

For a formal parameter of a subprogram or entry, the discriminants of
the formal parameter are initialized with those of the corresponding
actual parameter. (The formal parameteris constrained if the corresponding actual parameter is constrained, and in any case if the modeis
in or if the subtype of the formal parameteris constrained.)

For a renaming declaration and for a generic formal parameter of mode
in out, the discriminants are those of the renamed object or of the
corresponding generic actual parameter.

For the elaboration of a discriminant constraint, the expressions given in
the discriminant associations are evaluated in some order that is not defined
by the language; the expression of a namedassociation is evaluated once for

each named discriminant.

14.

Examples using types declared in the previous section:
LARGE

>: BUFFER(200);

---

constrained, always 200 characters
(explicit discriminant value)

MESSAGE

: BUFFER;

----

unconstrained, initially 100
characters (default discriminant
value)

BASIS

SQUARE (5) ;

constrained,

ILLEGAL

SQUARE;

illegal,

always 5 by 5

a SQUARE must be

constrained

Note:
1s

The above rules and the rules defining the elaboration of an object declaration (see 3.2) ensure that discriminants always have a value. In particular,if
a discriminant constraint is imposed on an object declaration, each discriminant is initialized with the value specified by the constraint. Similarly, if the
subtype of a component has a discriminant constraint, the discriminants of
the component are correspondingly initialized.

3-53

Discriminant Constraints

3.7.2

References: access type 3.8, access type definition 3.8, access value 3.8, actual
parameter 6.4.1, allocator 4.8, array type definition 3.6, bound of a range 3.5,
compatible 3.3.2, component 3.8, component declaration 3.7, component subtype
indication 3.7, composite value 3.3, constant 3.2.1, constrained subtype 3.3, constraint 3.3, declaration 3.1, default expression for a discriminant 3.7, depend on a

discriminant 3.7.1, designate 3.8, designated type 3.8, discriminant 3.3, elaboration
3.9, entry 9.5, evaluation 4.5, expression 4.4, formal parameter 6.1, generic actual
parameter 12.38, generic formal parameter 12.1 12.3, mode in 6.1, modein out 6.1,

name 4.1, object 3.2, object declaration 3.2.1, renaming declaration 8.5, reserved
word 2.9, satisfy 3.3, simple name 4.1, subcomponent 3.3, subprogram 6, subtype
3.3, subtype indication 3.3.2, type 3.3, type mark 3.3.2, variable 3.2.1

3.7.3

Variant Parts
A record type with a variant part specifies alternative lists of components.
Each variant defines the components for the corresponding value or values
of the discriminant.
2

variantpart ::=

case discriminantsimplename is
variant
{variant }

end case;

variant ::=
when choice

choice}

componentlist

choice ::= simpleexpression
| discreterange | others

component_simple_name

Each variant starts with a list of choices which must be of the same type
as the discriminant of the variant part. The type of the discriminant of

a variant part must not be a generic formal type. If the subtype of ‘the
discriminantis static, then each value of this subtype must be represented
once and only oncein the set of choices of the variant part, and no other
value is allowed. Otherwise, each value of the (base) type of the discriminant
must be represented once and only once intheset of choices.
4

3.7.3

The simple expressions and discrete ranges given as choices in a variant

part must be static. A choice defined by a discrete range stands forall
values in the corresponding range (none if a null range). The choice others
is only allowed for the last variant and as its only choice; it stands for
all values (possibly none) not given in the choices of previous variants. A
component simple nameis not allowed as a choice of a variant (although it
is part of the syntax of choice).

Variant Parts

3-54

A record value contains the values of the components of a given variant if
and only if the discriminant value is equal to one of the values specified
by the choices of the variant. This rule applies in turn to any further
variant that is, itself, included in the componentlist of the given variant.

If the componentlist of a variant is specified by null, the variant has no
components.

Example of record type with a variant part:
type DEVICE is
type STATE
is

(PRINTER, DISK,
(OPEN, CLOSED) ;

DRUM);

type PERIPHERAL(UNIT : DEVICE := DISK) is

record
STATUS : STATE;
case UNIT is
when PRINTER =>
LINECOUNT : INTEGER range 1...
when others =>
CYLINDER

CYLINDERINDEX;

TRACK

TRACKNUMBER;

PAGESIZE;

end case;
end record;

Examples of record subtypes:
subtype DRUMUNIT is PERIPHERAL (DRUM) ;
subtype DISKUNIT is PERIPHERAL (DISK) ;

Examples of constrained record variables:
WRITER

: PERIPHERAL(UNIT => PRINTER) ;

ARCHIVE : DISK_UNIT;
Note:

Choices with discrete values are also used in case statements and in array

aggregates. Choices with component simple names are used in record
aggregates.
10

3-55

References: array aggregate 4.3.2, base type 3.3, component 3.3, componentlist
3.7, discrete range 3.6, discriminant 3.3, generic formal type 12.1.2, null range 3.5,
record aggregate 4.3.1, range 3.5, record type 3.7, simple expression 4.4, simple
name 4.1, static discrete range 4.9, static expression 4.9, static subtype 4.9,
subtype 3.3

Variant Parts

3.7.3

3.7.4

Operations of Record Types
1

The basic operations of a record type include the operations involved in

assignment and aggregates (unless the type is limited), membershiptests,
selection of record components, qualification, and type conversion (for
derived types).

For any object A of a type with discriminants, the basic operations also
include the following attribute:
A'CONSTRAINED

Yields the value TRUE if a discriminant constraint
applies to the object A, or if the object is a constant
(including a formal parameter or generic formal
parameter of mode in); yields the value FALSE
otherwise. If A is a generic formal parameter of mode
in out, or if A is a formal parameter of mode in out
or out and the type mark given in the corresponding

parameter specification denotes an unconstrained
type with discriminants, then the value of this
attribute is obtained from that of the corresponding
actual parameter. The value of this attribute is of the
predefined type BOOLEAN.
In addition, the attributes T’ BASE and T’ SIZE are defined for a record
type or subtype T (see 3.3.3); the attributes A’ SIZE and A’ ADDRESSare

defined for a record object A (see 13.7.2).

Besides the basic operations, the operations of a record type include the

predefined comparison for equality and inequality, unless the type is limited.
Note:

A record type is limited if the type of any of its components is limited
(see 7.4.4).
References: actual parameter 6.4.1, aggregate 4.3, assignment 5.2, attribute 4.1.4,

basic operation 3.3.3, boolean type 3.5.3, constant 3.2.1, conversion 4.6, derived type
3.4, discriminant 3.3, discriminant constraint 3.7.2, formal parameter 6.1, generic

actual parameter 12.3, generic formal parameter 12.1 12.3, limited type 7.4.4,
membership test 4.5 4.5.2, mode 6.1, object 3.2.1, operation 3.3, predefined operator
4.5, predefined type C, qualified expression 4.7, record type 3.7, relational operator
4.5 4.5.2, selected component 4.1.3, subcomponent 3.3, subtype 3.3, type 3.3

3.7.4

Operations of Record Types

3-56

3.8 Access Types
1

An object declared by an object declaration is created by the elaboration
of the object declaration and is denoted by a simple name or by some

other form of name. In contrast, there are objects that are created by the
evaluation of allocators (see 4.8) and that have no simple name. Access to
such an object is achieved by an access value returned by an allocator; the
access valueis said to designate the object.
accesstypedefinition ::= access subtypeindication

For each access type,there is a literal null which has a null access value
designating no object at all. The null value of an access type is the default
initial value of the type. Other values of an access type are obtained by
evaluation of a special operation of the type, called an allocator. Each such
access value designates an object of the subtype defined by the subtype
indication of the access type definition; this subtype is called the designated
subtype; the base type of this subtype is called the designated type. The
objects designated by the values of an access type form a collection implicitly
associated with the type.
The elaboration of an access type definition consists of the elaboration of the
subtype indication and creates an access type.
If an access object is constant, the contained access value cannot be changed
and always designates the same object. On the other hand, the value of the
designated object need not remain the same(assignment to the designated
object is allowed unless the designated typeis limited).

The only forms of constraint that are allowed after the name of an access
type in a subtype indication are index constraints and discriminant
constraints. (See sections 3.6.1 and 3.7.2 for the rules applicable to these
subtype indications.) An access value belongs to a corresponding subtype of
an access type either if the access value is the null value orif the value of

the designated object satisfies the constraint.°6
Examples:
type FRAME is access MATRIX;

see 3.6

type BUFFERNAME is access BUFFER;

see 3.7.1

36 See also Appendix G, AI-00324
3-57

Access Types

3.8

Notes:

An access value delivered by an allocator can be assigned to several access
objects. Henceit is possible for an object created by an allocator to be designated by more than one variable or constant of the access type. An access
value can only designate an object created by an allocator; in particular, it
cannot designate an object declared by an object declaration.

If the type of the objects designated by the access values is an array type
or a type with discriminants, these objects are constrained with either the
array boundsor the discriminant values supplied implicitly or explicitly for
the corresponding allocators (see 4.8).

Access valuesare called pointers or references in some other languages.

References: allocator 4.8, array type 3.6, assignment 5.2, belong to a subtype 3.3,

constant 3.2.1, constraint 3.3, discriminant constraint 3.7.2, elaboration 3.9, index
constraint 3.6.1, index specification 3.6, limited type 7.4.4, literal 4.2, name 4.1,

object 3.2.1, object declaration 3.2.1, reserved word 2.9, satisfy 3.3, simple name4.1,
subcomponent 3.3, subtype 3.3, subtype indication 3.3.2, type 3.3, variable 3.2.1

3.8.1

Incomplete Type Declarations.
1

There are no particular limitations on the designated type of an access type.
In particular, the type of a component of the designated type can be another
access type, or even the sameaccess type. This permits mutually dependent
and recursive access types. Their declarations require a prior incomplete (or
private) type declaration for one or more types.
incompletetypedeclaration ::=
type identifier

3.8.1.

[discriminantpart];

For each incomplete type declaration, there must be a corresponding
declaration of a type with the sameidentifier. The corresponding declaration
must be either a full type declaration or the declaration of a task type.
In the rest of this section, explanations are given in termsof full type
declarations; the same rules apply also to declarations of task types.
If the incomplete type declaration occurs immediately within either a
declarative part or the visible part of a package specification, then the full
type declaration must occur later and immediately within this declarative
part or visible part. If the incomplete type declaration occurs immediately
within the private part of a package, then the full type declaration must
occur later and immediately within either the private part itself, or the
declarative part of the corresponding package body.

Incomplete Type Declarations

3-58

A discriminant part must be given in the full type declaration if and only
if one is given in the incomplete type declaration; if discriminant parts are
given, then they must conform (see 6.3.1 for the conformance rules). Prior

to the end of the full type declaration, the only allowed use of a namethat
denotes a type declared by an incomplete type declaration is as the type

mark in the subtype indication of an access type definition; the only form of
constraint allowed in this subtype indication is a discriminant constraint>’

The elaboration of an incomplete type declaration creates a type. If the
incomplete type declaration has a discriminant part, this elaboration
includes that of the discriminant part: in such a case, the discriminant part
of the full type declaration is not elaborated.

Example of a recursive type:
type CELL;
-- incomplete type declaration
type LINK is access CELL;
type CELL is
record
VALUE
SUCC
PRED

:
:

INTEGER;
LINK;

LINK;

end record;
HEAD
NEXT

:
:

LINK
LINK

:=
new CELL’ (0,
:= HEAD.SUCC;

null,

null);

Examples of mutually dependent accesstypes:
type PERSON(SEX : GENDER);
type CAR;

---

incomplete type declaration
incomplete type declaration

type PERSONNAME is access PERSON;
type CARNAME
is access CAR;
type CAR is
record
NUMBER :
OWNER
:
end record;

INTEGER;
PERSONNAME;

37 See also Appendix G, AI-00007, AI-00231, and AI-00319.
3-59

Incomplete Type Declarations

3.8.1

type PERSON(SEX : GENDER) is
record
NAME
: STRING(1 .. 20);
BIRTH

AGE

DATE;
INTEGER range

VEHICLE

CAR_NAME;

130;

case SEX is
when M =>

WIFE

PERSONNAME (SEX

when F

HUSBAND

PERSONNAME (SEX => M);

F);

end case;
end record;

MYCAR, YOUR_CAR, NEXT_CAR : CAR_NAME;

---

implicitly

initialized
with null value

References: access type 3.8, access type definition 3.8, component 3.3, conform
6.3.1, constraint 3.3, declaration 3.1, declarative item 3.9, designate 3.8, discriminant constraint 3.7.2, discriminant part 3.7.1, elaboration 3.9, identifier 2.8, name
4.1, subtype indication 3.3.2, type 3.3, type mark 3.3.2

3.8.2

Operations of Access Types
1

The basic operations of an access type include the operations involved in
assignment, allocators for the access type, membership tests, qualification,

explicit conversion, and theliteral null. If the designated type is a type with
discriminants, the basic operations include the selection of the corresponding
discriminants; if the designated type is a record type, they include the
selection of the corresponding components; if the designated type is an
array type, they include the formation of indexed components andslices;

if the designated type is a task type, they include selection of entries and

entry families. Furthermore, the basic operations include the formation of a

selected component with the reserved wordall (see 4.1.3).

If the designated type is an array type, the basic operations include the
attributes that have the attribute designators FIRST, LAST, RANGE, and

LENGTH (likewise, the attribute designators of the N-th dimension). The
prefix of each of these attributes must be a value of the access type. These
attributes yield the corresponding characteristics of the designated object
(see 3.6.2).

If the designated type is a task type, the basic operations include theat-

tributes that have the attribute designators TERMINATED and CALLABLE
(see 9.9). The prefix of each of these attributes must be a value of the
access type. These attributes yield the corresponding characteristics of the
designated task objects.

3.8.2

Operations of Access Types

3-60

In addition, the attribute T’ BASE (see 3.3.3) and the representation

attributes T’ SIZE and T’STORAGE_SIZE(see 18.7.2) are defined for an

access type or subtype T; the attributes A’SIZE and A’ ADDRESSare
defined for an access object A (see 13.7.2).
5
6

Besides the basic operations, the operations of an access type include the

predefined comparison for equality and inequality.

References: access type 3.8, allocator 4.8, array type 3.6, assignment 5.2, attribute

4.1.4, attribute designator 4.1.4, base type 3.3, basic operation 3.3.3, collection 3.8,

constrained array subtype 3.6, conversion 4.6, designate 3.8, designated subtype
3.8, designated type 3.8, discriminant 3.3, indexed component 4.1.1, literal 4.2,
membership test 4.5 4.5.2, object 3.2.1, operation 3.3, private type 7.4, qualified
expression 4.7, record type 3.7, selected component 4.1.3, slice 4.1.2, subtype 3.3,
task type 9.1, type 3.3

3.9

Declarative Parts
1
2

A declarative part contains declarative items (possibly none).
declarativepart

::=

{basicdeclarativeitem} {laterdeclarativeitem}

basicdeclarativeitem ::= basicdeclaration

| representation_clause | useclause

laterdeclarativeitem ::= body

body

::= properbody

properbody

3-61

bodystub

::= subprogram_body

packagebody

task_body

The elaboration of a declarative part consists of the elaboration of the
declarative items, if any, in the order in which they are given in the
declarative part. After its elaboration, a declarative item is said to be
elaborated. Prior to the completion of its elaboration (including before the
elaboration), the declarative item is not yet elaborated.

For several forms of declarative item, the language rules (in particular scope
and visibility rules) are such that it is either impossible or illegal to use
an entity before the elaboration of the declarative item that declares this
entity. For example, it is not possible to use the nameof a type for an object
declaration if the corresponding type declaration is not yet elaborated. In
the case of bodies, the following checks are performed:

Declarative Parts

3.9

For a subprogram call, a check is made that the body of the subprogram
is already elaborated.3

For the activation of a task, a check is made that the body of the
corresponding task unit is already elaborated.39

For the instantiation of a generic unit that has a body, a check is made
that this body is already elaborated.

The exception PROGRAM_ERRORisraised if any of these checks fails.40

If a subprogram declaration, a package declaration, a task declaration, or
a generic declaration is a declarative item of a given declarative part, then
the body (if there is one) of the program unit declared by the declarative
item must itself be a declarative item of this declarative part (and must
appearlater). If the body is a body stub, then a separately compiled subunit
containing the corresponding proper body is required for the program unit
(see 10.2).

References: activation 9.3, instantiation 12.3, program_error exception 11.1, scope
8.2, subprogram call 6.4, type 3.3, visibility 8.3

Elaboration of declarations: 3.1, component declaration 3.7, deferred constant

declaration 7.4.3, discriminant specification 3.7.1, entry declaration 9.5, enumeration

literal specification 3.5.1, generic declaration 12.1, generic instantiation 12.3, incomplete type declaration 3.8.1, loop parameter specification 5.5, number declaration
3.2.2, object declaration 3.2.1, package declaration 7.2, parameter specification 6.1,
private type declaration 7.4.1, renaming declaration 8.5, subprogram declaration
6.1, subtype declaration 3.3.2, task declaration 9.1, type declaration 3.3.1
12

Elaboration of type definitions: 3.3.1, access type definition 3.8, array type

definition 3.6, derived type definition 3.4, enumeration type definition 3.5.1, integer
type definition 3.5.4, real type definition 3.5.6, record type definition 3.7
Elaboration of other constructs: context clause 10.1, body stub 10.2, compilation
unit 10.1, discriminant part 3.7.1, generic body 12.2, generic formal parameter 12.1
12.3, library unit 10.5, package body 7.1, representation clause 13.1, subprogram
body 6.3, subunit 10.2, task body 9.1, task object 9.2, task specification 9.1, use
clause 8.4, with clause 10.1.1
|

38 See also Appendix G, AI-00180 and AI-00406.
39 See also Appendix G, AI-00149.
40 See also Appendix G, AI-00430.
3.9

Declarative Parts

3-62

Chapter 4

Names and Expressions
The rules applicable to the different forms of name and expression, and to
their evaluation, are given in this chapter.

4.1

Names
Namescan denote declared entities, whether declared explicitly or implicitly
(see 3.1). Names can also denote objects designated by access values;
subcomponents andslices of objects and values; single entries, entry
families, and entries in families of entries. Finally, names can denote

attributes of any of the foregoing.
name ::= simplename
|

characterliteral

operatorsymbol

| indexed_component
| slice
| selectedcomponent | attribute
simplename ::= identifier
prefix ::= name

functioncall

A simple namefor an entity is either the identifier associated with the
entity by its declaration, or another identifier associated with the entity by a
renaming declaration.
Certain forms of name (indexed and selected components, slices, and

attributes) include a prefix that is either a nameor a function call. If the
type of a prefix is an access type, then the prefix must not be a name that
denotes a formal parameter of mode out or a subcomponentthereof.
If the prefix of a nameis a function call, then the name denotes a compo- ~

nent, a slice, an attribute, an entry, or an entry family, either of the result of

the function call, or Gf the result is an access value) of the object designated
by the result.
4-1

Names

4.1

A prefix is said to be appropriate for a type in either of the following cases:

The evaluation of a name determines the entity denoted by the name. This
evaluation has no other effect for a name that is a simple name, a character
literal, or an operator symbol.

The evaluation of a name that has a prefix includes the evaluation of the

The type of the prefix is the type considered.
The type of the prefix is an access type whose designated typeis the

type considered.

prefix, that is, of the corresponding nameor function call. If the type

of the prefix is an access type, the evaluation of the prefix includes the
determination of the object designated by the corresponding access value;

the exception CONSTRAINT_ERRORis raised if the value of the prefix

is a null access value, except in the case of the prefix of a representation
attribute (see 13.7.2).

Examples of simple names:
PI
LIMIT
COUNT
BOARD
MATRIX
RANDOM

ERROR

4.1.1.

the
the
the
the
the

simple
simple
simple
simple
simple

name
name
name
name
name

of
of
of
of
of

a number
a constant
a scalar variable
an array variable
a type

the simple name of a function

the simple name of an exception

(see
(see
(see
(see
(see

3.2.2)
3.2.1)
3.2.1)
3.6.1)
3.6)

(see 6.1)

(see 11.1)

References: access type 3.8, access value 3.8, attribute 4.1.4, belong to a type 3.3,
character literal 2.5, component 3.3, constraint_error exception 11.1, declaration 3.1,
designate 3.8, designated type 3.8, entity 3.1, entry 9.5, entry family 9.5, evaluation
4.5, formal parameter 6.1, function call 6.4, identifier 2.3, indexed component
4.1.1, mode 6.1, null access value 3.8, object 3.2.1, operator symbol 6.1, raising
of exceptions 11, renaming declarations 8.5, selected component 4.1.3, slice 4.1.2,
subcomponent 3.3, type 3.3

Indexed Components
—

4.1.1

------

An indexed component denotes either a component of an array or an entry
in a family of entries.
indexedcomponent

::= prefix(expression {,

expression})

In the case of a component of an array, the prefix must be appropriate for

an array type. The expressions specify the index values for the component;
there must be one such expression for each index position of the array type.
In the case of an entry in a family of entries, the prefix must be a name that

Indexed Components

4—2

denotes an entry family of a task object, and the expression (there must be

exactly one) specifies the index value for the individual entry.

Each expression must be of the type of the corresponding index. For the
evaluation of an indexed component, the prefix and the expressions are
evaluated in some order that is not defined by the language. The exception
CONSTRAINT_ERRORis raised if an index value does not belong to the
range of the corresponding index of the prefixing array or entry family.
Examples of indexed components:
MYSCHEDULE(SAT)

-- a component of a
-- one-dimensional array

(see 3.6.1)

PAGE (10)

-- a component of a

(see 3.6)

-- a component of a

(see 3.6.1)

BOARD (M,

-- one-dimensional array
J + 1)

-- two-dimensional array

PAGE (10) (20)
REQUEST (MEDIUM)
NEXTFRAME (L) (M,

-- a component of a component
-- an entry ina family of entries

(see 3.6)
(see 9.5)

-- a component of a function call

(see

6.1)

Notes on the examples:
Distinct notations are used for components of multidimensional arrays (such

as BOARD) and arrays of arrays (such as PAGE). The components of an
array of arrays are arrays and can therefore be indexed. Thus PAGE(10)(20)
denotes the 20th component of PAGE(10). In the last example NEXT_

FRAME(L) is a function call returning an access value which designates a
two-dimensional array.
References: appropriate for a type 4.1, array type 3.6, component 3.3, component
of an array 3.6, constraint_error exception 11.1, dimension 3.6, entry 9.5, entry
family 9.5, evaluation 4.5, expression 4.4, function call 6.4, in some order 1.6, index
3.6, name 4.1, prefix 4.1, raising of exceptions 11, returned value 5.8 6.5, task

object 9.2

4.1.2

Slices
1

A slice denotes a one-dimensional array formed by a sequence of consecutive
components of a one-dimensional array. A slice of a variable is a variable; a
slice of a constant is a constant; a slice of a valueis a value.
slice ::= prefix(discreterange)

Slices

4.1.2

The prefix of a slice must be appropriate for a one-dimensional array type.

The type of the slice is the base type of this array type. The boundsof the
discrete range define those of the slice and must be of the type of the index;
the slice is a null slice denoting a null array if the discrete range is a null
range.
For the evaluation of a namethat is a slice, the prefix and the discrete
range are evaluated in someorderthat is not defined by the language. The
exception CONSTRAINT_ERRORisraised by the evaluation of a slice, other
than a null slice, if any of the bounds of the discrete range does not belong
to the index rangeof the prefixing array. (The boundsof a null slice need
not belong to the subtype of the index.)

Examplesofslices:
STARS (1

15)

PAGE(10

10+ SIZE)

PAGE (L) (A

STARS (1

MYSCHEDULE (WEEKDAY)
STARS (5

15) (K)

---~

a slice of
15 characters

(see 3.6.3)
(see 3.6 and 3.2.1)

a slice of

components

---

a slice of
the array PAGE (L)

(see 3.6)

-~-

a null slice

(see 3.6.3)

by subtype

SIZE

bounds given
same as STARS (K)

provided that K

is ind...

(see 3.6 and 3.5.1)
(see 3.6.3)

Notes:

For a one-dimensional array A, the name A(N .. N) is a slice of one component; its type is the base type of A. On the other hand, A(N) is a component
of the array A and hasthe corresponding componenttype.

References: appropriate for a type 4.1, array 3.6, array type 3.6, array value 3.8,
base type 3.3, belong to a subtype 3.8, bound of a discrete range 3.6.1, component
3.3, component type 3.3, constant 3.2.1, constraint 3.3, constraint_error exception

11.1, dimension 3.6, discrete range 3.6, evaluation 4.5, index 3.6, index range 3.6,
name 4.1, null array 3.6.1, null range 3.5, prefix 4.1, raising of exceptions 11, type
3.3, variable 3.2.1

4.1.2

Slices

4.1.3. Selected Components
1

Selected componentsare used to denote record components, entries, entry
families, and objects designated by access values; they are also used as
expanded names as described below.
selectedcomponent

::= prefix.selector

selector ::= simplename
|

characterliteral

operatorsymbol

all

The following four forms of selected components are used to denote a
discriminant, a record component, an entry, or an object designated by an
access value:
(a)

A discriminant:

The selector must be a simple name denoting a discriminant of an
object or value. The prefix must be appropriate for the type of this
object or value.
(b)

A component of a record:

The selector must be a simple name denoting a componentof a record
object or value. The prefix must be appropriate for the type of this
object or value.

For a component of a variant, a check is made that the values of
the discriminants are such that the record has this component. The
exception CONSTRAINT_ERRORisraised if this check fails.
(c)

Asingle entry or an entry family of a task:
The selector must be a simple name denoting a single entry or an entry
family of a task. The prefix must be appropriate for the type of this
task.

(d)

An object designated by an access value:
The selector must be the reserved word all. The value of the prefix
must belong to an access type.

4-5

A selected component of one of the remaining two formsis called an
expanded name. In each case the selector must be either a simple name, a
characterliteral, or an operator symbol. A function call is not allowed as the
prefix of an expanded name. An expanded name can denote:
(e)

An entity declared in the visible part of a package:

Selected Components

4.1.3

The prefix must denote the package. The selector must be the simple
name, characterliteral, or operator symbol of the entity. 4
(f)

An entity whose declaration occurs immediately within a named
construct:

The prefix must denote a construct that is either a program unit, a

block statement, a loop statement, or an accept statement. In the case
of an accept statement, the prefix must be either the simple name of
the entry or entry family, or an expanded name ending with such a
simple name (that is, no index is allowed). The selector must be the

simple name, character literal, or operator symbol of an entity whose
declaration occurs immediately within the construct.
18

This form of expanded nameis only allowed within the construct

itself (including the body and any subunits, in the case of a program

unit). A name declared by a renaming declaration is not allowed
as the prefix. If the prefix is the name of a subprogram or accept
statement and if there is more than one visible enclosing subprogram
or accept statement of this name, the expanded nameis ambiguous,

independently of the selector.*
19

If, according to the visibility rules, there is at least one possible interpre-

tation of the prefix of a selected component as the nameof an enclosing
subprogram or accept statement, then the only interpretations considered
are those of rule (f), as expanded names(no interpretations of the prefix as
a function call are then considered).
The evaluation of a namethat is a selected componentincludes the evaluation of the prefix.

Examples of selected components:
NEXTCAR.OWNER
-—NEXTCAR.OWNER.AGE --

TOMORROW .MONTH

a record component
a record component

WRITER.UNIT

a record component

MINCELL(H).VALUE

CONTROL. SEIZE

a record component

(a discriminant)

a record component

----

of the result of
the function call
MINCELL (H)

an entry of the

task CONTROL

(see 3.7)

(see 3.8.1)
(see 3.8.1
(see 3.7.3)

(see

6.1 and 3.8.1)

(see

9.1 and 9.2)

1 See also Appendix G, AI-00016, AI-00187, and AI-00412.
2 See also Appendix G, AI-00016 and AI-00412.
4.1.3

Selected Components

4—6

POOL (K) .WRITE

NEXTCAR.ALL

---

an entry of the
task POOL (K)

the object designated

by the access variable

-22

(see

NEXTCAR

9.1 and 9.2)

(see 3.8.1)

Examples of expanded names:
TABLEMANAGER.INSERT --

a procedure of the

visible part of

a package

---

an operator of the
visible part of

a package

-~--

a variable declared
in a procedure body

(see

6.5)

---

a variable declared
ina task unit

(see

9.12)

BUFFER. READ

an entry of a task unit

(see 9.12)

SWAP . TEMP

---

a variable declared in
a block statement

(see 5.6)

KEYMANAGER. "<"

DOTPRODUCT .SUM
BUFFER. POOL

STANDARD . BOOLEAN

the name of a

predefined type

(see 7.5)

(see 7.4.2)

(see 8.6 and C)

Note:
23

For a record with components that are other records, the above rules imply
that the simple name must be given at each level for the name of a subcomponent. For example, the name NEXT_CAR.OWNER.BIRTH.MONTH
cannot be shortened (NEXT_CAR.OWNER.MONTHis not allowed).
References: accept statement 9.5, access type 3.8, access value 3.8, appropriate
for a type 4.1, block statement 5.6, body of a program unit 3.9, character literal
2.5, component of a record 3.7, constraint_error exception 11.1, declaration 3.1,
designate 3.8, discriminant 3.3, entity 3.1, entry 9.5, entry family 9.5, function
call 6.4, index 3.6, loop statement 5.5, object 3.2.1, occur immediately within 8.1,

operator 4.5, operator symbol 6.1, overloading 8.3, package 7, predefined type C,
prefix 4.1, procedure body 6.3, program unit 6, raising of exceptions 11, record 3.7,

record component 3.7, renaming declaration 8.5, reserved word 2.9, simple name

4.1, subprogram 6, subunit 10.2, task 9, task object 9.2, task unit 9, variable 3.7.3,
variant 3.7.3, visibility 8.3, visible part 3.7.3

Selected Components

4.1.3

4.1.4

Attributes
1

An attribute denotes a basic operation of an entity given by a prefix.

attribute ::= prefix’attributedesignator

attributedesignator ::=
simplename

[(universalstatic_expression) ]

The applicable attribute designators depend on the prefix. An attribute can
be a basic operation delivering a value; alternatively it can be a function,
a type, or a range. The meaning of the prefix of an attribute must be

determinable independently of the attribute designator and independently of
the fact that it is the prefix of an attribute?
4

The attributes defined by the language are summarized in Annex A. In
addition, an implementation may provide implementation-defined attributes;
their description must be given in Appendix F. The attribute designator of
any implementation-defined attribute must not be the sameas that of any

language-defined attribute.
5

The evaluation of a namethat is an attribute consists of the evaluation of

the prefix.
Notes:

The attribute designators DIGITS, DELTA, and RANGE have the same

identifier as a reserved word. However, no confusion is possible since
an attribute designator is always preceded by an apostrophe. The only
predefined attribute designators that have a universal expression are those
for certain operations of array types (see 3.6.2).

Examplesof attributes:
COLOR’ FIRST

—~- minimum value of
-- the enumeration
-- type COLOR

RAINBOW’ BASE’ FIRST -- same as COLOR’ FIRST

REAL’ DIGITS
BOARD’ LAST (2)

BOARD’ RANGE (1)

(see 3.3.1 and 3.5)
(see 3.3.2 and 3.3.3)

-- precision of the
-- type REAL

(see 3.5.7 and 3.5.8)

-- upper bound of the
-- second dimension of
-- BOARD

(see 3.6.1 and 3.6.2)

-- index range of the
-- first dimension of
-- BOARD

(see 3.6.1 and 3.6.2)

3 See also Appendix G, AI-00015.
4.1.4

Attributes

4-8

POOL (K)’ TERMINATED -- TRUE if task POOL (K)
~~ is terminated
for

(see 9.2

and 9.9)

and 13.7.2)

DATE’ SIZE

-- number of bits

-- records of type DATE

(see 3.7

MESSAGE’ ADDRESS

-~- address of the record
-- variable MESSAGE

(see 3.7.2 and 13.7.2)

References: appropriate for a type 4.1, basic operation 3.3.3, declared entity 3.1,

name 4.1, prefix 4.1, reserved word 2.9, simple name 4.1, static expression 4.9, type
3.3, universal expression 4.10

4.2

Literals
A literal is either a numeric literal, an enumerationliteral, the literal null,

or a string literal. The evaluation of a literal yields the corresponding value.

Numericliterals are the literals of the types universal_integer and universal_

real. Enumeration literals include character literals and yield values of the
corresponding enumeration types. Theliteral null yields a null access value
which designates no objects atall.
A string literal is a basic operation that combines a sequence of characters
into a value of a one-dimensional array of a character type; the bounds
of this array are determined according to the rules for positional array

aggregates (see 4.3.2). For a null string literal, the upper bound is the
predecessor, as given by the PRED attribute, of the lower bound. The
evaluation of a null string literal raises the exception CONSTRAINT_
ERRORif the lower bound does not have a predecessor(see 3.5.5).

The type of a string literal and likewise the type of the literal null must
be determinable solely from the context in which this literal appears,
excluding the literal itself, but using the fact that the literal null is a
value of an access type, and similarly that a string literal is a value of a
one-dimensional array type whose componenttype is a charactertype.
The character literals corresponding to the graphic characters contained
within a string literal must be visible at the place of the string literal
(although these characters themselves are not used to determine the type of
the string literal).

4-9

Literals

4.2

Examples:
3.1415926536

1345

CLUBS
aN

a real literal

an integer literal

a string literal

---

"SOME TEXT"

an enumeration literal
a character literal

References: access type 3.8, aggregate 4.3, array 3.6, array bound 3.6, array type
3.6, character literal 2.5, character type 3.5.2, component type 3.3, constraint_error
exception 11.1, designate 3.8, dimension 3.6, enumeration literal 3.5.1, graphic
character 2.1, integer literal 2.4, null access value 3.8, null literal 3.8, numeric
literal 2.4, object 3.2.1, real literal 2.4, string literal 2.6, type 3.3, universal_integer
type 3.5.4, universal_real type 3.5.6, visibility 8.3

4.3 Aggregates
1

An aggregate is a basic operation that combines component values into a
composite value of a record or array type.

aggregate

::=

(component association {,

componentassociation ::=
[choice {|

choice} => ]

component_association})

expression

Each component association associates an expression with components
(possibly none). A component association is said to be named if the
components are specified explicitly by choices; it is otherwise said to
be positional. For a positional association, the (single) componentis

implicitly specified by position, in the order of the corresponding component

declarations for record components, in index order for array components.

Namedassociations can be given in any order (except for the choice
others), but if both positional and namedassociations are used in the
same aggregate, then positional associations must occurfirst, at their

normal position. Hence once a namedassociation is used, the rest of the

aggregate must use only namedassociations. Aggregates containing a single

component association must always be given in named notation. Specific
rules concerning component associations exist for record aggregates and
array aggregates.

Choices in component associations have the same syntax as in variant parts
(see 3.7.3). A choice that is a component simple nameis only allowed in a

record aggregate. For a component association, a choice that is a simple
expression or a discrete range is only allowed in an array aggregate; a choice

that is a simple expression specifies the component at the corresponding
index value; similarly a discrete range specifies the components at the index
4.3

Aggregates

4-10

values in the range. The choice others is only allowed in a component
association if the association appears last and has this single choice; it
specifies all remaining components,if any.
6

Each component of the value defined by an aggregate must be represented
once and only once in the aggregate. Hence each aggregate must be

complete and a given componentis not allowed to be specified by more than

one choice.
7

The type of an aggregate must be determinable solely from the context

in which the aggregate appears, excluding the aggregateitself, but using
the fact that this type must be composite and not limited. The type of an
aggregate in turn determines the required type for each of its components.
Notes:

The above rule implies that the determination of the type of an aggregate
cannot use any information from within the aggregate. In particular, this
determination cannot use the type of the expression of a component association, or the form or the type of a choice. An aggregate can always be
distinguished from an expression enclosed by parentheses: this is a consequence of the fact that named notation is required for an aggregate with a
single component.

References: array aggregate 4.3.2, array type 3.6, basic operation 3.3.3, choice
3.7.3, component 3.3, composite type 3.3, composite value 3.3, discrete range 3.6,
expression 4.4, index 3.6, limited type 7.4.4, primary 4.4, record aggregate 4.3.1,
record type 3.7, simple expression 4.4, simple name 4.1, type 3.3, variant part 3.7.3

4.3.1

Record Aggregates
1

If the type of an aggregate is a record type, the component names given
as choices must denote components (including discriminants) of the record
type. If the choice othersis given as a choice of a record aggregate, it must
represent at least one component. A component association with the choice
others or with more than one choiceis only allowed if the represented
components areall of the same type. The expression of a component
association must have the type of the associated record components.°

The value specified for a discriminant that governs a variant part must
be given by a static expression (note that this value determines which
dependent components must appearin the record value).

4 See also Appendix G, AI-00169 and AI-00293.
5 See also Appendix G, AI-00244.
4—11

Record Aggregates

4.3.1

For the evaluation of a record aggregate, the expressions given in the
component associations are evaluated in someorder that is not defined
by the language. The expression of a namedassociation is evaluated once
for each associated component. A check is made that the value of each
subcomponent of the aggregate belongs to the subtype of this subcomponent.
The exception CONSTRAINT_ERRORisraised if this check fails.
Example of a record aggregate with positional associations:
(4,

JULY,

1776)

see 3.7

Examples of record aggregates with named associations:
(DAY => 4, MONTH => JULY, YEAR => 1776)
(MONTH => JULY, DAY => 4, YEAR => 1776)
(DISK, CLOSED,
(UNIT => DISK,

TRACK => 5, CYLINDER => 12)
STATUS => CLOSED, CYLINDER => 9,

-see 3.7.3
TRACK => 1)

Example of component association with several choices:
(VALUE

SUCC|PRED

=> new CELL’ (0,

null,

null))

see

3.8.1

The allocator is evaluated twice:

SUCC and PRED designate different cells

Note:

For an aggregate with positional associations, discriminant values appear
first since the discriminantpart is given first in the record type declaration;
they must be in the sameorderasin the discriminantpart.
References: aggregate 4.3, allocator 4.8, choice 3.7.3, component association
4.3, component name 3.7, constraint 3.3, constraint_error exception 11.1, depend
on a discriminant 3.7.1, discriminant 3.3, discriminant part 3.7.1, evaluate 4.5,
expression 4.4, in some order 1.6, program 10, raising of exceptions 11, record
component 3.7, record type 3.7, satisfy 3.3, static expression 4.9, subcomponent 3.3,
subtype 3.3.2, type 3.3, variant part 3.7.3

4.3.2

Array Aggregates
1

If the type of an aggregate is a one-dimensional array type, then each choice
must specify values of the index type, and the expression of each component
association must be of the component type.
If the type of an aggregate is a multidimensional array type, an

n-dimensional aggregate is written as a one-dimensional aggregate, in

which the expression specified for each componentassociation is itself written as an (n — 1)-dimensional aggregate whichis called a subaggregate; the
index subtype of the one-dimensional aggregate is given by the first index
4.3.2

Array Aggregates

4-12

position of the array type. The samerule is used to write a subaggregate
if it is again multidimensional, using successive index positions. A string
literal is allowed in a multidimensional aggregate at the place of a onedimensional array of a character type. In what follows, the rules concerning
array aggregates are formulated in terms of one-dimensional aggregates.
3

Apart from a final component association with the single choice others, the
rest (if any) of the component associations of an array aggregate must be
either all positional or all named. A named association of an array aggregate
is only allowed to have a choice that is not static, or likewise a choice that

is a null range, if the aggregate includes a single component association and
this component association has a single choice. An otherschoiceis static if
the applicable index constraintis static. ®
4

The bounds of an array aggregate that has an others choice are determined
by the applicable index constraint. An others choice is only allowed if
the aggregate appears in one of the following contexts (which defines the
applicable index constraint):

(a)

The aggregate is an actual parameter, a generic actual parameter,
the result expression of a function, or the expression that follows
an assignment compounddelimiter. Moreover, the subtype of the
corresponding formal parameter, generic formal parameter, function
result, or object is a constrained array subtype.
For an aggregate that appears in such a context and contains an

association with an others choice, named associations are allowed for

other associations only in the case of a (nongeneric) actual parameter
or function result. If the aggregate is a multidimensional array, this
restriction also applies to each of its subaggregates.
7

(b)

The aggregate is the operand of a qualified expression whose type mark
denotes a constrained array subtype.

(c)

The aggregate is the expression of the component association of an
enclosing (array or record) aggregate. Moreover, if this enclosing
aggregate is a multidimensional array aggregate thenit is itself in one

of these three contexts. ’

The bounds of an array aggregate that does not have an others choice
are determined as follows. For an aggregate that has namedassociations,
the bounds are determined by the smallest and largest choices given. For
a positional aggregate, the lower bound is determined by the applicable
index constraint if the aggregate appears in one of the contexts (a) through

6 See also Appendix G, AI-00190 and AI-00310.
7 See also Appendix G, AI-00177.

4-13

Array Aggregates

4.3.2

(c); otherwise, the lower bound is given by S’ FIRST where S is the index

subtype; in either case, the upper bound is determined by the numberof

components.

The evaluation of an array aggregate that is not a subaggregate proceeds
in two steps. First, the choices of this aggregate and of its subaggregates,
if any, are evaluated in some order that is not defined by the language.
Second, the expressions of the component associations of the array aggregate
are evaluated in some order that is not defined by the language; the
expression of a named association is evaluated once for each associated
component. The evaluation of a subaggregate consists of this second step
(the first step is omitted since the choices have already been evaluated).

~+=For the evaluation of an aggregate that is not a null array, a check is
made that the index values defined by choices belong to the corresponding
index subtypes, and also that the value of each subcomponentof the aggregate belongs to the subtype of this subcomponent. For an n-dimensional
multidimensional aggregate, a check is madethatall (n — 1)-dimensional
subaggregates have the same bounds. The exception CONSTRAINT_ERROR
is raised if any of these checksfails.®
Note:

The allowed contexts for an array aggregate including an others choice

Examples of array aggregates with positional associations:

are such that the bounds of such an aggregate are always known from the
context.

(7,

14.

TABLE’ (5,

others => 0)

see 3.6

Examples of array aggregates with named associations:
(1
(1

..
..

5 => (1 .. 8 => 0.0))
N => new CELL)

---

two-dimensional
N new cells,

in particular for N = 0

TABLE’ (2 | 4 | 10 => 1, others => 0)
SCHEDULE’ (MON .. FRI => TRUE,
others => FALSE)
SCHEDULE’ (WED

SUN

FALSE,

others

see 3.6

TRUE)

8 See also Appendix G, AI-00018, AI-00019, AI-00265, and AI-00318.

4.3.2

Array Aggregates

4-14

Examples of two-dimensional array aggregates:
~- Three aggregates for the same value of type MATRIX

(see 3.6):

((1.1, 1.2, 1.3), (2.1, 2.2, 2.3))
(1 => (1.1, 1.2, 1.3), 2 => (2.1, 2.2, 2.3))
(l => (1 => 1.1, 2 => 1.2, 3 => 1.3),
2 => (1 => 2.1, 2 => 2.2, 3 => 2.3))
is

Examples of aggregatesasinitial values:
A : TABLE := (7, 9, 5, 1, 3, 2, 4, 8,
B : TABLE := TABLE’ (2 | 4 | 10 => 1,
others => 0);
C

D
E
F

:
:
:

constant MATRIX
(1 .. 5 => (1

0); -- A(1)=7, A(10)=0
-- B(1)=0, B(10)=1

:=
.. 8 => 0.0));

-- C’FIRST(1)=1,
-- C’ LAST (2) =8

BITVECTOR(M .. N) := (M..N => TRUE);
-- see 3.6
BITVECTOR(M .. N) := (others => TRUE);
STRING(1 .. 1) := (1 => ’F’);
=-- a one component aggregate:
--

same

"F"

References: actual parameter 6.4.1, aggregate 4.3, array type 3.6, assignment
compound delimiter 5.2, choice 3.7.3, component 3.3, component association 4.3,
component type 3.3, constrained array subtype 3.6, constraint 3.3, constraint_error
exception 11.1, dimension 3.6, evaluate 4.5, expression 4.4, formal parameter6.1,
function 6.5, in some order 1.6, index constraint 3.6.1, index range 3.6, index
subtype 3.6, index type 3.6, named componentassociation 4.3, null array 3.6.1,
object 3.2, positional component association 4.3, qualified expression 4.7, raising of
exceptions 11, static expression 4.9, subcomponent3.3, type 3.3

4.4 Expressions
1
2

An expression is a formula that defines the computation of a value.
expression ::=
|
|

relation
relation
relation

{and relation}
{or relation}
{xor relation}

|
|

relation
relation

{and then relation}
{or else relation}

relation ::=
simpleexpression [relationaloperator simpleexpression]
| simpleexpression [not] in range
|

simpleexpression

[not]

in typemark

simpleexpression ::=
[unaryaddingoperator] term {binaryaddingoperator term}
term ::= factor {multiplyingoperator factor}
factor ::= primary

4-15

[** primary]

| abs primary | not primary

Expressions

4.4

Each primary has a value and a type. The only names allowed as primaries
are named numbers; attributes that yield values; and names denoting
objects (the value of such a primaryis the value of the object) or denoting
values. Names that denote formal parameters of mode out are not allowed
as primaries; names of their subcomponents are only allowed in the case of
discriminants.
The type of an expression depends only on the type of its constituents and
on the operators applied; for an overloaded constituent or operator, the

determination of the constituent type, or the identification of the appropriate
operator, depends on the context. For each predefined operator, the operand
and result types are given in section 4.5.

Examples of primaries:
4.0
PI
(1 ..

SUM

--—--

10 => QO)

variable

INTEGER’ LAST

attribute

(LINECOUNT + 10)

parenthesized expression

SINE (X)
COLOR’ (BLUE)
REAL (M*N)

real literal
named number
array aggregate

----

function call
qualified expression
conversion

Examples of expressions:
VOLUME

primary

not DESTROYED

factor

2*LINECOUNT

-4.0
-4.0 +A
B*¥*2 - 4,.0*A*C
PASSWORD (1 .. 3)

term

= "BWV"

COUNT in SMALLINT

relation

INDEX = 0 or ITEMHIT

expression

COUNT not in SMALLINT
(COLD and SUNNY)

A** (B*x*C)

4.4

Simple expression
Simple expression
simple expression
relation

Expressions

or WARM

relation

expression
(parentheses are required)
expression
(parentheses are required)

4-16

References: aggregate 4.3, allocator 4.8, array aggregate 4.3.2, attribute 4.1.4,
binary adding operator 4.5 4.5.8, context of overload resolution 8.7, exponentiating

operator 4.5 4.5.6, function call 6.4, multiplying operator 4.5 4.5.5, name 4.1, named

number3.2, null literal 3.8, numeric literal 2.4, object 3.2, operator 4.5, overloading
8.3, overloading an operator 6.7, qualified expression 4.7, range 3.5, real literal 2.4,

relation 4.5.1, relational operator 4.5 4.5.2, result type 6.1, string literal 2.6, type

3.3, type conversion 4.6, type mark 3.3.2, unary adding operator 4.5 4.5.4,
variable 3.2.1

4.5 Operators and Expression Evaluation
The language defines the following six classes of operators. The corresponding operator symbols (except /=), and only those, can be used as designators
in declarations of functions for user-defined operators. They are given in the
order of increasing precedence.
logicaloperator

and

xor

relationaloperator

::=

«==

binaryaddingoperator

22=

unaryaddingoperator

multiplyingoperator

::=

| mod |

highestprecedenceoperator

::=

abs

rem

not

The short-circuit control forms and then and or else have the same
precedence as logical operators. The membership tests in and not in have
the same precedence asrelational operators.
For a term, simple expression, relation, or expression, operators of higher
precedence are associated with their operands before operators of lower
precedence. In this case, for a sequence of operators of the same precedence
level, the operators are associated in textual order from left to right;
parentheses can be used to imposespecific associations.
The operandsof a factor, of a term, of a simple expression, or of a relation,

and the operands of an expression that does not contain a short-circuit
control form, are evaluated in someorderthat is not defined by the language
(but before application of the corresponding operator). The right operand of
a short-circuit control form is evaluated if and only if the left operand has a
certain value (see 4.5.1).

For each form of type declaration, certain of the above operators are
predefined, that is, they are implicitly declared by the type declaration.
For each such implicit operator declaration, the names of the parameters

are LEFT and RIGHT for binary operators; the single parameteris called

4-17

Operators and Expression Evaluation

4.5

RIGHTfor unary adding operators and for the unary operators abs and
not. The effect of the predefined operators is explained in subsections 4.5.1

through 4.5.7.

The predefined operations on integer types either yield the mathematically
correct result or raise the exception NUMERIC_ERROR.A predefined

operation that delivers a result of an integer type (other than universal_
integer) can only raise the exception NUMERIC_ERRORif the mathematical
result is not a value of the type. The predefined operations on real types
yield results whose accuracy is defined in section 4.5.7. A predefined
operation that delivers a result of a real type (other than wniversal_real) can
only raise the exception NUMERIC_ERRORif the result is not within the
range of the safe numbersof the type, as explained in section 4.5.7.2
8

Examples of precedence:
not SUNNY or WARM
X > 4.0 and Y > 0.0

---

same as
same as

—-4,0*A**2
abs(1 + A)

---

same as -(4.0 * (A**2))
same as (abs (1 + A)) +B

y** (-3)
A/B*C
A + (B + C)

----

(not SUNNY) or WARM
(X > 4.0) and (Y > Q.0)

parentheses are necessary
same as (A/B)*C
evaluate B + C before adding it to A

References: designator 6.1, expression 4.4, factor 4.4, implicit declaration 3.1, in

some order 1.6, integer type 3.5.4, membership test 4.5.2, name 4.1, numeric_error

exception 11.1, overloading 6.6 8.7, raising of an exception 11, range 3.5, real type
3.5.6, relation 4.4, safe number 3.5.6, short-circuit control form 4.5 4.5.1, simple
expression 4.4, term 4.4, type 3.3, type declaration 3.3.1, universal_integer type
3.5.4, universal_real type 3.5.6

4.5.1

Logical Operators and Short-circuit Control Forms
1

The following logical operators are predefined for any boolean type and any
one-dimensional array type whose components are of a boolean type; in
either case the two operands have the sametype.

Operator

Operation

Operand type

Result type

and

conjunction

any boolean type

same boolean type

array of boolean

same array type

components

9 See also Appendix G, AI-00387.
4.5.1

Logical Operators and Short-circuit Control! Forms

4-18

Operator

Operation

Operand type

Result type

inclusive
disjunction

any boolean type

same boolean type

array of boolean

same array type

any boolean type

same boolean type

array of boolean

same array type

components

xor

exclusive
disjunction

components

The operations on arrays are performed on a component-by-component basis
on matching components, if any (as for equality, see 4.5.2). The bounds of
the resulting array are those of the left operand. A check is madethat for
each component of the left operand there is a matching componentof the
right operand, and vice versa. The exception CONSTRAINT_ERRORis
raised if this check fails.1°

The short-circuit control forms and then andorelse are defined for two
operandsof a boolean type and deliver a result of the same type. Theleft
operand of a short-circuit control form is always evaluated first. If the
left operand of an expression with the control form and then evaluates to
FALSE, the right operand is not evaluated and the value of the expression
is FALSE. If the left operand of an expression with the control form or else
evaluates to TRUE, the right operand is not evaluated and the value of the
expression is TRUE. If both operands are evaluated, and then delivers the
same result as and, and or else delivers the same result as or.

Note:
5

The conventional meaning of the logical operators is given by the following

A and B

AorB

A xor B

TRUE

FALSE

truth table:

TRUE

FALSE

TRUE

FALSE

TRUE

FALSE

TRUE

FALSE

10 See also Appendix G, AI-00426 and AI-00431.
4-19

Logical Operators and Short-circuit Control Forms

4.5.1

Examples of logical operators:
SUNNY or WARM
FILTER(1 .. 10)

and FILTER(15

24)

see 3.6.1

Examples of short-circuit control forms:
NEXTCAR.OWNER /= null
and then NEXTCAR.OWNER.AGE > 25 ~- see 3.8.1
N = 0 or else A(N)

4.5.2

References: array type 3.6, boolean type 3.5.3, bound of an index range 3.6.1,
component of an array 3.6, constraint_error exception 11.1, dimension 3.6, false
boolean value 3.5.3, index subtype 3.6, matching components of arrays 4.5.2, null
array 3.6.1, operation 3.3, operator 4.5, predefined operator 4.5, raising of exceptions
11, true boolean value 3.5.3, type 3.3

Relational Operators and Membership Tests
1

The equality and inequality operators are predefined for any type that
is not limited. The other relational operators are the ordering operators
< (less than), <= (less than or equal), > (greater than), and >= (greater
than or equal). The ordering operators are predefined for any scalartype,
and for any discrete array type, that is, a one-dimensional array type
whose components are of a discrete type. The operands of each predefined
relational operator have the same type. The result type is the predefined
type BOOLEAN.

The relational operators have their conventional meaning: the result is
equal to TRUEif the corresponding relation is satisfied; the result is FALSE
otherwise. The inequality operator gives the complementary result to the
equality operator: FALSE if equal, TRUE if not equal.

Operator

Operation

Operand type

Result type

equality and
inequality

any type

BOOLEAN

test for
ordering

any scalar type

BOOLEAN

discrete array type

BOOLEAN

4.5.2

= HITVALUE

Equality for the discrete types is equality of the values. For real operands
whose values are nearly equal, the results of the predefined relational
operators are given in section 4.5.7. Two access values are equal either if

Relational Operators and Membership Tests

4-20

they designate the sameobject, or if both are equal to the null value of the
access type.

For two array values or two record values of the same type, the left operand
is equal to the right operand if and only if for each componentof the left
operand there is a matching component of the right operand andvice versa;
and the values of matching components are equal, as given by the predefined
equality operator for the component type. In particular, two null arrays of
the same type are always equal; two null records of the same type are
always equal.
For comparing two records of the same type, matching components are those
which have the same componentidentifier.
For comparing two one-dimensional arrays of the same type, matching
components are those (if any) whose index values match in the following
sense: the lower bounds of the index ranges are defined to match, and
the successors of matching indices are defined to match. For comparing
two multidimensional arrays, matching components are those whose index
values match in successive index positions.
If equality is explicitly defined for a limited type, it does not extend to
composite types having subcomponentsof the limited type (explicit definition
of equality is allowed for such composite types).
The ordering operators <, <=,>, and >= that are defined for discrete array

types correspondto lexicographic order using the predefined order relation
of the component type. A null array is lexicographically less than any
array having at least one component. In the case of nonnull arrays, the
left operand is lexicographically less than the right operandif thefirst
componentof the left operand is less than that of the right; otherwise the
left operandis lexicographically less than the right operand onlyif their first
components are equal andthetail of the left operand is lexicographically
less than that of the right (the tail consists of the remaining components
beyondthefirst and can be null).
The membership tests in and not in are predefined for all types. The
result type is the predefined type BOOLEAN.For a membership test with
a range, the simple expression and the bounds of the range must be of the
same scalar type; for a membership test with a type mark, the type of the
simple expression must be the base type of the type mark. The evaluation
of the membership test in yields the result TRUE if the value of the simple
expression is within the given range,or if this value belongs to the subtype
denoted by the given type mark; otherwise this evaluation yields the result
FALSE (for a value of a real type, see 4.5.7). The membership test not in
gives the complementary result to the membership test in.

4-21

Relational Operators and Membership Tests

4.5.2

Examples:
X /= Y
Woe

wan

WaAA"

and

WBN

Wau

and

Wan

waAAN
<

_—

TRUE

_—

TRUE

MYCAR = null

-- true if MYCAR has been set

MYCAR = YOUR_CAR

~- true if we both share

-- to null

(see 3.8.1)

-- the same car

MYCAR. ALL = YOUR_CAR. ALL -- true if the two cars
-- are identical
N not ini... 10
TODAY in MON .. FRI
TODAY in WEEKDAY
ARCHIVE in DISKUNIT

--~--

range membership test
range membership test
subtype membership test
subtype membership test

(see 3.5.1)
(see 3.7.3)

Notes:
12.

No exception is ever raised by a predefined relational operator or by a

Ifa record type has components that depend on discriminants, two values
of this type have matching componentsif and only if their discriminants
are equal. Two nonnull arrays have matching componentsif and only if the
value of the attribute LENGTH(N)for each index position N is the samefor
both.

membership test, but an exception can be raised by the evaluation of the
operands.

References: access value 3.8, array type 3.6, base type 3.3, belong to a subtype

3.3, boolean predefined type 3.5.38, bound of a range 3.5, component 3.3, component

identifier 3.7, component type 3.3, composite type 3.8, designate 3.8, dimension
3.6, discrete type 3.5, evaluation 4.5, exception 11, index 3.6, index range 3.6,

limited type 7.4.4, null access value 3.8, null array 3.6.1, null record 3.7, object
3.2.1, operation 3.3, operator 4.5, predefined operator 4.5, raising of exceptions 11,
range 3.5, record type 3.7, scalar type 3.5, simple expression 4.4, subcomponent3.3,
successor 3.5.5, type 3.3, type mark 3.3.2

4.5.3.

Binary Adding Operators
1

4.5.3

The binary adding operators + and — are predefined for any numeric type
and have their conventional meaning. The catenation operators & are
predefined for any one-dimensional array type that is not limited.

Binary Adding Operators

4-22

Operator

Operation

addition

—

subtraction

catenation

Left operand

Right operand
type

Result type

any numeric

same numeric

type

any numeric

same numeric

type

same numeric

type

any array type

Same array type

samearray
type

any array type

the component

same array

type

the component
type

any array type

same array
type

the component

type

any array

type

For real types, the accuracy of the result is determined by the operand type
(see 4.5.7).

If both operands are one-dimensional arrays, the result of the catenation
is a one-dimensional array whose length is the sum of the lengthsof its
operands, and whose components comprise the componentsof the left
operand followed by the componentsof the right operand. The lower bound
of this result is the lower boundof the left operand, unless the left operand
is a null array, in which case the result of the catenation is the right
operand.

If either operand is of the component type of an array type, the result of
the catenation is given by the above rules, using in place of this operand
an array having this operand as its only component and having the lower
bound of the index subtype of the array type as its lower bound.
The exception CONSTRAINT_ERRORisraised by catenation if the upper

bound of the result exceeds the range of the index subtype, unless the
result is a null array. This exception is also raised if any operandis of the
component type but has a value that does not belong to the component

subtype.

Examples:

4—23

Zt 0.1

2 must be of a real type

"A" &€ "BCD"

catenation of two string literals

‘A’

& "BCD"

---

catenation of a character literal
anda string literal

"R’

& "RB!

catenation of two character literals

Binary Adding Operators

4.5.3

References: array type 3.6, character literal 2.5, component type 3.3, constraint_
error exception 11.1, dimension 3.6, index subtype 3.6, length of an array 3.6.2,
limited type 7.4.4, null array 3.6.1, numeric type 3.5, operation 3.3, operator 4.5,
predefined operator 4.5, raising of exceptions 11, range of an index subtype 3.6.1,
real type 3.5.6, string literal 2.6, type 3.3

4.5.4 Unary Adding Operators
1

The unary adding operators + and — are predefined for any numeric type and
have their conventional meaning. For each of these operators, the operand
and the result have the sametype.

Operator

Operation

Operand type

Result type

identity

any numeric type

same numeric type

—

negation

any numeric type

same numeric type

4.5.5

References: numeric type 3.5, operation 3.3, operator 4.5, predefined operator 4.5,
type 3.3

Multiplying Operators
1

The operators * and / are predefined for any integer and anyfloating point
type and have their conventional meaning; the operators mod and rem are
predefined for any integer type. For each of these operators, the operands
and the result have the same base type. For floating point types, the
accuracy of the result is determined by the operandtype(see 4.5.7).

Operator
#

Operation

Operand type

multiplication

any integer type

Result type
same integer
type

any floating
point type
/

mod

4.5.5

Multiplying Operators

integer division

any integer type

floating division

any floating
point type

modulus

any integer type

samefloating
point type
same integer

type

samefloating
point type
same integer

type

4—24

Operator

Operation

Operand type

rem

remainder

any integer type

same integer

type

Integer division and remainderare defined by the relation
A =

Result type

(A/B)*B +

(A rem B)

where (A rem B) has the sign of A and an absolute value less than the
absolute value of B. Integer division satisfies the identity
(-A)/B = -(A/B) = A/(-B)

The result of the modulus operation is such that (A mod B) hasthe sign of
B and an absolute value less than the absolute value of B; in addition, for

some integer value N, this result must satisfy the relation
A = B*N +

For each fixed point type, the following multiplication and division operators,
with an operandof the predefined type INTEGER,are predefined.

Operator

Operation

multiplication

(A mod B)

division

Left operand
type

Right
operand
type

any fixed

INTEGER

any fixed
point type

same as
right

any fixed
point type

INTEGER

same as
left

point type

Result type

same as

left

Integer multiplication of fixed point values is equivalent to repeated
addition. Division of a fixed point value by an integer does not involve

a change in type but is approximate (see 4.5.7)1!

Finally, the following multiplication and division operators are declared in
the predefined package STANDARD. These two special operators apply to
operandsofall fixed point types (it is a consequence of other rules that they
cannot be renamedor given as generic actual parameters).

11 See also Appendix G, AI-00475.
4-25

Multiplying Operators

4.5.5

Left
operand

Operator Operation

Right
operand

type

type!

Result type

multiplication

any fixed
point type

universal_fixed

division

any fixed
point type

universal_fixed

1See also Appendix G, AI-00020 and AI-00376.

Multiplication of operands of the sameor of different fixed point typesis
exact and delivers a result of the anonymouspredefined fixed point type
universal_fixed whose delta is arbitrarily small. The result of any such

multiplication must always be explicitly converted to some numeric type.

This ensures explicit control of the accuracy of the computation. The same

considerations apply to division of a fixed point value by another fixed point
value. No other operators are defined for the type universal_fixed.'?
12

The exception NUMERIC_ERRORis raised by integer division, rem, and

Examples:

mod if the right operandis zero.?

I
J
K

:
:
:

INTEGER
INTEGER
INTEGER

:= 1;
:= 2;
:= 3;

REAL digits

F
G

:
:

FRACTION delta 0.0001
FRACTION delta 0.0001

Y : REAL digits 6

:= 1.0;

:= 2.0;
:= 0.1;
:= 0.1;

see 3.5.7

see 3.5.9

Expression

Value

Result type

I*J

sameas I and J, that is, INTEGER

K/J

same as K and J, that is, INTEGER

K mod J

same as K and J, that is, INTEGER

X/Y

0.5

same as X and Y, that is, REAL

12 See also Appendix G, AI-00235.
13 See also Appendix G, AI-00387.
4.5.5

Multiplying Operators

4-26

Expression

Value

Result type

B/2

0.05

same as F, that is, FRACTION

3*F

0.3

same as F, that is, FRACTION

F*G

0.01

universal_fixed, conversion needed

FRACTION(F*G)

0.01

FRACTION,as stated by the conversion

REAL(J)*Y

4.0

REAL,the type of both operands after conversion
of J

Notes:
14

For positive A and B, A/B is the quotient and A rem is the remainder
when is divided by B. The following relations are satisfied by the rem
operator:
A
(-A)

4-27

(-B)
B

=
A rem B
= ~(A rem B)

For any integer K, the following identity holds:
A

i¢

rem
rem

mod

(A + K*B) mod B

The relations between integer division, remainder, and modulusareillus-

trated by the following table:
A

A/B

A rem B

A mod B

—5

—2

—5

—2

—-4,

—5

—2

—3

—5

—2

—5

—2

—1

-10

—2

—i1

—2

—1

-12

—2

Multiplying Operators

4.5.5

4.5.6

A/B

Arem B

A mod B

—13

—2

—3

—14

—2

—4

—10

—5

—11

—5

—]

—1

—12

—5

—2

—13

—5

—3

—14

—5

—4

References: actual parameter 6.4.1, base type 3.3, declaration 3.1, delta of a fixed
point type 3.5.9, fixed point type 3.5.9, floating point type 3.5.7, generic formal
subprogram 12.1, integer type 3.5.4, numeric type 3.5, numeric_error exception 11.1,
predefined operator 4.5, raising of exceptions 11, renaming declaration 8.5, standard
predefined package 8.6, type conversion 4.6

Highest Precedence Operators
1

The highest precedence unary operator abs is predefined for any numeric
type. The highest precedence unary operator not is predefined for any
boolean type and any one-dimensional array type whose components have a
boolean type.
Operator

Operation

Operand type

Result type

abs

absolute value

any numeric type

same numeric type

not

logical negation

any boolean type

same boolean type

array of boolean

same array type

components

The operator not that applies to a one-dimensional array of boolean components yields a one-dimensional boolean array with the same bounds; each
component of the result is obtained by logical negation of the corresponding
component of the operand(that is, the component that has the same index

value).

The highest precedence exponentiating operator ** is predefined for each
integer type and for each floating point type. In either case the right
operand, called the exponent, is of the predefined type INTEGER.

4.5.6

Highest Precedence Operators

4-28

Operator

Operation

exponentiation

Left operand
type

Right
operand
type

Result type

any integer
type

INTEGER

same as
left

any floating
point type

INTEGER

same as
left

Exponentiation with a positive exponent is equivalent to repeated multiplication of the left operand by itself, as indicated by the exponent and from
left to right. For an operand of a floating point type, the exponent can be
negative, in which case the value is the reciprocal of the value with the
positive exponent. Exponentiation by a zero exponent delivers the value one.
Exponentiation of a value of a floating point type is approximate (see 4.5.7).
Exponentiation of an integer raises the exception CONSTRAINT_ERRORfor
a negative exponent.!4

References: array type 3.6, boolean type 3.5.3, bound of an array 3.6.1, component
of an array 3.6, constraint_error exception 11.1, dimensionality 3.6, floating point
type 3.5.9, index 3.6, integer type 3.5.4, multiplication operation 4.5.5, predefined
operator 4.5, raising of exceptions 11

4.5.7

Accuracy of Operations with Real Operands
1

A real subtype specifies a set of model numbers.15° Both the accuracy
required from any basic or predefined operation giving a real result, and the
result of any predefined relation between real operands are defined in terms
of these model numbers.

A model interval of a subtype is any interval whose bounds are model
numbers of the subtype. The model interval associated with a value that
belongs to a real subtype is the smallest model interval (of the subtype) that
includes the value. (The model interval associated with a model numberof a
subtype consists of that numberonly.)

For any basic operation or predefined operator that yields a result of a real
subtype, the required bounds on the result are given by a model interval
defined as follows:

The result model interval is the smallest model interval (of the result
subtype) that includes the minimum and the maximum ofall the

values obtained by applying the (exact) mathematical operation, when
14 See also Appendix G, AI-00137.
15 See also Appendix G, AI-00407.
4-29

Accuracy of Operations with Real Operands

4.5.7

each operand is given any value of the model interval (of the operand
subtype) defined for the operand. 16

The modelinterval of an operandthatis itself the result of an operation,

other than an implicit conversion, is the result model interval of this
operation.

The model interval of an operand whose value is obtained by implicit
conversion of a universal expression is the model interval associated
with this value within the operand subtype.

The result model interval is undefined if the absolute value of one of the

above mathematical results exceeds the largest safe numberof the result

type. Whenever the result model interval is undefined, it is highly desirable

that the exception NUMERIC_ERRORberaised if the implementation

cannot produce an actual result that is in the range of safe numbers.

This is, however, not required by the language rules, in recognition of the
fact that certain target machines do not permit easy detection of overflow

situations. The value of the attribute MACHINEOVERFLOWSindicates

whether the target machine raises the exception NUMERIC_ERRORin
overflow situations (see 13.7.3)!
8

The safe numbers of a real type are defined (see 3.5.6) as a superset of the
model numbers, for which error bounds follow the same rules as for model

numbers. Any definition given in this section in terms of model intervals
can therefore be extended to safe intervals of safe numbers. A consequence
of this extension is that an implementation is not allowed to raise the
exception NUMERIC_ERRORwhentheresult interval is a safe interval.

For the result of exponentiation, the model interval defining the bounds
on the result is obtained by applying the above rules to the sequence of
multiplications defined by the exponent, and to the final division in the case
of a negative exponent.

For the result of a relation between two real operands, consider for each

operand the model interval (of the operand subtype) defined for the operand;
the result can be any value obtained by applying the mathematical comparison to values arbitrarily chosen in the corresponding operand model
intervals. If either or both of the operand modelintervals is undefined (and
if neither of the operand evaluations raises an exception) then the result of
the comparison is allowed to be any possible value (thatis, either TRUE or
FALSE).

16 See also Appendix G, AI-00516.
17 See also Appendix G, AI-00387.
4.5.7

Accuracy of Operations with Real Operands

4-30

The result of a membership test is defined in terms of comparisons of the

operand value with the lower and upper boundsof the given range or type

mark (the usual rules apply to these comparisons).
Note:

For a floating point type the numbers 15.0, 3.0, and 5.0 are always model

numbers. Hence X/Y where X equals 15.0 and Y equals 3.0 yields exactly
5.0 according to the above rules. In the general case, division does not yield
model numbers and in consequence one cannot assumethat (1.0/X)*X = 1.0.
References: attribute 4.1.4, basic operation 3.3.3, bound of a range 3.5, error

bound 3.5.6, exponentiation operation 4.5.6, false boolean value 3.5.3, floating point
type 3.5.9, machine_overflows attribute 13.7.1, membership test 4.5.2, model number
3.5.6, multiplication operation 4.5.5, numeric_error exception 11.1, predefined
operation 3.3.3, raising of exceptions 11, range 3.5, real type 3.5.6, relation 4.4,
relational operator 4.5.2 4.5, safe number 3.5.6, subtype 3.3, true boolean value

3.5.3, type conversion 4.6, type mark 3.3.2, universal expression 4.10

4.6 Type Conversions
1

The evaluation of an explicit type conversion evaluates the expression

given as the operand, and converts the resulting value to a specified target
type. Explicit type conversions are allowed between closely related types as
defined below.
typeconversion ::= typemark (expression)

The target type of a type conversion is the base type of the type mark. The
type of the operand of a type conversion must be determinable independently
of the context (in particular, independently of the target type). Furthermore,
the operand of a type conversion is not allowed to be a literal null, an
allocator, an aggregate, or a string literal; an expression enclosed by

parentheses is allowed as the operand of a type conversion only if the
expression alone is allowed.
A conversion to a subtype consists of a conversion to the target type followed
by a check that the result of the conversion belongs to the subtype. A
conversion of an operandof a given type to the type itself is allowed.
The other allowed explicit type conversions correspond to the following three

cases:
(a)

4-31

Numeric types

Type Conversions

4.6

The operand can be of any numeric type; the value of the operandis
converted to the target type which must also be a numeric type. For
conversions involving real types, the result is within the accuracy of
the specified subtype (see 4.5.7). The conversion of a real value to an
integer type roundsto the nearest integer; if the operand is halfway
between two integers (within the accuracy of the real subtype) rounding
may be either up or down.
(b)

10
11

Derived types
The conversion is allowed if one of the target type and the operand type

is derived from the other, directly or indirectly, or if there exists a third
type from which both types are derived, directly or indirectly.
(c)

Array types
The conversion is allowed if the operand type and the target type are
array types that satisfy the following conditions: both types must have
the same dimensionality; for each index position the index types must
either be the sameor be convertible to each other; the component
types must be the same; finally, if the component type is a type with

discriminants or an access type, the component subtypes mustbeeither
both constrained or both unconstrained. If the type mark denotes an
unconstrained array type, then, for each index position, the bounds of
the result are obtained by converting the bounds of the operand to the
corresponding index type of the target type. If the type mark denotes
a constrained array subtype, then the boundsof the result are those
imposed by the type mark. In either case, the value of each component
of the result is that of the matching componentof the operand
(see 4.5.2).

In the case of conversions of numeric types and derived types, the exception
CONSTRAINT_ERRORis raised by the evaluation of a type conversion if
the result of the conversion fails to satisfy a constraint imposed by the type
mark.

In the case of array types, a check is made that any constraint on the
component subtype is the same for the operand array type as for the target
array type. If the type mark denotes an unconstrained array type and
if the operandis not a null array, then, for each index position, a check
is made that the bounds of the result belong to the corresponding index
subtype of the target type. If the type mark denotes a constrained array
subtype, a check is made that for each component of the operand thereis a
matching component of the target subtype, and vice versa. The exception
CONSTRAINT_ERRORis raised if any of these checks fails.1®

18 See also Appendix G, AI-00313.
4.6

Type Conversions

4-32

If a conversion is allowed from one type to another, the reverse conversion is
also allowed. This reverse conversion is used where an actual parameter of
mode in out or out has the form of a type conversion of a (variable) name
as explained in section 6.4.1.

Apart from the explicit type conversions, the only allowed form of type
conversion is the implicit conversion of a value of the type universal_integer
or universal_real into another numeric type. An implicit conversion of an
operand of type universal_integer to another integer type, or of an operand of
type universal_real to another real type, can only be applied if the operand
is either a numeric literal, a named number, or an attribute; such an

operandis called a convertible universal operand in this section. An implicit
conversion of a convertible universal operand is applied if and only if the
innermost complete context (see 8.7) determines a unique (numeric) target
type for the implicit conversion, and there is no legal interpretation of this
context without this conversion.
Notes:

The rules for implicit conversions imply that no implicit conversion is ever
applied to the operand of an explicit type conversion. Similarly, implicit
conversions are not applied if both operands of a predefined relational
operator are convertible universal operands.
The language allows implicit subtype conversions in the case of array types
(see 5.2.1). An explicit type conversion can have the effect of a change of
representation (in particular see 13.6). Explicit conversions are also used for
actual parameters (see 6.4).
Examples of numeric type conversion:
REAL (2*J)
INTEGER (1.6)
INTEGER(-0.4)

----

value is converted to floating point
value is 2
value is 0

Example of conversion between derived types:
type AFORM is new BFORM;
X
Y
Xx

4-33

A_FORM;

: BFORM;
A FORM(Y);
—_—

B_FORM(X);

the reverse conversion

Type Conversions

4.6

Examples of conversions between array types:
type SEQUENCE is array

of INTEGER;

12);

SEQUENCE (LEDGER)

bounds are those of LEDGER

LEDGER

(INTEGER range <>)

subtype DOZEN is SEQUENCE(1
:

array(l

100)

SEQUENCE (LEDGER(31

DOZEN (LEDGER(31

42))

of INTEGER;

42))

-—-

bounds

bounds are those of DOZEN

are

and

Examples of implicit conversions:
X

INTEGER

:= 2;

X + 1+ 2
|
1+2+X

—-- implicit conversion of
-- each integer literal
)

-- implicit conversion of
-- each integer literal

X +

(1 + 2)

—-- implicit conversion of
-- each integer literal

(1 + 1)

—-- no implicit conversion:
-- the type is universal_integer

A’ LENGTH = B’ LENGTH

-- no implicit conversion:
-- the type is universal_ integer

C : constant := 3 + 2; -- no implicit conversion:
-- the type is universalinteger
X = 3 andl =2

-- implicit conversion of 3,
-- but not of 1 and 2

References: actual parameter 6.4.1, array type 3.6, attribute 4.1.4, base type 3.3,
belong to a subtype 3.3, component 3.3, constrained array subtype 3.6, constraint_
error exception 11.1, derived type 3.4, dimension 3.6, expression 4.4, floating point
type 3.5.7, index 3.6, index subtype 3.6, index type 3.6, integer type 3.5.4, matching
component 4.5.2, mode 6.1, name 4.1, named number3.2, null array 3.6.1, numeric

literal 2.4, numeric type 3.5, raising of exceptions 11, real type 3.5.6, representation
13.1, statement 5, subtype 3.3, type 3.3, type mark 3.3.2, unconstrained array type
3.6, universal_integer type 3.5.4, universal_real type 3.5.6, variable 3.2.1

4.7 Qualified Expressions
1
2

4.7

A qualified expression is used to state explicitly the type, and possibly the
subtype, of an operand that is the given expression or aggregate.
qualified_expression ::=

typemark’ (expression)

Qualified Expressions

type_mark’aggregate

4-34

The operand must have the same type as the base type of the type mark.
The value of a qualified expression is the value of the operand. The
evaluation of a qualified expression evaluates the operand and checks that
its value belongs to the subtype denoted by the type mark. The exception
CONSTRAINT_ERRORis raised if this check fails.
Examples:
type MASK is (FIX, DEC, EXP, SIGNIF);
type CODE is (FIX, CLA, DEC, TNZ, SUB);
PRINT (MASK! (DEC) );

for J in CODE’ (FIX)

.. CODE’ (DEC)

PRINT (CODE’ (DEC));

DEC is of type MASK
DEC is of type CODE

loop ... -- qualification
-- needed for

-~ either FIX
-- or DEC

for J in CODE range FIX .. DEC loop ...

-- qualification
-- unnecessary

for J in CODE’ (FIX)

-- qualification
-- unnecessary

.. DEC loop ...

-- for DEC
DOZEN’ (1

7 => 2,

others => 0)

-- see 4.6

Notes:

Wheneverthe type of an enumeration literal or aggregate is not known from
the context, a qualified expression can be used to state the type explicitly.

For example, an overloaded enumeration literal must be qualified in the
following cases: when given as a parameter in a subprogram call to an
overloaded subprogram that cannot otherwise be identified on the basis
of remaining parameteror result types, in a relational expression where
both operands are overloaded enumeration literals, or in an array or loop
parameter range where both bounds are overloaded enumerationliterals.
Explicit qualification is also used to specify which one of a set of overloaded
parameterless functions is meant, or to constrain a value to a given subtype.
References: aggregate 4.3, array 3.6, base type 3.8, bound of a range 3.5, constraint_error exception 11.1, context of overload resolution 8.7, enumeration literal
3.5.1, expression 4.4, function 6.5, loop parameter 5.5, overloading 8.5, raising of
exceptions 11, range 3.3, relation 4.4, subprogram 6, subprogram call 6.4, subtype
3.3, type 3.3, type mark 3.3.2

4—35

Qualified Expressions

4.7

4.8

Allocators
1

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

::=

new subtypeindication

new qualifiedexpression

The type of the object created by an allocator is the base type of the type

mark given in either the subtype indication or the qualified expression. For
an allocator with a qualified expression, this expression defines the initial
value of the created object. The type of the access value returned by an
allocator must be determinable solely from the context, but using the fact
that the value returned is of an access type having the named designated
type.

The only allowed forms of constraint in the subtype indication of an allocator
are index and discriminant constraints. If an allocator includes a subtype
indication and if the type of the object created is an array type or a type
with discriminants that do not have default expressions, then the subtype
indication must either denote a constrained subtype, or include an explicit

index or discriminant constraint.

If the type of the created object is an array type or a type with discriminants,
then the created object is always constrained. If the allocator includes a
subtype indication, the created object is constrained either by the subtype
or by the default discriminant values. If the allocator includes a qualified
expression, the created object is constrained by the boundsor discriminants
of the initial value. For other types, the subtype of the created object is the
subtype defined by the subtype indication of the access type definition.19
For the evaluation of an allocator, the elaboration of the subtype indication
or the evaluation of the qualified expression is performedfirst. The new
object is then created. Initializations are then performed as for a declared
object (see 3.2.1); the initialization is considered explicit in the case of a
qualified expression; any initializations are implicit in the case of a subtype
indication. Finally, an access value that designates the created object is
returned.
An implementation must guarantee that any object created by the evaluation
of an allocator remains allocated for as long as this object or one of its
subcomponents is accessible directly or indirectly, that is, as long as it can
be denoted by some name. Moreover, if an object or one of its subcomponents
belongs to a task type,it is considered to be accessible as long as the task is
19 See also Appendix G, AI-00150, AI-00331, and AI-00397.
4.8

Allocators

4—36

not terminated. An implementation may (but need not) reclaim the storage
occupied by an object created by an allocator, once this object has become
inaccessible.7”
In VAX Ada, storage is reclaimed only upon leaving the innermost block
statement, subprogram body, or task body that encloses the access type
declaration. In other words, storage for an inaccessible object of an access
type is not reclaimed until the collection allocated for the access type is
reclaimed(see also 13.2). For more detailed information on VAX Ada storage
allocation and deallocation, see the VAX Ada Run-Time Reference Manual.

When an application needs closer control over storage allocation for objects

designated by values of an access type, such control may be achieved by one
or more of the following means:
(a)

The total amountof storage available for the collection of objects of an
access type can be set by meansof a length clause (see 13.2).

(b)

The pragma CONTROLLEDinforms the implementation that automatic storage reclamation must not be performed for objects designated
by values of the access type, except upon leaving the innermost block
statement, subprogram body, or task body that encloses the access type

declaration, or after leaving the main program.
pragma CONTROLLED

A pragma CONTROLLEDfor a given access type is allowed at the
same places as a representation clause for the type (see 13.1). This
pragmais not allowed for a derived type”!

(accesstypesimplename);

(c)

The explicit deallocation of the object designated by an access value
can be achieved by calling a procedure obtained by instantiation of the
predefined generic library procedure UNCHECKED_DEALLOCATION
(see 13.10.1).

The exception STORAGE_ERRORis raised by an allocator if there is not
enough storage. Note also that the exception CONSTRAINT_ERRORcan be
raised by the evaluation of the qualified expression, by the elaboration of the
subtype indication, or by the initialization?

20 See also Appendix G, AI-00356.
21 See also Appendix G, AI-00294.
22 See also Appendix G, AI-00397.
4-37

Allocators

4.8

—

14.

Examples for access types declared in section 3.8:
new CELL’ (0, null, null)

-- initialized explicitly

new CELL’ (VALUE => 0,
SUCC => null,

PRED => null)

-- initialized explicitly

new CELL

—-- not initialized

new MATRIX(1

new MATRIX’ (1

10,

1...

10 =>

20)

-- the bounds only

-- are given
20 => 0.0))

new BUFFER (100)

-- the discriminant

-- only is given

new BUFFER’ (SIZE => 80,
POS => 0,

VALUE =>

-- initialized
—- explicitly

80 => ‘A’))

-- initialized
-- explicitly

References: access type 3.8, access type definition 3.8, access value 3.8, array type
3.6, block statement 5.6, bound of an array 3.6.1, collection 3.8, constrained subtype
3.3, constraint 3.3, constraint_error exception 11.1, context of overload resolution

8.7, derived type 3.4, designate 3.8, discriminant 3.3, discriminant constraint 3.7.2,
elaboration 3.9, evaluation of a qualified expression 4.7, generic procedure 12.1,
index constraint 3.6.1, initial value 3.2.1, initialization 3.2.1, instantiation 12.3,

length clause 13.2, library unit 10.1, main program 10.1, name 4.1, object 3.2.1,

object declaration 3.2.1, pragma 2.8, procedure 6, qualified expression 4.7, raising of

exceptions 11, representation clause 13.1, simple name 4.1, storage_error exception
11.1, subcomponent 3.3, subprogram body 6.3, subtype 3.3, subtype indication 3.3.2,
task body 9.1, task type 9.2, terminated task 9.4, type 3.3, type declaration 3.3.1,
type mark 3.3.2 type with discriminants 3.3

4.9 Static Expressions and Static Subtypes
1

Certain expressions of a scalar type are said to be static. Similarly, certain
discrete ranges are said to be static, and the type marksof certain scalar
subtypes are said to denote static subtypes.

An expression of a scalar type is said to be static if and only if every primary

is one of those listed in (a) through (h) below, every operator denotes a

predefined operator, and the evaluation of the expression delivers a value

(that is, it does not raise an exception):2°
3

(a)

An enumeration literal (including a characterliteral).

23 See also Appendix G, AI-00128, AI-00190, and AI-00219.
4.9

Static Expressions and Static Subtypes

4-38

(b)

A numericliteral.

(c)

A named number.

(d)

A constant explicitly declared by a constant declaration with a static

(e)

A function call whose function nameis an operator symbol that denotes
a predefined operator, including a function name that is an expanded
name; each actual parameter must also be a static expression.

(f)

A language-defined attribute of a static subtype; for an attribute that is

(g)

A qualified expression whose type mark denotes a static subtype and

(h)

A static expression enclosed in parentheses.

A static range is a range whose boundsare static expressions. A static

subtype, and initialized with a static expression.”

a function, the actual parameter must also be a static expression.

whose operandis a static expression.

range constraint is a range constraint whose rangeis static. A static
subtype is either a scalar base type, other than a generic formal type; or a
scalar subtype formed by imposing on a static subtype either a static range
constraint, or a floating or fixed point constraint whose range constraint, if
any, is static. A static discrete range is either a static subtype or a static

range. A static index constraint is an index constraint for which each index

subtype of the corresponding array type is static, and in which each discrete

range is static. A static discriminant constraint is a discriminant constraint

for which the subtype of each discriminant is static, and in which each

expression is static.2°
Notes:

The accuracy of the evaluation of a static expression having a real typeis

Array attributes are not static: in particular, the RANGEattribute is not

defined by the rules given in section 4.5.7. If the result is not a model number (or a safe number) of the type, the value obtained by this evaluation at
compilation time need not be the sameas the value that would be obtained
by an evaluation at run time.
static.

24 See also Appendix G, AI-00001 and AI-00163.
25 See also Appendix G, AI-00023, AI-00251, and AI-00409.
4-39

Static Expressions and Static Subtypes

4.9

References: actual parameter 6.4.1, attribute 4.1.4, base type 3.3, bound of a

range 3.5, character literal 2.5, constant 3.2.1, constant declaration 3.2.1, discrete
range 3.6, discrete type 3.5, enumeration literal 3.5.1, exception 11, expression 4.4,
function 6.5, generic actual parameter 12.3, generic formal type 12.1.2, implicit
declaration 3.1, initialize 3.2.1, model number 3.5.6, named number 3.2, numeric

literal 2.4, predefined operator 4.5, qualified expression 4.7, raising of exceptions
11, range constraint 3.5, safe number 3.5.6, scalar type 3.5, subtype 3.3, type mark
3.3.2

4.10 Universal Expressions
1

A universal_expression is either an expression that delivers a result of type

The sameoperations are predefined for the type universal_integer as for any
integer type. The same operations are predefined for the type universal_real
as for any floating point type. In addition, these operations include the
following multiplication and division operators:

Operator Operation

Left operand
type

Right operand
type

universal_real

—universal_
integer

universal_real

universal_
integer

universal_real

_—_universal_
integer

universal_real

universal_integer or one that delivers a result of type wniversal_real.

multiplication

division

Result type

The accuracy of the evaluation of a universal expression of type universal_
real is at least as good as that of the most accurate predefined floating
point type supported by the implementation, apart from universal_real
itself. Furthermore, if a universal expression is a static expression, then the

evaluation must be exact.?®

For the evaluation of an operation of a nonstatic universal expression, an
implementation is allowed to raise the exception NUMERIC_ERRORonly
if the result of the operation is a real value whose absolute value exceeds
the largest safe number of the most accurate predefined floating point type
(excluding uwniversal_real), or an integer value greater than SYSTEM.MAX_
INT or less than SYSTEM.MIN_INT.2?

26 See also Appendix G, AI-00103, AI-00209, and AI-00405.
27 See also Appendix G, AI-00181 and AI-00387.
4.10

Universal Expressions

4—40

Note:

It is a consequence of the above rules that the type of a universal expression
is universal_integer if every primary contained in the expression is of this
type (excluding actual parameters of attributes that are functions, and
excluding right operands of exponentiation operators) and that otherwise the
type is universal_real.
Examples:
1+1
abs (-10)*3

-- 2
-- 30

KILO

constant

:= 1000;

LONG

constant

:= FLOAT’ DIGITS*2;

MEGA : constant := KILO*KILO;
HALF PI

constant

PI/2;

-- 1000000

DEGTORAD : constant :
HALFPI/90;
RADTODEG : constant :
1.0/DEG_TORAD;
-- equivalent to
-- 1.0/((3.1415926536/2)/90)

-- see 3.2.2

References: actual parameter 6.4.1, attribute 4.1.4, evaluation of an expression
4.5, floating point type 3.5.9, function 6.5, integer type 3.5.4, multiplying operator
4.5 4.5.5, predefined operation 3.3.3, primary 4.4, real type 3.5.6, safe number 3.5.6,
system.max_int 13.7, system.min_int 13.7, type 3.3, universal_integer type 3.5.4,
universal_real type 3.5.6

4—41

Universal Expressions

4.10

Chapter 5

Statements
1

A statement defines an action to be performed; the process by which a
statement achievesits action is called execution of the statement.

This chapter describes the general rules applicable to all statements.
Somespecific statements are discussed in later chapters. Procedurecall
statements are described in chapter 6 on subprograms. Entry call, delay,
accept, select, and abort statements are described in chapter 9 on tasks.
Raise statements are described in chapter 11 on exceptions, and code
statements in chapter 18. The remaining forms of statements are presented
in this chapter.

References: abort statement 9.10, accept statement 9.5, code statement 13.8,
delay statement 9.6, entry call statement 9.5, procedure call statement 6.4, raise
statement 11.3, select statement 9.7

5.1

Simple and Compound Statements—Sequencesof
Statements
1

A statementis either simple or compound. A simple statement encloses no
other statement. A compound statement can enclose simple statements and
other compound statements.
sequenceofstatements
Statement
{label}

::= statement

{statement}

::=
simplestatement

{label}

compound_statement

| raisestatement

5—1

codestatement

Simple and Compound Statements—Sequences of Statements

5.1

compoundstatement
|
|

ifstatement

::=

loopstatement
acceptstatement

| casestatement

| blockstatement
| selectstatement

label ::= <<label_simple_name>>
nullstatement ::= null;

A statement is said to be labeled by the label name of any label of the
statement. A label name, and similarly a loop or block name,is implicitly
declared at the end of the declarative part of the innermost block statement,
subprogram body, package body, task body, or generic body that encloses the

labeled statement, the named loop statement, or the named block statement,

as the case may be. For a block statement without a declarative part, an
implicit declarative part (and preceding declare) is assumed.
4

The implicit declarations for different label names, loop names, and block
namesoccur in the sameorder as the beginnings of the corresponding
labeled statements, loop statements, and block statements. Distinct
identifiers must be used for all label, loop, and block names that are
implicitly declared within the body of a program unit, including within
block statements enclosed by this body, but excluding within other enclosed
program units (a program unit is either a subprogram, a package, a task

unit, or a generic unit).
5

Execution of a null statement has no othereffect than to pass to the next

The execution of a sequence of statements consists of the execution of the
individual statements in succession until the sequence is completed, or a
transfer of control takes place. A transfer of control is caused either by

action.

the execution of an exit, return, or goto statement; by the selection of a

terminate alternative; by the raising of an exception; or (indirectly) by the
execution of an abort statement.
7

Examples of labeled statements:
<<HERE>> <<ICI>> <<AQUI>> <<HIER>> null;
<<AFTER>> X := 1;

Note:

The scope of a declaration starts at the place of the declaration itself (see

8.2). In the case of a label, loop, or block name,it follows from this rule that

the scope of the implicit declaration starts before thefirst explicit occurrence
of the corresponding name,since this occurrenceis either in a statement
label, a loop statement, a block statement, or a goto statement. An implicit
declaration in a block statement may hide a declaration given in an outer
5.1

Simple and Compound Statements—Sequences of Statements

5-2

program unit or block statement (according to the usual rules of hiding
explained in section 8.3).
9

References: abort statement 9.10, accept statement 9.5, assignment statement
5.2, block name 5.6, block statement 5.6, case statement 5.4, code statement 13.8,
declaration 3.1, declarative part 3.9, delay statement 9.6, entry call statement 9.5,
exception 11, exit statement 5.7, generic body 12.1, generic unit 12, goto statement
5.9, hiding 8.3, identifier 2.3, if statement 5.3, implicit declaration 3.1, loop name
5.5, loop statement 5.5, package 7, package body 7.1, procedure call statement 6.4,

program unit 6, raise statement 11.3, raising of exceptions 11, return statement 5.8,

scope 8.2, select statement 9.7, simple name 4.1, subprogram 6, subprogram body
6.3, task 9, task body 9.1, task unit 9.1, terminate alternative 9.7.1, terminated

task 9.4

5.2 Assignment Statement
1

An assignment statement replaces the current value of a variable with a
new value specified by an expression. The namedvariable andthe righthand side expression must be of the same type; this type must not be a
limited type.
assignmentstatement

::=

variablename := expression;

For the execution of an assignment statement, the variable name and the
expression are first evaluated, in some order that is not defined by the
language. A check is then madethat the value of the expression belongs to
the subtype of the variable, except in the case of a variable that is an array
(the assignment then involves a subtype conversion as described in section
5.2.1). Finally, the value of the expression becomes the new value of the
variable!

The exception CONSTRAINT_ERRORis raised if the above-mentioned
subtype check fails; in such a case the current value of the variableis left
unchanged. If the variable is a subcomponent that depends on discriminants
of an unconstrained record variable, then the execution of the assignment
is erroneousif the value of any of these discriminants is changed by this
execution.

1 See also Appendix G, AI-00407.
5-3

Assignment Statement

5.2

Examples:
VALUE := MAXVALUE - 1;
SHADE

:= BLUE;

NEXTFRAME (F) (M,

:= 2.5;

U := DOTPRODUCT (V, W);

WRITER :=

(STATUS

=> OPEN,

UNIT

=> PRINTER,

LINECOUNT => 60);

NEXTCAR.ALL :=

see 4.1.1

see 6.5

-- see 3.7.3
--

see 3.8.1

Examples of constraint checks:
J

INTEGER range 1

Ho
-

I:
K

(72074, null);

10;

20;

identical ranges
compatible ranges

will raise the exception CONSTRAINTERROR if K > 10

Notes:

5.2

The values of the discriminants of an object designated by an access value
cannot be changed (not even by assigning a complete value to the object
itself) since such objects, created by allocators, are always constrained
(see 4.8); however, subcomponents of such objects may be unconstrained.

If the right-hand side expression is either a numericliteral or named
number, or an attribute that yields a result of type wniversal_integer or
universal_real, then an implicit type conversion is performed, as described
in section 4.6.

The determination of the type of the variable of an assignment statement
may require consideration of the expression if the variable name can be interpreted as the nameof a variable designated by the access value returned
by a function call, and similarly, as a componentorslice of such a variable
(see section 8.7 for the context of overload resolution).

References: access type 3.8, allocator 4.8, array 3.6, array assignment 5.2.1,
component 3.6 3.7, constraint_error exception 11.1, designate 3.8, discriminant
3.7.1, erroneous 1.6, evaluation 4.5, expression 4.4, function call 6.4, implicit type
conversion 4.6, name 4.1, numeric literal 2.4, object 3.2, overloading 6.6 8.7, slice
4.1.2, subcomponent 3.3, subtype 3.3, subtype conversion 4.6, type 3.3, universal_
integer type 3.5.4, universal_real type 3.5.6, variable 3.2.1

Assignment Statement

5—4

5.2.1.

Array Assignments
1

If the variable of an assignment statement is an array variable (including
a slice variable), the value of the expression is implicitly converted to the
subtype of the array variable; the result of this subtype conversion becomes
the new value of the array variable.

This means that the new value of each component of the array variable is

specified by the matching componentin the array value obtained by evaluation of the expression (see 4.5.2 for the definition of matching components).
The subtype conversion checks that for each component of the array variable
there is a matching component in the array value, and vice versa. The
exception CONSTRAINT_ERRORisraised if this check fails; in such a case

the value of each componentof the array variable is left unchanged.
3

Examples:
A
B

:
:

:= B;

A(l
A(4

STRING(1
STRING(3

..
..

-9)
12)

..
..

31);
33);

same number of components
= "tar sauce";
:= A(1l .. 9);
--

A(l..

12)

= "tartar sauce"

Notes:

Array assignment is defined even in the case of overlapping slices, because
the expression on the right-hand side is evaluated before performing any
component assignment. In the above example, an implementation yielding

A(1 .. 12) = "tartartartar" would be incorrect.

5.3

The implicit subtype conversion described above for assignment to an array
variable is performed only for the value of the right-hand side expression as
a whole; it is not performed for subcomponents that are array values.

References: array 3.6, assignment 5.2, constraint_error exception 11.1, matching
array components 4.5.2, slice 4.1.2, subtype conversion 4.6, type 3.3, variable 3.2.1

If Statements
1

5-5

An if statement selects for execution one or none of the enclosed sequences
of statements, depending on the (truth) value of one or more corresponding
conditions.

lf Statements

5.3

ifstatement ::=

if condition then
sequenceofstatements

{elsif condition then

sequenceofstatements}

[else

sequenceofstatements]

end if;

condition ::= boolean_expression

An expression specifying a condition must be of a boolean type.

For the execution of an if statement, the condition specified after if, and any
conditions specified after elsif, are evaluated in succession (treating a final
else as elsif TRUE then), until one evaluates to TRUEorall conditions

are evaluated and yield FALSE. If one condition evaluates to TRUE, then
the corresponding sequence of statements is executed; otherwise none of the
sequences of statements is executed.
5

Examples:
if MONTH = DECEMBER and DAY = 31 then
MONTH := JANUARY;
DAY
:= 1;
YEAR
:= YEAR + 1;
end if;

if LINETOOSHORT then
raise LAYOUTERROR;

elsif LINEFULL then

NEWLINE;

PUT (ITEM) ;

else

PUT (ITEM) ;

end if;

if MYCAR.OWNER.VEHICLE /= MYCAR then

REPORT
end if;

5.4

see 3.8

References: boolean type 3.5.3, evaluation 4.5, expression 4.4, sequence of
statements 5.1

Case Statements
1

5.4

("Incorrect data");

A case statement selects for execution one of a numberof alternative
sequences of statements; the chosen alternative is defined by the value of an
expression.

Case Statements

5-6

casestatement ::=
case expression is

casestatementalternative

{casestatementalternative}
end case;
casestatement_alternative ::=
when choice

choice

}

sequenceofstatements

The expression must be of a discrete type which must be determinable
independently of the context in which the expression occurs, but using the
fact that the expression must be of a discrete type. Moreover, the type of

this expression must not be a generic formal type. Each choice in a case
statement alternative must be of the same type as the expression; the list
of choices specifies for which values of the expression the alternative is

chosen2

If the expression is the name of an object whose subtypeis static, then
each value of this subtype must be represented once and only once in the
set of choices of the case statement, and no other value is allowed; this

rule is likewise applied if the expression is a qualified expression or type
conversion whose type mark denotes a static subtype. Otherwise, for other
forms of expression, each value of the (base) type of the expression must be
represented once and only once in the set of choices, and no other value is
allowed.
5

The simple expressions and discrete ranges given as choices in a case
statement must be static. A choice defined by a discrete range standsforall
values in the corresponding range (noneif a null range). The choice others
is only allowed for the last alternative and as its only choice; it stands for
all values (possibly none) not given in the choices of previous alternatives.
A component simple nameis not allowed as a choice of a case statement
alternative.

The execution of a case statement consists of the evaluation of the expression
followed by the execution of the chosen sequence of statements?

2 See also Appendix G, AI-00151.
3 See also Appendix G, AI-00267.

5-7

Case Statements

5.4

Examples:
case SENSOR is
when ELEVATION

=> RECORD

when AZIMUTH

RECORDAZIMUTH

(SENSOR_VALUE) ;

when DISTANCE

RECORDDISTANCE

(SENSOR_VALUE) ;

when others
end case;

ELEVATION (SENSOR_VALUE) ;

=> null;

case TODAY is
when MON

COMPUTEINITIALBALANCE;

when FRI

COMPUTECLOSINGBALANCE;

GENERATEREPORT (TODAY) ;

when

TUE

THU

when SAT

SUN => null;

end case;

case BINNUMBER (COUNT)
when

when

when 3

UPDATEBIN(1);

UPDATEBIN (2);

EMPTYBIN(1);
EMPTYBIN (2);

when others => raise ERROR;
end case;

Notes:

The execution of a case statement chooses one and only one alternative,
since the choices are exhaustive and mutually exclusive. Qualification of the
expression of a case statement by a static subtype can often be usedto limit
the numberof choices that need be given explicitly.

An otherschoice is required in a case statement if the type of the expression
is the type universal_integer (for example, if the expression is an integer
literal), since this is the only wayto cover all values of the type uwniversal_
integer.

References: base type 3.3, choice 3.7.3, context of overload resolution 8.7, discrete

type 3.5, expression 4.4, function call 6.4, generic formal type 12.1, conversion 4.6,

discrete type 3.5, enumeration literal 3.5.1, expression 4.4, name 4.1, object 3.2.1,
overloading 6.6 8.7, qualified expression 4.7, sequence of statements 5.1, static
discrete range 4.9, static subtype 4.9, subtype 3.3, type 3.3, type conversion 4.6, type
mark 3.3.2

5.4

Case Statemenis

5-8

5.5 Loop Statements
1
2

A loop statement includes a sequence of statements that is to be executed
repeatedly, zero or more times.
loopstatement

::=

[loop_simple_name: ]

[iterationscheme] loop
sequenceofstatements
end loop [loopsimplename];

iterationscheme ::= while condition
| for loopparameterspecification
loopparameterspecification

identifier in [reverse]

::=

discreterange

If a loop statement has a loop simple name, this simple name must be given
both at the beginning and at the end.

A loop statement without an iteration schemespecifies repeated execution
of the sequence of statements. Execution of the loop statement is complete
whenthe loop is left as a consequence of the execution of an exit statement,
or as a consequence of some other transfer of control (see 5.1).

For a loop statement with a while iteration scheme, the condition is
evaluated before each execution of the sequence of statements; if the value
of the condition is TRUE, the sequence of statements is executed, if FALSE
the execution of the loop statement is complete.

For a loop statement with a for iteration scheme, the loop parameter

specification is the declaration of the loop parameter with the given
identifier. The loop parameter is an object whose type is the base type

of the discrete range (see 3.6.1). Within the sequence of statements, the

loop parameter is a constant. Hence a loop parameteris not allowed as
the (left-hand side) variable of an assignment statement. Similarly the

loop parameter must not be given as an out or in out parameterof a

procedure or entry call statement, or as an in out parameter of a generic

instantiation.
7

For the execution of a loop statement with a for iteration scheme, the loop
parameter specification is first elaborated. This elaboration creates the loop
parameter and evaluates the discrete range.

4 See also Appendix G, AI-00006.

5-9

Loop Statements

5.5

If the discrete range is a null range, the execution of the loop statement
is complete. Otherwise, the sequence of statements is executed once for
each value of the discrete range (subject to the loop not being left as a
consequence of the execution of an exit statement or as a consequence of
some other transfer of control). Prior to each such iteration, the corresponding value of the discrete range is assigned to the loop parameter. These
values are assigned in increasing order unless the reserved word reverseis
present, in which case the values are assigned in decreasing order.
Example of a loop statement without an iteration scheme:
loop

GET (CURRENTCHARACTER) ;
exit when CURRENTCHARACTER = '*’;
end loop;

Example of a loop statement with a while iteration scheme:
while BID(N).PRICE < CUT_OFF.PRICE loop
RECORDBID(BID(N) .PRICE) ;
N := N + 1;
end loop;
11

Example of a loop statement with a for iteration scheme:
for J in BUFFER’ RANGE loop

legal even with a null range

if BUFFER(J) /= SPACE then
PUT (BUFFER (J) );
end if;

end loop;
12

Example of a loop statement with a loop simple name:
SUMMATION:

while NEXT /= HEAD loop
SUM

-- see 3.8

:= SUM + NEXT.VALUE;

NEXT := NEXT.SUCC;
end loop SUMMATION;

Notes:
13

The scope of a loop parameter extends from the loop parameter specification
to the end of the loop statement, and the visibility rules are such that a loop
parameteris only visible within the sequence of statements of the loop.
The discrete range of a for loop is evaluated just once. Use of the reserved
word reverse does not alter the discrete range, so that the following iteration schemesare not equivalent; the first has a null range.
for J in reverse 1...
for Jaiano..tl

5.5

Loop Statements

5-10

Loop namesare also used in exit statements, and in expanded names(in a
prefix of the loop parameter).

i¢

References: actual parameter 6.4.1, assignment statement 5.2, base type 3.3,
- bound of a range 3.5, condition 5.3, constant 3.2.1, context of overload resolution
8.7, conversion 4.6, declaration 3.1, discrete range 3.6.1, elaboration 3.1, entry
call statement 9.5, evaluation 4.5, exit statement 5.7, expanded name 4.1.3, false
boolean value 3.5.3, generic actual parameter 12.3, generic instantiation 12.3, goto

statement 5.9, identifier 2.3, integer type 3.5.4, null range 3.5, object 3.2.1, prefix
4.1, procedure call 6.4, raising of exceptions 11, reserved word 2.9, return statement
5.8, scope 8.2, sequence of statements 5.1, simple name 4.1, terminate alternative
9.7.1, true boolean value 3.5.3 3.5.4, visibility 8.3

5.6

Block Statements
1
2

A block statement encloses a sequence of statements optionally preceded by
a declarative part and optionally followed by exception handlers.
blockstatement ::=
[block_simplename:]
[declare
declarativepart]

begin
sequenceofstatements
[exception

exceptionhandler

{exceptionhandler}]

end [block_simple_name];

If a block statement has a block simple name, this simple name must be
given both at the beginning and at the end.

The execution of a block statement consists of the elaboration of its
declarative part (if any) followed by the execution of the sequence of

statements. If the block statement has exception handlers, these service

corresponding exceptions that are raised during the execution of the
sequence of statements (see 11.2).

Example:
SWAP :
declare
TEMP

begin

TEMP

INTEGER;

:= V;

TEMP;

end SWAP;

5-11

Block Statements

5.6

Notes:
6

If task objects are declared within a block statement whose execution is

completed, the block statementis not left until all its dependent tasks are
terminated (see 9.4). This rule applies also to a completion caused by an
exit, return, or goto statement; or by the raising of an exception.

Within a block statement, the block name can be used in expanded names
denoting local entities such as SWAP.TEMPin the above example
(see 4.1.3 (f)).

References: declarative part 3.9, dependent task 9.4, exception handler 11.2, exit
statement 5.7, expanded name 4.1.3, goto statement 5.9, raising of exceptions 11,

return statement 5.8, sequence of statements 5.1, simple name4.1, task object 9.2

5.7

Exit Statements
1

An exit statement is used to complete the execution of an enclosing loop

statement (called the loop in what follows); the completion is conditional if
the exit statement includes a condition.
exitstatement ::=
exit

[loopname]

[when condition] ;°

An exit statement with a loop nameis only allowed within the named loop,

and applies to that loop; an exit statement without a loop nameis only
allowed within a loop, and applies to the innermost enclosing loop (whether
named or not). Furthermore, an exit statement that applies to a given loop
must not appear within a subprogram body, package body, task body, generic
body, or accept statement, if this construct is itself enclosed by the given
loop.
For the execution of an exit statement, the condition, if present, is first

evaluated. Exit from the loop then takes place if the value is TRUE orif

there is no condition.

5 See also Appendix G, AI-00210.
5.7

Exit Statements

5-12

Examples:
for N in 1 .. MAXNUM_ITEMS loop

GETNEW_ITEM(NEWITEM) ;

MERGEITEM(NEWITEM, STORAGEFILE) exit when NEWITEM = TERMINALITEM;

end loop;

MAINCYCLE:

Loop

initial statements

final statements

exit MAINCYCLE when FOUND;
end loop MAINCYCLE;
Note:

Several nested loops can be exited by an exit statement that names the
outer loop.
References: accept statement 9.5, condition 5.3, evaluation 4.5, generic body 12.1,
loop name5.5, loop statement 5.5, package body 7.1, subprogram body 6.3, true
boolean value 3.5.3

5.8

Return Statements
A return statement is used to complete the execution of the innermost
enclosing function, procedure, or accept statement.
returnstatement

::= return [expression];

A return statementis only allowed within the body of a subprogram or
generic subprogram, or within an accept statement, and applies to the
innermost (enclosing) such construct; a return statementis not allowed
within the body of a task unit, package, or generic package enclosed by this
construct (on the other hand,it is allowed within a compound statement
enclosed by this construct and, in particular, in a block statement).
A return statement for an accept statementor for the body of a procedure or
generic procedure must not include an expression. A return statement for
the body of a function or generic function must include an expression.
The value of the expression defines the result returned by the function. The
type of this expression must be the base type of the type mark given after
the reserved word return in the specification of the function or generic
function (this type mark defines the result subtype).

5-13

Return Statements

5.8

For the execution of a return statement, the expression (if any) is first

evaluated and a check is made that the value belongs to the result subtype.
The execution of the return statement is thereby completed if the check
succeeds; so also is the execution of the subprogram or of the accept
statement. The exception CONSTRAINT_ERRORisraised at the place of
the return statementif the check fails.
Examples:
return;

-- in a procedure

return KEYVALUE(LASTINDEX) ;

-- in a function

Note:

If the expression is either a numeric literal or named number, or an attribute
that yields a result of type universal_integer or universal_real, then an
implicit conversion of the result is performed as described in section 4.6.

References: accept statement 9.5, attribute A, block statement 5.6, constraint_
error exception 11.1, expression 4.4, function body 6.3, function call 6.4, generic body
12.1, implicit type conversion 4.6, named number 3.2, numericliteral 2.4, package
body 7.1, procedure body 6.3, reserved word 2.9, result subtype 6.1, subprogram
body 6.3, subprogram specification 6.1, subtype 3.3, task body 9.1, type mark 3.3.2,
universal_integer type 3.5.4, universal_real type 3.5.6

5.9 Goto Statements
1
2

A goto statement specifies an explicit transfer of control from this statement
to a target statement namedbya label.
gotostatement

::= goto labelname;

The innermost sequence of statements that encloses the target statement
must also enclose the goto statement (note that the goto statement can
be a statement of an inner sequence). Furthermore, if a goto statementis
enclosed by an accept statement or the body of a program unit, then the
target statement must not be outside this enclosing construct; conversely,

it follows from the previous rule that if the target statement is enclosed by
such a construct, then the goto statement cannot be outside.
4

5.9

The execution of a goto statement transfers control to the named target
statement.

Goto Statements

5-14

Note:
The above rules allow transfer of control to a statement of an enclosing sequence of statements but not the reverse. Similarly, they prohibit transfers
of control such as between alternatives of a case statement, if statement, or

select statement; between exception handlers; or from an exception handler
of a frame back to the sequence of statements of this frame.
Example:
<<COMPARE>>
if A(I) < ELEMENT then
if LEFT(I) /= 0 then
I := LEFT (1);

goto COMPARE;

end if;
-some statements
end if;

References: accept statement 9.5, block statement 5.6, case statement 5.4,

compound statement 5.1, exception handler 11.2, frame 11.2, generic body 12.1, if
statement 5.3, label 5.1, package body 7.1, program unit 6, select statement 9.7,
sequence of statements 5.1, statement 5.1, subprogram body 6.3, task body 9.1,
transfer of control 5.1

5-15

Goto Statements

5.9

Chapter 6

Subprograms
Subprogramsare one of the four forms of program unit, of which programs
can be composed. The other forms are packages, task units, and generic

units.

A subprogram is a program unit whose execution is invoked by a

subprogram call. There are two forms of subprogram: procedures and

functions. A procedure call is a statement; a function call is an expression
and returns a value. The definition of a subprogram can be given in two

parts: a subprogram declaration defining its calling conventions, and a
subprogram body defining its execution.

References: function 6.5, function call 6.4, generic unit 12, package 7, procedure
6.1, procedure call 6.4, subprogram body 6.3, subprogram call 6.4, subprogram
declaration 6.1, task unit 9

6.1

Subprogram Declarations
A subprogram declaration declares a procedure or a function, as indicated by
the initial reserved word.
subprogramdeclaration ::= subprogram_specification;
subprogram_specification ::=
|

procedure identifier [formalpart]
function designator

designator ::= identifier
operatorsymbol
formalpart

[formalpart]

return typemark

operatorsymbol

::= stringliteral

::=

(parameterspecification {; parameterspecification})

Subprogram Declarations

6.1

parameterspecification

identifierlist

mode

::=

[in]

::=

: mode typemark [:= expression]

in out

out

The specification of a procedure specifies its identifier and its formal

parameters (if any). The specification of a function specifies its designator,

its formal parameters (if any) and the subtype of the returned value (the
result subtype). A designator that is an operator symbol is used for the
overloading of an operator. The sequence of characters represented by an
operator symbol must be an operator belonging to one of the six classes of
overloadable operators defined in section 4.5 (extra spaces are not allowed
and the case of letters is not significant).

A parameter specification with several identifiers is equivalent to a sequence
of single parameter specifications, as explained in section 3.2. Each single
parameter specification declares a formal parameter. If no modeis explicitly
given, the mode in is assumed. If a parameter specification ends with an
expression, the expression is the default expression of the formal parameter.
A default expression is only allowed in a parameter specification if the mode
is in (whether this modeis indicated explicitly or implicitly). The type of a
default expression must be that of the corresponding formal parameter.

The use of a name that denotes a formal parameteris not allowed in default
expressions of a formal part if the specification of the parameteris itself
given in this formal part.

The elaboration of a subprogram declaration elaborates the corresponding
formal part. The elaboration of a formal part has no othereffect.

Examples of subprogram declarations:
procedure
procedure
procedure
procedure

TRAVERSETREE;
INCREMENT (X : in out INTEGER) ;
RIGHTINDENT(MARGIN : out LINESIZE); -SWITCH(FROM, TO : in out LINK);
--

function RANDOM return PROBABILITY;

see 3.5.4
see 3.8.1
see 3.5.7

function MINCELL(X : LINK) return CELL;
-- see 3.8.1
function NEXTFRAME(K : POSITIVE) return FRAME; -- see 3.8
function DOT_PRODUCT(LEFT, RIGHT: VECTOR) return REAL; -- see 3.6
function "*"(LEFT,RIGHT

MATRIX)

return MATRIX;

Examples of in parameters with default expressions:
procedure PRINTHEADER(PAGES
HEADER
>=

: in NATURAL;
: in LINE
(1 .. LINE’LAST => ’

CENTER : in BOOLEAN
>= TRUE);

6.1.

-- see 3.6

Subprogram Declarations

’);

see 3.6

6-2

Notes:

The evaluation of default expressions is caused by certain subprogram calls,
as described in section 6.4.2 (default expressions are not evaluated during
the elaboration of the subprogram declaration).
All subprogramscan becalled recursively and are reentrant.
References: declaration 3.1, elaboration 3.9, evaluation 4.5, expression 4.4, formal

parameter 6.2, function 6.5, identifier 2.3, identifier list 3.2, mode 6.2, name4.1,

elaboration has no other effect 3.9, operator 4.5, overloading 6.6 8.7, procedure 6,
string literal 2.6, subprogram call 6.4, type mark 3.3.2

6.2

Formal Parameter Modes
The value of an object is said to be read whenthis value is evaluated;it is
also said to be read when oneof its subcomponents is read. The value of

a variable is said to be updated when an assignmentis performedto the
variable, and also (indirectly) when the variable is used as actual parameter

of a subprogram call or entry call statement that updates its value; it is also

said to be updated when oneof its subcomponents is updated.

A formal parameter of a subprogram hasoneof the three following modes:
in

The formal parameter is a constant and permits only reading of the
value of the associated actual parameter.

in out

The formal parameter is a variable and permits both reading and
updating of the value of the associated actual parameter.

out

The formal parameteris a variable and permits updating of the value of
the associated actual parameter.
The value of a scalar parameter that is not updated by thecall is undefined upon return; the same holds for the value of a scalar subcomponent, other than a discriminant. Reading the bounds and discriminants
of the formal parameter and of its subcomponents is allowed, but no
other reading.

For a scalar parameter, the above effects are achieved by copy: at the start

of each call, if the mode is in or in out, the value of the actual parameteris

copied into the associated formal parameter; then after normal completion
of the subprogram body, if the modeis in out or out, the value of the
formal parameter is copied back into the associated actual parameter. For a
parameter whose typeis an access type, copy-in is used for all three modes,
and copy-back for the modes in out and out.

6-3

Formal Parameter Modes’

6.2

For a parameter whose type is an array, record, or task type, an implementation may likewise achieve the above effects by copy, as for scalar types.
In addition, if copy is used for a parameter of mode out, then copy-in is
required at least for the bounds and discriminants of the actual parameter
and of its subcomponents, and also for each subcomponent whosetypeis

an access type. Alternatively, an implementation may achieve these effects
by reference, that is, by arranging that every use of the formal parameter
(to read or to update its value) be treated as a use of the associated actual

parameter, throughout the execution of the subprogram call. The language

does not define which of these two mechanismsis to be adopted for parame-

ter passing, nor whetherdifferent calls to the same subprogram are to use
the same mechanism. The execution of a program is erroneousif its effect

depends on which mechanismis selected by the implementation.

The VAX Ada Run-Time Reference Manual describes the parameter passing
mechanisms used in VAX Ada.
8

For a parameter whose type is a private type, the above effects are achieved

Within the body of a subprogram, a formal parameter is subject to any

according to the rule that applies to the corresponding full type declaration.

constraint resulting from the type mark given in its parameter specification.

For a formal parameter of an unconstrained array type, the bounds

are obtained from the actual parameter, and the formal parameteris

constrained by these bounds(see 3.6.1). For a formal parameter whose

declaration specifies an unconstrained (private or record) type with

discriminants, the discriminants of the formal parameterare initialized

with the values of the corresponding discriminants of the actual parameter;
the formal parameter is unconstrained if and only if the modeis in out
or out and the variable name given for the actual parameter denotes an
unconstrained variable (see 3.7.1 and 6.4.1).
10

Ifthe actual parameter of a subprogram call is a subcomponent that depends
on discriminants of an unconstrained record variable, then the execution of

the call is erroneous if the value of any of the discriminants of the variable
is changed by this execution; this rule does not apply if the mode is in and
the type of the subcomponentis a scalar type or an access type.
Notes:
11

6.2

For parameters of array and record types, the parameter passing rules have

these consequences:
©

Ifthe execution of a subprogram is abandonedasa result of an exception, the final value of an actual parameter of such a type can be either
its value before the call or a value assigned to the formal parameter
during the execution of the subprogram.

Formal Parameter Modes

6—4

If no actual parameter of such a type is accessible by more than one
path, then the effect of a subprogram call (unless abandoned)is the same

whetheror not the implementation uses copying for parameter passing.
If, however, there are multiple access paths to such a parameter(for
example, if a global variable, or another formal parameter, refers to the
same actual parameter), then the value of the formal is undefined after
updating the actual other than by updating the formal. A program using

such an undefined value is erroneous.

The same parameter modesare defined for formal parametersof entries
(see 9.5) with the same meaning as for subprograms. Different parameter
modes are defined for generic formal parameters (see 12.1.1).
For all modes, if an actual parameter designates a task, the associated

formal parameter designates the same task; the same holds for a subcom-

ponent of an actual parameter and the corresponding subcomponentof the
associated formal parameter.

References: access type 3.8, actual parameter 6.4.1, array type 3.6, assignment
5.2, bound of an array 3.6.1, constraint 3.3, depend on a discriminant 3.7.1, discriminant 3.7.1, entry call statement 9.5, erroneous 1.6, evaluation 4.5, exception

11, expression 4.4, formal parameter 6.1, generic formal parameter 12.1, global

8.1, mode 6.1, null access value 3.8, object 3.2, parameter specification 6.1, private

type 7.4, record type 3.7, scalar type 3.5, subcomponent 3.3, subprogram body 6.3,

subprogram call statement 6.4, task 9, task type 9.2, type mark 3.3.2, unconstrained

array type 3.6, unconstrained type with discriminants 3.7.1, unconstrained variable
3.2.1, variable 3.2.1

6.3 Subprogram Bodies
A subprogram body specifies the execution of a subprogram.
subprogrambody

::=

subprogramspecification is
[declarativepart]
begin
sequenceofstatements

[exception

exceptionhandler

{exceptionhandler} ]
end [designator];

The declaration of a subprogram is optional. In the absence of such a
declaration, the subprogram specification of the subprogram body (or body
stub) acts as the declaration. For each subprogram declaration, there

must be a corresponding body (except for a subprogram written in another

language, as explained in section 13.9). If both a declaration and a body
Subprogram Bodies’

6.3

are given, the subprogram specification of the body must conform to the
subprogram specification of the declaration (see section 6.3.1 for conformance

rules).

If a designator appears at the end of a subprogram body, it must repeat the
designator of the subprogram specification.

The elaboration of a subprogram body has no othereffect than to establish
that the body can from then on be used for the execution of calls of the
subprogram.

The execution of a subprogram body is invoked by a subprogram call
(see 6.4). For this execution, after establishing the association between
formal parameters and actual parameters, the declarative part of the body
is elaborated, and the sequence of statements of the body is then executed.

Upon completion of the body, return is madeto the caller (and any necessary

copying back of formal to actual parameters occurs (see 6.2)). The optional
exception handlers at the end of a subprogram body handle exceptions
raised during the execution of the sequence of statements of the subprogram

body (see 11.4).
Note:

It follows from the visibility rules that if a subprogram declared in a package
is to be visible outside the package, a subprogram specification must be
given in the visible part of the package. The samerules dictate that a
subprogram declaration must be given if a call of the subprogram occurs
textually before the subprogram body (the declaration must then occur
earlier than the call in the program text). The rules given in sections 3.9
and 7.1 imply that a subprogram declaration and the corresponding body
must both occur immediately within the same declarative region.

Example of subprogram body:
procedure PUSH(E

begin

in ELEMENTTYPE;

in out STACK)

if S.INDEX = S.SIZE then

raise STACKOVERFLOW;

else

S.INDEX

S.INDEX +

S.SPACE(S.INDEX)
end if;
end PUSH;

6.3

:= 5;

References: actual parameter 6.4.1, body stub 10.2, conform 6.3.1, declaration
3.1, declarative part 3.9, declarative region 8.1, designator 6.1, elaboration 3.9,
elaboration has no other effect 3.1, exception 11, exception handler 11.2, formal
parameter 6.1, occur immediately within 8.1, package 7, sequence of statements

Subprogram Bodies

6-6

5.1, subprogram 6, subprogram call 6.4, subprogram declaration 6.1, subprogram
specification 6.1, visibility 8.3, visible part 7.2

6.3.1

Conformance Rules
1

Whenever the languagerules require or allow the specification of a given
subprogram to be provided in more than one place, the following variations
are allowed at each place:
e

A numeric literal can be replaced by a different numeric literal if and
only if both have the same value.

A simple name can be replaced by an expanded namein which this
simple nameistheselector, if and only if at both places the meaning of
the simple nameis given by the same declaration.

A string literal given as an operator symbol can be replaced by a

different string literal if and only if both represent the same operator. |

Two subprogram specifications are said to conform if, apart from comments
and the above allowed variations, both specifications are formed by the same
sequence of lexical elements, and corresponding lexical elements are given

the same meaningbythevisibility and overloading rules.2

Conformanceis likewise defined for formal parts, discriminant parts, and
type marks(for deferred constants and for actual parameters that have the
form of a type conversion (see 6.4.1)).
Notes:

A simple name can be replaced by an expanded nameevenif the simple
nameis itself the prefix of a selected component. For example, Q.R can be
replaced by P.Q.R if Q is declared immediately within P.
The following specifications do not conform since they are not formed by the
same sequenceof lexical elements:
procedure P(X,Y : INTEGER)
procedure P(X : INTEGER; Y : INTEGER)
procedure P(X,Y : in INTEGER)

References: actual parameter 6.4 6.4.1, allow 1.6, comment 2.7, declaration 3.1,
deferred constant 7.4.3, direct visibility 8.3, discriminant part 3.7.1, expanded name
4.1.3, formal part 6.1, lexical element 2, name 4.1, numeric literal 2.4, operator
symbol 6.1, overloading 6.6 8.7, prefix 4.1, selected component 4.1.3, selector 4.1.3,
simple name4.1, subprogram specification 6.1, type conversion 4.6, visibility 8.3
1 See also Appendix G, AI-00493.
2 See also Appendix G, AI-00350.
6—7

Conformance Rules

6.3.1

6.3.2

Inline Expansion of Subprograms
1

The pragma INLINEis used to indicate that inline expansion of the
subprogram bodyis desired for every call of each of the named subprograms.
The form of this pragmais as follows:
pragma INLINE

(name {,

name});

Each nameis either the name of a subprogram or the nameof a generic sub-

program. The pragma INLINEis only allowed at the place of a declarative
item in a declarative part or package specification, or after a library unit in
a compilation, but before any subsequent compilation unit.
If the pragma appears at the place of a declarative item, each name must

denote a subprogram or a generic subprogram declared by an earlier
declarative item of the same declarative part or package specification. If
several (overloaded) subprogramssatisfy this requirement, the pragma
applies to all of them. If the pragma appearsafter a given library unit,
the only name allowed is the nameof this unit. If the name of a generic
subprogram is mentioned in the pragma,this indicates that inline expansion

is desired for calls of all subprograms obtained by instantiation of the named

generic unit.?

In VAX Ada, the subprogram name mustbe an identifier or a string literal
that denotes an operator symbol.
Also, in VAX Ada, if the namespecified by a pragma INLINEis declared
by a renaming declaration, the pragma INLINE applies to the subprogram
only if the declaration of the subprogram that has been renamed, the
renaming declaration, and the pragmaall occur in the same declarative part
or package specification. The pragmais ignored if these conditions are not
satisfied.
The meaning of a subprogram is not changed by the pragma INLINE. For

each call of the named subprograms, an implementation is free to follow or

to ignore the recommendation expressed by the pragma. (Note, in particular,
that the recommendation cannot generally be followed for a recursive
subprogram.)
In VAX Ada,a call of a subprogram for which the pragma INLINEhas been
specified is expanded inline provided that certain conditionsare satisfied.
These conditions are given in the VAX Ada Run-Time Reference Manual.
The samecriteria apply to subprogramsthat result from instantiation of a
generic declaration for which a pragma INLINEwasspecified.

3 See also Appendix G, AI-00200 and AI-00242.
6.3.2

Inline Expansion of Subprograms

6-8

Notes:

The meaning of the subprogram nameis determined as for any name
(see 8.3), except that the name can denote more than one subprogram.
Thus, in the following declaration the pragma INLINEappliesto thefirst
two procedures; it does not apply to the third because the declaration is not
visible at the place of the pragma:
.

procedure P (B: BOOLEAN) ;
procedure P (I: INTEGER);
pragma INLINE (P);
procedure P (F: FLOAT);

If a pragma INLINE and pragma INTERFACEare used together, the
pragma INLINEis ignored regardless of the order in which the two pragmas
appear.
Example of renaming:
package CHOOSER is
procedure P (X: INTEGER) ;
procedure P (X: FLOAT);
private
procedure R (X: FLOAT) renames P;
pragma INLINE(R); -- second procedure P will be expanded
-- inline when procedure R is called

end CHOOSER;

References: allow 1.6, compilation 10.1, compilation unit 10.1, declarative item
3.9, declarative part 3.9, generic subprogram 12.1, generic unit 12 12.1, instantiation

12.3, library unit 10.1, name 4.1, overloading 6.6 8.7, package specification 7.1,
pragma 2.8, subprogram 6, subprogram body 6.3, subprogram call 6.4
identifier 2.3, operator symbol 6.1, renaming declaration 8.5, string literal 2.6

6.4 Subprogram Calls
A subprogram call is either a procedure call statement or a function call;
it invokes the execution of the corresponding subprogram body. Thecall
specifies the association of the actual parameters, if any, with formal

parameters of the subprogram.

procedurecallstatement ::=
procedurename [actualparameterpart];
functioncall ::=
functionname

[actualparameterpart]

actualparameterpart ::=
(parameter_association {, parameter_association})

Subprogram Calls

6.4

parameterassociation ::=
(formal parameter =>]
formalparameter

actualparameter

::= parametersimplename

actualparameter ::=
expression | variablename

| typemark(variable_name)

Each parameter association associates an actual parameter with a corre-

sponding formal parameter. A parameter association is said to be named
if the formal parameter is named explicitly; it is otherwise said to be positional. For a positional association, the actual parameter correspondsto the
formal parameter with the same position in the formal part.

Namedassociations can be given in any order, but if both positional and
named associations are used in the samecall, positional associations must
occurfirst, at their normal position. Hence once a namedassociation is
used, the rest of the call must use only named associations.

For each formal parameter of a subprogram, a subprogram call must specify
exactly one corresponding actual parameter. This actual parameteris

specified either explicitly, by a parameter association, or, in the absence of
such an association, by a default expression (see 6.4.2).

The parameter associations of a subprogram call are evaluated in some
order that is not defined by the language. Similarly, the language rules do
not define in which order the values of in out or out parameters are copied
back into the corresponding actual parameters (when this is done).

Examples of procedurecalls:
TRAVERSETREE;
TABLEMANAGER. INSERT (E) ;
PRINTHEADER(128, TITLE,
SWITCH (FROM => X,

TRUE);

TO => NEXT);

----

see 6.1
see 7.5
see 6.1

see

see 6.1

—--

see 6.1

6.1

PRINTHEADER (128,

HEADER => TITLE,

CENTER => TRUE) ;
PRINTHEADER (HEADER => TITLE,
CENTER => TRUE,

PAGES

Examples of function calls:
DOTPRODUCT (U,

CLOCK

=> 128);

see

6.1 and 6.5

see 9.6

References: default expression for a formal parameter 6.1, erroneous 1.6, ex-

pression 4.4, formal parameter 6.1, formal part 6.1, name 4.1, simple name4.1,

subprogram 6, type mark 3.3.2, variable 3.2.1
6.4

Subprogram Calls

6-10

6.4.1

Parameter Associations
Each actual parameter must have the same type as the corresponding
formal parameter.
An actual parameter associated with a formal parameter of mode in must be
an expression; it is evaluated before thecall.
An actual parameter associated with a formal parameter of mode in out
or out must be either the nameof a variable, or of the form of a type
conversion whose argumentis the nameof a variable. In either case, for the
mode in out, the variable must not be a formal parameter of mode out or a
subcomponent thereof. For an actual parameter that has the form of a type
conversion, the type mark must conform (see 6.3.1) to the type mark of the
formal parameter; the allowed operand and target types are the sameasfor
type conversions (see 4.6).4
The variable name given for an actual parameter of mode in out or out
is evaluated before the call. If the actual parameter has the form of a
type conversion, then before the call, for a parameter of mode in out, the
variable is converted to the specified type; after (normal) completion of
the subprogram body, for a parameter of mode in out or out, the formal
parameter is converted back to the type of the variable. (The type specified
in the conversion mustbe that of the formal parameter.) °
The following constraint checks are performed for parameters of scalar and
access types:

Before thecall: for a parameter of mode in or in out, it is checked that
the value of the actual parameter belongs to the subtype of the formal
parameter.

After (normal) completion of the subprogram body: for a parameter of
mode in out or out, it is checked that the value of the formal parameter
belongs to the subtype of the actual variable. In the case of a type
conversion, the value of the formal parameter is converted back and the
check applies to the result of the conversion.

In each of the above cases, the execution of the program is erroneous if the
checked value is undefined.
For other types, for all modes, a check is made before the call as for scalar
and access types; no check is made upon return. ©
4 See also Appendix G, AI-00245.
5 See also Appendix G, AI-00024.
6 See also Appendix G, AI-00025 and AI-00396.

6-11

Parameter Associations

6.4.1

The exception CONSTRAINT_ERRORis raised at the place of the subpro-

gram call if either of these checks fails.
Note:

For array types and for types with discriminants, the check before thecall is
sufficient (a check upon return would be redundant) if the type mark of the

formal parameter denotes a constrained subtype, since neither array bounds
nor discriminants can then vary.
12

Ifthis type mark denotes an unconstrained array type, the formal parameter
is constrained with the bounds of the corresponding actual parameter and

no check (neither before the call nor upon return) is needed (see 3.6.1).

Similarly, no check is needed if the type mark denotes an unconstrained

type with discriminants, since the formal parameter is then constrained
exactly as the corresponding actual parameter(see 3.7.1).
13

References: actual parameter 6.4, array bound 3.6, array type 3.6, call of a subprogram 6.4, conform 6.3.1, constrained subtype 3.3, constraint 3.3, constraint_error
exception 11.1, discriminant 3.7.1, erroneous 1.6, evaluation 4.5, evaluation of a
name 4.1, expression 4.4, formal parameter 6.1, mode 6.1, name 4.1, parameter

association 6.4, subtype 3.3, type 3.3, type conversion 4.6, type mark 3.3.2, unconstrained array type 3.6, unconstrained type with discriminants 3.7.1, undefined

value 3.2.1, variable 3.2.1

6.4.2

Default Parameters
1

If a parameter specification includes a default expression for a parameter

of mode in, then corresponding subprogram calls need not include a parameter association for the parameter. If a parameter association is thus
omitted from a call, then the rest of the call, following any initial positional
associations, must use only namedassociations.

For any omitted parameter association, the default expression is evalu-

ated before the call and the resulting value is used as an implicit actual

parameter.

Examples of procedures with default values:
procedure ACTIVATE (PROCESS

AFTER
WAIT
PRIOR

: in PROCESSNAME;

: in PROCESSNAME := NOPROCESS;
: in DURATION := 0.0;
: in BOOLEAN := FALSE);

procedure PAIR(LEFT, RIGHT : PERSONNAME := new PERSON);

6.4.2

Default Parameters

6-12

Examples of their calls:
ACTIVATE (X) ;
ACTIVATE (X, AFTER => Y);
ACTIVATE (X, WAIT => 60.0, PRIOR => TRUE);
ACTIVATE (X, Y, 10.0, FALSE);
PAIR;
PAIR(LEFT => new PERSON,

RIGHT => new PERSON) ;

Note:

If a default expression is used for two or more parameters in a multiple

parameter specification, the default expression is evaluated once for each

omitted parameter. Hence in the above examples, the two calls of PAIR are
equivalent.

References: actual parameter 6.4.1, default expression for a formal parameter
6.1, evaluation 4.5, formal parameter 6.1, mode 6.1, named parameter association
6.4, parameter association 6.4, parameter specification 6.1, positional parameter
association 6.4, subprogram call 6.4

6.5 Function Subprograms
A function is a subprogram that returns a value (the result ofthe function

call). The specification of a function starts with the reserved word function,
and the parameters, if any, must have the mode in (whether this mode
is specified explicitly or implicitly). The statements of the function body
(excluding statements of program units that are inner to the function body)
must include one or more return statements specifying the returned value.
The exception PROGRAM_ERRORisraised if a function bodyis left

otherwise than by a return statement. This does not apply if the execution
of the function is abandonedas a result of an exception.

Example:
function DOTPRODUCT (LEFT,
SUM : REAL := 0.0;

RIGHT

VECTOR)

return REAL is

begin
CHECK (LEFT’FIRST = RIGHT’FIRST and LEFT’ LAST = RIGHT’ LAST) ;
for J in LEFT’RANGE loop
SUM := SUM + LEFT (J) *RIGHT (J);
end loop;
return SUM;

end DOTPRODUCT;

References: exception 11, formal parameter 6.1, function 6.1, function body 6.3,
function call 6.4, function specification 6.1, mode 6.1, program_error exception 11.1,
raising of exceptions 11, return statement 5.8, statement 5
6-13

Function Subprograms'

6.5

6.6 Parameter and Result Type Profile—Overloading of
Subprograms
1

Two formal parts are said to have the same parametertype profile if and only
if they have the same numberof parameters, and at each parameter position
corresponding parameters have the same base type. A subprogram or entry
has the same parameter and result type profile as another subprogram or
entry if and only if both have the same parameter type profile, and either
both are functions with the same result base type, or neither of the two is a
function.
|
The same subprogram identifier or operator symbol can be used in several
subprogram specifications. The identifier or operator symbol is then said to
be overloaded; the subprogramsthat have this identifier or operator symbol
are also said to be overloaded and to overload each other. As explained in
section 8.3, if two subprograms overload each other, one of them can hide
the other only if both subprograms have the same parameter andresult
type profile (see section 8.3 for the other requirements that must be met for
hiding).
A call to an overloaded subprogram is ambiguous (andtherefore illegal)
if the name of the subprogram, the number of parameter associations,
the types and the order of the actual parameters, the namesof the
formal parameters (if named associations are used), and the result type
(for functions) are not sufficient to determine exactly one (overloaded)
subprogram specification.
Examples of overloaded subprograms:
procedure PUT(X : INTEGER) ;
procedure PUT(X : STRING);
procedure SET (TINT

COLOR) ;

procedure SET(SIGNAL : LIGHT);

Examples of calls:
PUT (28);

PUT("no possible ambiguity here");
SET (TINT
=> RED);
SET (SIGNAL => RED);
SET (COLOR’ (RED) ) ;

---

6.6

SET(RED) would be ambiguous since RED may
denote a value either of type COLOR or of type LIGHT

Parameter and Result Type Profile—Overloading of Subprograms

6-14

Notes:

The notion of parameter and result type profile does not include parameter
names, parameter modes, parameter subtypes, default expressions and their
presence or absence.
Ambiguities may (but need not) arise when actual parametersof the call of
an overloaded subprogram are themselves overloaded function calls, literals,
or aggregates. Ambiguities may also (but need not) arise when several
overloaded subprograms belonging to different packages are visible. These
ambiguities can usually be resolved in several ways: qualified expressions
can be used for someorall actual parameters, and for the result, if any; the

name of the subprogram can be expressed more explicitly as an expanded
name;finally, the subprogram can be renamed.

References: actual parameter 6.4.1, aggregate 4.3, base type 3.3, default expression for a formal parameter 6.1, entry 9.5, formal parameter 6.1, function 6.5,
function call 6.4, hiding 8.3, identifier 2.3, illegal 1.6, literal 4.2, mode 6.1, named
parameter association 6.4, operator symbol 6.1, overloading 8.7, package 7, parameter of a subprogram 6.2, qualified expression 4.7, renaming declaration 8.5, result
subtype 6.1, subprogram 6, subprogram specification 6.1, subtype 3.3, type 3.3

6.7 Overloading of Operators
1

The declaration of a function whose designator is an operator symbol is used
to overload an operator. The sequence of characters of the operator symbol

must be either a logical, a relational, a binary adding, a unary adding, a
multiplying, or a highest precedence operator (see 4.5). Neither membership
tests nor the short-circuit control forms are allowed as function designators.
The subprogram specification of a unary operator must have a single
parameter. The subprogram specification of a binary operator must have
two parameters; for each use of this operator, the first parameter takes

the left operand as actual parameter, the second parameter takes the right
operand. Similarly, a generic function instantiation whose designator is an
operator symbolis only allowed if the specification of the generic function
has the corresponding number of parameters. Default expressions are not
allowed for the parameters of an operator (whether the operator is declared
with an explicit subprogram specification or by a generic instantiation).
For each of the operators “+” and “—”, overloading1is allowed both as a unary
and as a binary operator.

6-15

Overloading of Operators

6.7

The explicit declaration of a function that overloads the equality operator
“=” other than by a renaming declaration, is only allowed if both parameters
are of the same limited type. An overloading of equality must deliver a
result of the predefined type BOOLEAN; it also implicitly overloads the

inequality operator “/=” so that this still gives the complementary result to

the equality operator. Explicit overloading of the inequality operator is not
allowed.

A renaming declaration whose designator is the equality operator is only
allowed to rename another equality operator. (For example, such a renaming
declaration can be used when equality is visible by selection but not directly
visible.)
Note:

Overloading of relational operators does not affect basic comparisons such as

testing for membership in a rangeor the choices in a case statement.
Examples:
function "+"
function "+"
--

assuming that A,

-A

6.7

(LEFT,
(LEFT,

RIGHT
RIGHT
B,

:
:

MATRIX)
VECTOR)

return MATRIX;
return VECTOR;

and C are of the type VECTOR

the three following assignments are equivalent
:= B+ C;

man (B,

C);

"+" (LEFT

RIGHT

C);

References: allow 1.6, actual parameter 6.4.1, binary adding operator 4.5 4.5.3,
boolean predefined type 3.5.3, character 2.1, complementary result 4.5.2, declaration
3.1, default expression for a formal parameter 6.1, designator 6.1, directly visible
8.3, equality operator 4.5, formal parameter 6.1, function declaration 6.1, highest
precedence operator 4.5 4.5.6, implicit declaration 3.1, inequality operator 4.5.2,
limited type 7.4.4, logical operator 4.5 4.5.1, membership test 4.5 4.5.2, multiplying
operator 4.5 4.5.5, operator 4.5, operator symbol 6.1, overloading 6.6 8.7, relational
operator 4.5 4.5.2, short-circuit control form 4.5 4.5.1, type definition 3.3.1, unary
adding operator 4.5 4.5.4, visible by selection 8.3

Overloading of Operators

6-16

Chapter 7

Packages
1

Packages are one of the four forms of program unit, of which programs can
be composed. The other forms are subprograms, task units, and generic
units.

Packages allow the specification of groups of logically related entities.
In their simplest form packages specify pools of common object and type
declarations. More generally, packages can be used to specify groups of
related entities including also subprogramsthat can be called from outside

the package, while their inner workings remain concealed and protected

from outside users.
3

7.1

References: generic unit 12, program unit 6, subprogram 6, task unit 9, type
declaration 3.3.1

Package Structure
1

A package is generally provided in two parts: a package specification and
a package body. Every package has a packagespecification, but notall
packages have a package body.
packagedeclaration ::= packagespecification;
packagespecification ::=
package identifier is

{basicdeclarativeitem}

[private

{basicdeclarativeitem}]

end [packagesimplename]

7-1

Package Structure

7.1

packagebody

::=

package body packagesimplename is
[declarativepart]
[begin
sequenceofstatements
[exception

exceptionhandler

{exceptionhandler}]]
end [packagesimplename];

The simple nameat the start of a package body must repeat the package
identifier. Similarly if a simple name appears at the end of the package
specification or body, it must repeat the package identifier.

If a subprogram declaration, a package declaration, a task declaration, or
a generic declaration is a declarative item of a given package specification,
then the body (if there is one) of the program unit declared by the declarative item must itself be a declarative item of the declarative part of the body
of the given package.
Notes:

7.1.

A simple form of package, specifying a pool of objects and types, does not
require a package body. Oneof the possible uses of the sequence of statements of a package bodyis to initialize such objects. For each subprogram
declaration there must be a corresponding body (except for a subprogram
written in another language, as explained in section 138.9). If the body of a
program unit is a body stub, then a separately compiled subunit containing
the corresponding proper body is required for the program unit (see 10.2).
A body is not a basic declarative item and so cannot appear in a package
specification.

A package declaration is either a library package (see 10.2) or a declarative
item declared within another program unit.

References: basic declarative item 3.9, body stub 10.2, declarative item 3.9,
declarative part 3.9, exception handler 11.2, generic body 12.2, generic declaration
12.1, identifier 2.3, library unit 10.1, object 3.2, package body 7.3, program unit 6,
proper body 3.9, sequence of statements 5.1, simple name 4.1, subprogram body6.3,
subprogram declaration 6.1, subunit 10.2, task body 9.1, task declaration 9.1,
type 3.3

Package Structure

7-2

7.2 Package Specifications and Declarations
1

Thefirst list of declarative items of a package specification is called the
visible part of the package. The optional list of declarative items after the
reserved word private is called the private part of the package.
An entity declared in the private part of a package is not visible outside
the package itself (a name denoting such an entity is only possible within
the package). In contrast, expanded names denoting entities declared in
the visible part can be used even outside the package; furthermore,direct
visibility of such entities can be achieved by meansof use clauses (see 4.1.3
and 8.4).
The elaboration of a package declaration consists of the elaboration of its
basic declarative items in the given order.
Notes:

The visible part of a package contains all the information that another
program unit is able to know about the package. A package consisting of
only a package specification (that is, without a package body) can be used
to represent a group of common constants or variables, or a common pool of
objects and types, as in the examples below.
Example of a package describing a group of commonvariables:
package PLOTTINGDATA is
PENUP

BOOLEAN;

CONVERSIONFACTOR,
X_OFFSET, YOFFSET,

XMIN,
XMAX,

Y_MIN,
Y_MAX:

REAL;

XVALUE : array (1
Y_VALUE : array (1

..
..

500)
500)

see 3.5.7

of REAL;
of REAL;

end PLOTTINGDATA;

Example of a package describing a commonpoolof objects and types:
package WORKDATA is
type DAY is (MON, TUE, WED,

THU, FRI,

SAT,

SUN);

type HOURSSPENT is delta 0.25 range 0.0 .. 24.0;
type TIMETABLE
WORK_HOURS
NORMALHOURS

end WORKDATA;
1-3

:
:

is array

(DAY) of HOURSSPENT;

TIMETABLE;
constant TIMETABLE

(MON
FRI
SAT

..
|

THU => 8.25,
=> 7.0,
SUN => 0.0);

Package Specifications and Declarations

7.2

References: basic declarative item 3.9, constant 3.2.1, declarative item 3.9, direct
visibility 8.3, elaboration 3.9, expanded name 4.1.3, name 4.1, number declaration

3.2.2, object declaration 3.2.1, package 7, package declaration 7.1, package identifier
7.1, package specification 7.1, scope 8.2, simple name 4.1, type declaration 3.3.1, use
clause 8.4, variable 3.2.1
.

7.3 Package Bodies
1

In contrast to the entities declared in the visible part of a package specifi-

cation, the entities declared in the package body are only visible within the
package body itself. As a consequence, a package with a package body can

be used for the construction of a group of related subprograms (a package in
the usual sense), in which the logical operations available to the users are
clearly isolated from the internal entities.
For the elaboration of a package body, its declarative part is first elaborated,
and its sequence of statements (if any) is then executed. The optional
exception handlers at the end of a package body service exceptions raised
during the execution of the sequence of statements of the package body.
Notes:

A variable declared in the body of a package is only visible within this body
and, consequently, its value can only be changed within the package body. In
the absence of local tasks, the value of such a variable remains unchanged
between calls issued from outside the package to subprogramsdeclared in
the visible part. The properties of such a variable are similar to those of an
“own”variable of Algol 60.
The elaboration of the body of a subprogram declared in the visible part of
a package is caused by the elaboration of the body of the package. Hence a
call of such a subprogram by an outside program unit raises the exception
PROGRAM_ERRORif the call takes place before the elaboration of the
package body (see 3.9).
Example of a package:
package RATIONALNUMBERS is
type RATIONAL is
record
NUMERATOR

INTEGER;

DENOMINATOR
end record;

POSITIVE;

function EQUAL(X,Y

7.3

Package Bodies

RATIONAL)

return BOOLEAN;

7-4

function "/"
(X,Y
INTEGER)
return RATIONAL;
-to construct a rational number
function

"+"

(X,Y

RATIONAL)

return RATIONAL;

function "-"
function "*"
function "/"
end;

(X,Y
(X,Y
(X,Y

RATIONAL)
RATIONAL)
RATIONAL)

return RATIONAL;
return RATIONAL;
return RATIONAL;

package body RATIONALNUMBERS is

procedure SAMEDENOMINATOR (X,Y
begin
--

in out RATIONAL) is

reduces X and Y to the same denominator:

end;
function EQUAL (X,Y
U,V

RATIONAL)

return BOOLEAN is

RATIONAL;

begin
U

:= X;

3:=

SAMEDENOMINATOR (U,V);
return U.NUMERATOR = V.NUMERATOR;
end EQUAL;
function "/"

begin

(X,Y

INTEGER)

return RATIONAL is

if Y > O then
return

(NUMERATOR => X,

DENOMINATOR =>

Y);

(NUMERATOR =>

DENOMINATOR =>

-Y);

else
return

-X,

end if;
end

function "+"
function "-"

(X,Y
(X,Y

RATIONAL)
RATIONAL)

return RATIONAL is
return RATIONAL is

function "/"

(X,Y

RATIONAL)

return RATIONAL is

function "*"

(X,Y

RATIONAL) return RATIONAL is

end "+";
end "-",;

end "x";
end "/";

end RATIONALNUMBERS;

References: declaration 3.1, declarative part 3.9, elaboration 3.1 3.9, exception
11, exception handler 11.2, name 4.1, package specification 7.1, program unit 6,
program_error exception 11.1, sequence of statements 5.1, subprogram 6, variable
3.2.1, visible part 7.2

Package Bodies

7.3

7.4 Private Type and Deferred Constant Declarations
1

The declaration of a type as a private type in the visible part of a package
serves to separate the characteristics that can be used directly by outside
program units (that is, the logical properties) from other characteristics
whose direct use is confined to the package (the details of the definition of
the type itself). Deferred constant declarations declare constants of private

types.

privatetype declaration ::=
type identifier [discriminant_part] 1s [limited] private;
deferredconstantdeclaration

::=

identifierlist : constant typemark;

3 A private type declaration is only allowed as a declarative item of the visible
part of a package, or as the generic parameter declaration for a generic
formal type in a generic formal part.
4

The type mark of a deferred constant declaration must denote a private
type or a subtype of a private type; a deferred constant declaration and the
declaration of the corresponding private type must both be declarative items
of the visible part of the same package. A deferred constant declaration with
several identifiers is equivalent to a sequence of single deferred constant
declarations as explained in section 3.2.

Examples of private type declarations:
type KEY is private;
type FILENAME is limited private;

Example of deferred constant declaration:
NULLKEY : constant KEY;

7.4

References: constant 3.2.1, declaration 3.1, declarative item 3.9, deferred constant
7.4.3, discriminant part 3.7.1, generic formal part 12.1, generic formal type 12.1,
generic parameter declaration 12.1, identifier 2.3, identifier list 3.2, limited type
7.4.4, package 7, private type 7.4.1, program unit 6, subtype 3.3, type 3.3, type
mark 3.3.2, visible part 7.2

Private Type and Deferred Constant Declarations

7-6

7.4.1.

Private Types
1

If a private type declaration is given in the visible part of a package, then
a corresponding declaration of a type with the same identifier must appear
as a declarative item of the private part of the package. The corresponding
declaration mustbe either a full type declaration or the declaration of a task
type. In therest of this section explanations are given in termsof full type
declarations; the samerules apply also to declarations of task types.

A private type declaration and the corresponding full type declaration define
a single type. The private type declaration, together with the visible part,
define the operations that are available to outside program units (see section
7.4.2 on the operations that are available for private types). On the other
hand, the full type declaration defines other operations whose direct use is
only possible within the packageitself.

If the private type declaration includes a discriminant part, the full declaration must include a discriminant part that conforms(see 6.3.1 for the
conformance rules) and its type definition must be a record type definition.
Conversely, if the private type declaration does not include a discriminant
part, the type declared by the full type declaration (the full type) must not
be an unconstrained type with discriminants. The full type must not be
an unconstrained array type. A limited type (in particular a task type) is
allowed for the full type only if the reserved word limited appears in the
private type declaration (see 7.4.4).

Within the specification of the package that declares a private type and
before the end of the corresponding full type declaration, a restriction
applies to the use of a name that denotes the private type or a subtype of
the private type and, likewise, to the use of a name that denotes any type
or subtype that has a subcomponentof the private type. The only allowed
occurrences of such a namearein a deferred constant declaration, a type
or subtype declaration, a subprogram specification, or an entry declaration;
moreover, occurrences within derived type definitions or within simple
expressions are not allowed.”

The elaboration of a private type declaration creates a private type. If the
private type declaration has a discriminant part, this elaboration includes
that of the discriminant part. The elaboration of the full type declaration
consists of the elaboration of the type definition; the discriminantpart, if
any, is not elaborated (since the conforming discriminant part of the private
type declaration has already been elaborated).

1 See also Appendix G, AI-00232.
2 See also Appendix G, AI-00039, AI-00153, and AI-00384.

7-7

Private Types

7.4.1

Notes:

It follows from the given rules that neither the declaration of a variable of
a private type, nor the creation by an allocator of an object of the private

type are allowed before the full declaration of the type. Similarly before the

full declaration, the name of the private type cannot be used in a generic
instantiation or in a representation clause.

References: allocator 4.8, array type 3.6, conform 6.3.1, declarative item 3.9,
deferred constant declaration 7.4.3, derived type 3.4, discriminant part 3.7.1,
elaboration 3.9, entry declaration 9.5, expression 4.4, full type declaration 3.3.1,
generic instantiation 12.3, identifier 2.3, incomplete type declaration 3.8.1, limited
type 7.4.4, name 4.1, operation 3.3, package 7, package specification 7.1, private
part 7.2, private type 7.4, private type declaration 7.4, record type definition 3.7,
representation clause 13.1, reserved word 2.9, subcomponent 3.3, subprogram
specification 6.1, subtype 3.3, subtype declaration 3.3.2, type 3.3, type declaration
3.3.1, type definition 3.3.1, unconstrained array type 3.6, variable 3.2.1, visible
part 7.2

7.4.2

Operations of a Private Type
1

The operations that are implicitly declared by a private type declaration
include basic operations. These are the operations involved in assignment
(unless the reserved word limited appears in the declaration), membership tests, selected components for the selection of any discriminant,

qualification, and explicit conversions.

For a private type T, the basic operations also include the attributes T’ BASE
(see 3.3.3) and T’ SIZE (see 13.7.2). For an object A of a private type, the
basic operations include the attribute A’, CONSTRAINEDif the private type

has discriminants (see 3.7.4), and in any case, the attributes A’ SIZE and

A’ ADDRESS(see 13.7.2).

Finally, the operations implicitly declared by a private type declaration
include the predefined comparison for equality and inequality unless the
reserved word limited appears in the private type declaration.
The above operations, together with subprograms that have a parameter
or result of the private type and that are declared in the visible part of the
package, are the only operations from the package that are available outside
the package for the privatetype.
Within the package that declares the private type, the additional operations
implicitly declared by the full type declaration are also available. However,
the redefinition of these implicitly declared operations is allowed within the
_samedeclarative region, including between the private type declaration and
the corresponding full declaration. An explicitly declared subprogram hides

7.4.2

Operations of a Private Type

7-8

an implicitly declared operation that has the same parameter andresult

type profile (this is only possible if the implicitly declared operation is a

derived subprogram or a predefined operator).

If a composite type has subcomponents of a private type and is declared

outside the package that declares the private type, then the operations
that are implicitly declared by the declaration of the composite type include
all operations that only depend on the characteristics that result from the
private type declaration alone. (For example the operator < is not included
for a one-dimensional array type.)

If the composite typeis itself declared within the package that declares the
private type (including within an inner package or generic package), then
additional operations that depend on the characteristics of the full type are
implicitly declared, as required by the rules applicable to the composite type
(for example the operator < is declared for a one-dimensional array type if
the full type is discrete). These additional operations are implicitly declared
at the earliest place within the immediate scope of the composite type and
after the full type declaration.®

The same rules apply to the operations that are implicitly declared for an

For every private type or subtype T the following attribute is defined:°

T’CONSTRAINED Yields the value FALSE if T denotes an unconstrained
nonformal private type with discriminants; also yields
the value FALSE if T denotes a generic formal private
type, and the associated actual subtype is either an

access type whose designated type is a private type or a type declared by an
incomplete type declaration.*

unconstrained type with discriminants or an uncon-

strained array type; yields the value TRUE otherwise.

The value of this attribute is of the predefined type

BOOLEAN.

Note:

+A private type declaration and the corresponding full type declaration
define two different views of one and the same type. Outside of the defining
package the characteristics of the type are those defined by thevisible part.
Within these outside program units the typeis just a private type and any

language rule that applies only to another class of types does not apply. The

fact that the full declaration might implement the private type with a type

3 See also Appendix G, AI-00139 and AI-00154.
4 See also Appendix G, AI-00154.
5 See also Appendix G, AI-00026.
7-9

Operations of a Private Type

7.4.2

of a particular class (for example, as an array type) is only relevant within
the packageitself.
12

The consequences of this actual implementation are, however, valid everywhere. For example: any default initialization of components takesplace;
the attribute SIZE providesthe size of the full type; task dependence rules
still apply to components that are task objects.

Example:
package KEYMANAGER is
type KEY is private;
NULLKEY : constant KEY;
procedure GETKEY(K : out KEY);
function "<"

(xX,

KEY)

return BOOLEAN;

private
type KEY is new NATURAL;
NULLKEY : constant KEY := 0; |
end;
package body KEYMANAGER is
LASTKEY : KEY := 0;
procedure GETKEY(K : out KEY)
begin
LASTKEY := LASTKEY + 1;

K := LASTKEY;
end GETKEY;
function "<"

begin
end

return
We :

(X,

INTEGER(X)

KEY)
<

return BOOLEAN is

INTEGER(Y) ;

end KEYMANAGER;
Notes on the example:

7.4.2

14.

Outside of the package KEY_MANAGER,the operations available for objects
of type KEY include assignment, the comparison for equality or inequality,
the procedure GET_KEYand the operator “<”; they do not include other
relational operators such as “>=”, or arithmetic operators.

The explicitly declared operator “<” hides the predefined operator “<” implicitly declared by the full type declaration. Within the body of the function, an
explicit conversion of X and Y to the type INTEGERis necessary to invoke
the “<” operator of this type. Alternatively, the result of the function could
be written as not (X >= Y), since the operator “>=” is not redefined.

The value of the variable LAST_KEY, declared in the package body, remains
unchanged betweencalls of the procedure GET_KEY. (See also the Notes of
section 7.3.)

Ce 9?

Operations of a Private Type

7-10

References: assignment 5.2, attribute 4.1.4, basic operation 3.3.3, component

3.3, composite type 3.3, conversion 4.6, declaration 3.1, declarative region 8.1,
derived subprogram 3.4, derived type 3.4, dimension 3.6, discriminant 3.3, equality

4.5.2, full type 7.4.1, full type declaration 3.3.1, hiding 8.3, immediate scope 8.2,

implicit declaration 3.1, incomplete type declaration 3.8.1, membership test 4.5,
operation 3.3, package 7, parameter of a subprogram 6.2, predefined function 8.6,
predefined operator 4.5, private type 7.4, private type declaration 7.4, program unit

6, qualification 4.7, relational operator 4.5, selected component 4.1.3, subprogram 6,

task dependence 9.4, visible part 7.2

7.4.3

Deferred Constants
1

If a deferred constant declaration is given in the visible part of a package
then a constant declaration (that is, an object declaration declaring a
constant object, with an explicit initialization) wath the same identifier must
appear as a declarative item of the private part of the package. This object
declaration is called the full declaration of the deferred constant. The type
mark given in the full declaration must conform to that given in the deferred constant declaration (see 6.3.1). Multiple or single declarations are allowed
for the deferred and the full declarations, provided that the equivalent single
declarations conform.
Within the specification of the package that declares a deferred constant
and before the end of the corresponding full declaration, the use of a name
that denotes the deferred constant is only allowed in the default expression
for a record component or for a formal parameter (not for a generic formal
parameter).

The elaboration of a deferred constant declaration has no othereffect.

The execution of a program is erroneousif it attempts to use the value
of a deferred constant before the elaboration of the corresponding full
declaration.6
Note:
The full declaration for a deferred constant that has a given private type

must not appear before the corresponding full type declaration. This is a
consequenceof the rules defining the allowed uses of a name that denotes a
private type (see 7.4.1).

6 See also Appendix G, AI-00155.

7-11

Deferred Constants

7.4.3

References: conform 6.3.1, constant declaration 3.2.1, declarative item 3.9,
default expression for a discriminant 3.7.1, deferred constant 7.4, deferred constant
declaration 7.4, elaboration has no other effect 3.1, formal parameter 6.1, generic
formal parameter 12.1 12.3, identifier 2.3, object declaration 3.2.1, package 7,
package specification 7.1, private part 7.2, record component 3.7, type mark 3.3.2,
visible part 7.2

7.4.4

Limited Types
1

A limited type is a type for which neither assignment nor the predefined
comparison for equality and inequality is implicitly declared.
A private type declaration that includes the reserved word limited declares
a limited type. A task type is a limited type. A type derived from a limited
type is itself a limited type. Finally, a composite typeis limited if the type of
any of its subcomponentsis limited.

The operations available for a private type that is limited are as given in
section 7.4.2 for private types except for the absence of assignment andof a
predefined comparison for equality and inequality.

For a formal parameter whose type is limited and whosedeclaration occurs
in an explicit subprogram declaration, the mode outis only allowed if this
type is private and the subprogram declaration occurs within the visible part
of the package that declares the private type. The sameholds for formal
parameters of entry declarations and of generic procedure declarations. The
corresponding full type must not be limited if the mode outis used for any
such formal parameter. Otherwise, the corresponding full type is allowed

(but not required) to be a limited type (in particular, it is allowed to be a

task type). If the full type corresponding to a limited private type is not
itself limited, then assignment for the type is available within the package,

but not outside.’

The following are consequencesof the rules for limited types:
e

An explicit initialization is not allowed in an object declaration if the

A default expression is not allowed in a component declaration if the

An explicit initial value is not allowed in an allocator if the designated
type is limited.

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

type of the object is limited.

type of the record componentis limited.

7 See also Appendix G, AI-00260.

7.4.4

Limited Types

7-12

Notes:

The above 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 type is not limited. An explicit declaration of an equality operator is
allowed for a limited type (see 6.7).
Aggregates are not available for a limited composite type (see 3.6.2 and

3.7.4). Catenation is not available for a limited array type (see 3.6.2).
Example:

package IOPACKAGE is
type FILENAME is limited private;
procedure OPEN

(F : in out FILENAME);

procedure CLOSE(F Fo::
procedure READ ( Fo:
procedure WRITE ( F :

private

in out FILENAME);
in FILENAME; ITEM
in FILENAME; ITEM

:
:

out INTEGER) ;
in
INTEGER) ;

type FILENAME is

record

INTERNALNAME

end record;

INTEGER

:= 0;

end I OPACKAGE;

package body IOPACKAGE is

LIMIT : constant := 200;
type FILEDESCRIPTOR is record
DIRECTORY

array

procedure OPEN (F
procedure CLOSE (F
procedure READ (F
ITEM

procedure WRITE (F
begin

ITEM

LIMIT)

...

end record;

of FILEDESCRIPTOR;

: in out FILENAME)
: in out FILENAME)
: in FILENAME;

is...
is...

out INTEGER)

...

end;

...

end;

: in FILENAME;
INTEGER)

end;
end;

end I_OPACKAGE;
Notes on the example:
13

7-13

In the example above, an outside subprogram making use of IO_PACKAGE
may obtain a file name by calling OPEN andlater use it in calls to READ
and WRITE. Thus, outside the package, a file name obtained from OPEN
acts as a kind of password; its internal properties (such as containing a
numeric value) are not known and no other operations (such as addition or
comparison of internal names) can be performedona file name.

Limited Types

7.4.4

14.

This example is characteristic of any case where complete control over the
operations of a type is desired. Such packages serve a dual purpose. They
prevent a user from making use of the internal structure of the type. They
also implement the notion of an encapsulated data type where the only
operations on the type are those given in the package specification.
References: aggregate 4.3, allocator 4.8, assignment 5.2, catenation operator 4.5,

component declaration 3.7, component type 3.3, composite type 3.3, default expression for a discriminant 3.7, deferred constant 7.4.3, derived type 3.4, designate 3.8,
discriminant specification 3.7.1, equality 4.5.2, formal parameter 6.1, full type 7.4.1,
full type declaration 3.3.1, generic formal parameter 12.1 12.3, implicit declaration
3.1, initial value 3.2.1, mode 12.1.1, object 3.2, operation 3.8, package 7, predefined
operator 4.5, private type 7.4, private type declaration 7.4, record component3.7,
record type 3.7, relational operator 4.5, subcomponent 3.3, subprogram 6, task type
9.1 9.2, type 3.3

7.5 Example of a Table Management Package
1

The following example illustrates the use of packages in providing highlevel
procedures with a simple interface to the user.

The problem is to define a table management packagefor inserting and
retrieving items. The items are inserted into the table as they are supplied.
Each inserted item has an order number. The itemsare retrieved according

to their order number, where the item with the lowest ordér numberis

retrievedfirst.

From the user’s point of view, the package is quite simple. There is a type
called ITEM designating table items, a procedure INSERTforinserting
items, and a procedure RETRIEVE for obtaining the item with the lowest

order number. Thereis a special item NULL_ITEMthat is returned when

the table is empty, and an exception TABLE_FULL whichis raised by
INSERTif the table is already full.
4

A sketch of such a package is given below. Only the specification of the
package is exposed to the user.

package TABLEMANAGER is
type ITEM is
record
ORDERNUM :
ITEMCODE :
QUANTITY
:
ITEMTYPE :
end record;

7.5

INTEGER;
INTEGER;
INTEGER;
CHARACTER;

Example of a Table Management Package

7-14

NULLITEM

constant ITEM

(ORDER_NUM |

ITEM_CODE

procedure INSERT

| QUANTITY => 0,

(NEWITEM

>: in

procedure RETRIEVE (FIRSTITEM

TABLEFULL : exception;
end;

ITEMTYPE => ’

‘);

ITEM);

out ITEM);

raised by INSERT when table full

The details of implementing such packages can be quite complex; in this case
they involve a two-waylinked table of internal items. A local housekeeping

procedure EXCHANGEis used to move an internal item between the
busy andthefree lists. The initial table linkages are established by the
initialization part. The package body need not be shown to the users of the
package.
package body TABLEMANAGER is
SIZE : constant := 2000;
subtype INDEX is INTEGER range 0 .. SIZE;
type INTERNALITEM is
record
CONTENT : ITEM;
SUCC

INDEX;

PRED

INDEX;

end record;
TABLE : array (INDEX) of INTERNALITEM;
FIRSTBUSYITEM : INDEX := 0;

FIRSTFREEITEM : INDEX

:= 1;

function FREELISTEMPTY return BOOLEAN is ... end;

function BUSYLISTEMPTY return BOOLEAN is ... end;
procedure EXCHANGE (FROM : in INDEX;

TO : in INDEX) is ... end;

procedure INSERT (NEW_ITEM : in ITEM) is
begin

if FREELISTEMPTY then
raise TABLEFULL;

end if;
-remaining code for INSERT
end INSERT;
procedure RETRIEVE

begin
--

(FIRSTITEM

out ITEM)

...

end;

initialization of the table linkages

end TABLEMANAGER;

7-15

Example of a Table Management Package

7.5

7.6 Example of a Text Handling Package
1

This example illustrates a simple text handling package. The users only
have access to the visible part; the implementation is hidden from them in
the private part and the package body (not shown).

From a user’s point of view, a TEXT is a variable-length string. Each text
object has a maximum length, which must be given when the object is
declared, and a current value, which is a string of some length between

zero and the maximum. The maximum possible length of a text object is an
implementation-defined constant.
The package defines first the necessary types, then functions that return
some characteristics of objects of the type, then the conversion functions

between texts and the predefined CHARACTER and STRINGtypes, and
finally some of the standard operations on varying strings. Most operations
are overloaded on strings and characters as well as on the type TEXT, in
order to minimize the numberof explicit conversions the user has to write.

package TEXTHANDLER is
MAXIMUM : constant

SOMEVALUE;

subtype INDEX is INTEGER range 0

type TEXT (MAXIMUMLENGTH

INDEX)

function LENGTH
function VALUE
function EMPTY

return INDEX;
return STRING;
return BOOLEAN;

function

TOQ_TEXT

(T
(T
(T

TEXT)
TEXT)
TEXT)

MAX
function

TOTEXT

function TOTEXT

function TOTEXT
function "&"
function "&"
function

"&"

function "&"
function "&"

is limited private;

STRING;

INDEX)

return TEXT;

maximum length MAX

CHARACTER;

MAX

7.6

implementation-defined
MAXIMUM;

-(C

INDEX)

STRING)

return TEXT;

maximum length S’ LENGTH
CHARACTER) return TEXT;

(LEFT
RIGHT
(LEFT
RIGHT

TEXT;
TEXT)
TEXT;
STRING)

(LEFT

STRING;

RIGHT
(LEFT

TEXT)
TEXT;

return TEXT;

RIGHT

CHARACTER)

return TEXT;

(LEFT
RIGHT

CHARACTER;
TEXT)

return TEXT;

Example of a Text Handling Package

return TEXT;
return TEXT;

7-16

function "="
function "<"

(LEFT
(LEFT

:
:

TEXT;
TEXT;

RIGHT
RIGHT

:
:

function

"<="

(LEFT

function

">"

(LEFT

function

">="

(LEFT

TEXT)
TEXT)

return BOOLEAN;
return BOOLEAN;

TEXT;

RIGHT

TEXT;

RIGHT

TEXT)

return BOOLEAN;

TEXT)

TEXT;

RIGHT

return BOOLEAN;

TEXT)

return BOOLEAN;

procedure SET
procedure SET

(OBJECT : in out TEXT; VALUE : in TEXT);
(OBJECT : in out TEXT; VALUE : in STRING);

procedure SET

(OBJECT

in out TEXT;

VALUE

in CHARACTER);

procedure APPEND

(TAIL : in TEXT;

TO : in out TEXT);

procedure APPEND
procedure APPEND

(TAIL
(TAIL

TO
TO

procedure AMEND

procedure AMEND
procedure AMEND
---

:
:

in STRING;
in CHARACTER;

(OBJECT
POSITION

>:
:

in out TEXT;
in INDEX);

POSITION

in INDEX);

POSITION

in INDEX);

(OBJECT

:
:
BY

in out TEXT);
in out TEXT);
:

in TEXT;

: in out TEXT; BY : in STRING;

(OBJECT

>: in out TEXT; BY : in CHARACTER;

amend replaces part of the object by the given
text, string, or character

starting at the given position in the object

function LOCATE

(FRAGMENT

WITHIN
function LOCATE (FRAGMENT
WITHIN
function LOCATE (FRAGMENT

:
:
:
:

WITHIN

TEXT;

TEXT) return INDEX;
STRING;
TEXT) return INDEX;
CHARACTER;

>: TEXT)

return INDEX;

all return 0 if the fragment is not located

private
type

TEXT (MAXIMUMLENGTH

INDEX)

record
POS

INDEX

VALUE

STRING(1

MAXIMUMLENGTH) ;

end record;
end TEXTHANDLER;

Example of use of the text handling package:
A program opens an output file, whose nameis supplied by the string
NAME. This string has the form
[DEVICE

[FILENAME

[.EXTENSION] ]

There are standard defaults for device, filename, and extension. The user-

supplied name is passed to EXPAND_FILE_NAMEas a parameter, and the
result is the expanded version, with any necessary defaults added.

7-17

Example of a Text Handling Package

7.6

function EXPANDFILENAME (NAME : STRING)
use TEXTHANDLER;
DEFAULTDEVICE
: constant STRING
DEFAULTFILENAME : constant STRING
DEFAULTEXTENSION : constant STRING

return STRING is
"cy: We

"RESULTS";
" .DAT";

MAXIMUMFILENAMELENGTH
constant INDEX := SOMEAPPROPRIATEVALUE;
FILENAME : TEXT (MAXIMUMFILENAMELENGTH) ;

begin
SET (FILENAME,

NAME) ;

if EMPTY (FILENAME) then
SET (FILENAME, DEFAULTFILENAME);
end if;
1f LOCATE (’:’,

FILENAME)

SET (FILENAME,

then

DEFAULTDEVICE

FILENAME) ;

end if;
if

LOCATE (’.’,

FILENAME)

APPEND (DEFAULTEXTENSION,
end if;

then

TO => FILENAME) ;

return VALUE (FILENAME) ;
end EXPANDFILENAME;

7.6

Example of a Text Handling Package

7-18

Chapter 8

Visibility Rules
The rules defining the scope of declarations and the rules defining which
identifiers are visible at various points in the text of the program are
described in this chapter. The formulation of these rules uses the notion of a
declarative region.
References: declaration 3.1, declarative region 8.1, identifier 2.3, scope 8.2,

visibility 8.3

8.1

Declarative Region
1

A declarative region is a portion of the program text. A single declarative
region is formed by the text of each of the following:
A subprogram declaration, a package declaration, a task declaration,
or a generic declaration, together with the corresponding body, if any.
If the body is a body stub, the declarative region also includes the
corresponding subunit. If the program unit has subunits, they are also
included.
An entry declaration together with the corresponding accept statements.
A record type declaration, together with a corresponding private or
incomplete type declaration if any, and together with a corresponding
record representation clause if any.
A renaming declaration that includes a formal part, or a generic parameter declaration that includes either a formal part or a discriminant
part.

—

A block statement or a loop statement.

Declarative Region

8.1

In each of the above cases, the declarative region is said to be associated
with the corresponding declaration or statement. A declaration is said to

occur immediately within a declarative region if this region is the innermost
region that encloses the declaration, not counting the declarative region (if
any) associated with the declaration itself.

A declaration that occurs immediately within a declarative region is said
to be local to the region. Declarations in outer (enclosing) regions are said
to be global to an inner (enclosed) declarative region. A local entity is one
declared by a local declaration; a global entity is one declared by a global
declaration.
Some of the above forms of declarative region include several disjoint parts
(for example, other declarative items can be between the declaration of a
package and its body). Each declarative region is nevertheless considered

as a (logically) continuous portion of the program text. Hence if any rule
defines a portion of text as the text that extends from somespecific point
of a declarative region to the end of this region, then this portion is the
corresponding subset of the declarative region (for example it does not
include intermediate declarative items between the two parts of a package).
Notes:
As defined in section 3.1, the term declaration includes basic declarations,

implicit declarations, and those declarations that are part of basic declarations, for example, discriminant and parameter specifications. It follows
from the definition of a declarative region that a discriminant specification
occurs immediately within the region associated with the enclosing record
type declaration. Similarly, a parameter specification occurs immediately
within the region associated with the enclosing subprogram body or accept
statement.

The package STANDARDformsa declarative region which enclosesall
library units: the implicit declaration of each library unit is assumed to
occur immediately within this package (see sections 8.6 and 10.1.1).
Declarative regions can be nested within other declarative regions. For
example, subprograms, packages, task units, generic units, and block

statements can be nested within each other, and can contain record type

declarations, loop statements, and accept statements.
13

References: accept statement 9.5, basic declaration 3.1, block statement 5.6,
body stub 10.2, declaration 3.1, discriminant part 3.7.1, discriminant specification
3.7.1, entry declaration 9.5, formal part 6.1, generic body 12.2, generic declaration
12.1, generic parameter declaration 12.1, implicit declaration 3.1, incomplete type

declaration 3.8.1, library unit 10.1, loop statement 5.5, package 7, package body

8.1.

Declarative Region

8-2

7.1, package declaration 7.1, parameter specification 6.1, private type declaration
7.4, record representation clause 13.4, record type 3.7, renaming declaration 8.5,

standard package 8.6, subprogram body 6.3, subprogram declaration 6.1, subunit
10.2, task body 9.1, task declaration 9.1, task unit 9

8.2 Scope of Declarations
1

For each form of declaration, the language rules define a certain portion
of the program text called the scope of the declaration. The scope of a
declaration is also called the scope of any entity declared by the declaration.

Furthermore, if the declaration associates some notation with a declared

entity, this portion of the text is also called the scope of this notation (either
an identifier, a character literal, an operator symbol, or the notation for a
basic operation). Within the scope of an entity, and only there, there are
places where it is legal to use the associated notation in order to refer to
the declared entity. These places are defined by the rules of visibility and
overloading.
The scope of a declaration that occurs immediately within a declarative
region extends from the beginning of the declaration to the end of the

declarative region; this part of the scope of a declaration is called the
immediate scope. Furthermore, for any of the declarations listed below, the
scope of the declaration extends beyond the immediate scope:
(a)

<A declaration that occurs immediately within the visible part of a
package declaration.

(b)

An entry declaration.

(c)

A component declaration.

(d)

A discriminant specification.

(e)

A parameterspecification.

(f)

A generic parameter declaration.

In each of these cases, the given declaration occurs immediately within some
enclosing declaration, and the scope of the given declaration extends to the
end of the scope of the enclosing declaration.
In the absence of a subprogram declaration, the subprogram specification
given in the subprogram bodyor in the body stub acts as the declaration
and rule (e) applies also in such a case.

Scope of Declarations

8.2

Note:
11

The above scope rules apply to all forms of declaration defined by section 3.1;
in particular, they apply also to implicit declarations. Rule (a) applies to a
package declaration and thus not to the package specification of a generic
declaration. For nested declarations, the rules (a) through (f) apply at each
level. For example, if a task unit is declared in thevisible part of a package,
the scope of an entry of the task unit extends to the end of the scope of the
task unit, that is, to the end of the scope of the enclosing package. The scope
of a use clause is defined in section 8.4.
References: basic operation 3.3.3, body stub 10.2, character literal 2.5, component

declaration 3.7, declaration 3.1, declarative region 8.1, discriminant specification

3.7.1, entry declaration 9.5, extends 8.1, generic declaration 12.1, generic parameter
declaration 12.1, identifier 2.3, implicit declaration 3.1, occur immediately within
8.1, operator symbol 6.1, overloading 6.6 8.7, package declaration 7.1, package
specification 7.1, parameter specification 6.1, record type 3.7, renaming declaration
8.5, subprogram body 6.3, subprogram declaration 6.1, task declaration 9.1, task
unit 9, type declaration 3.3.1, use clause 8.4, visibility 8.3, visible part 7.2

8.3 Visibility
1

The meaning of the occurrence of an identifier at a given place in the
text is defined by the visibility rules and also, in the case of overloaded
declarations, by the overloading rules. The identifiers considered in this
chapter include any identifier other than a reserved word, an attribute
designator, a pragmaidentifier, the identifier of a pragma argument, or
an identifier given as a pragma argument. Theplaces considered in this
chapter are those where a lexical element (such as an identifier) occurs.
The overloaded declarations considered in this chapter are those for
subprograms, enumeration literals, and single entries.
For each identifier and at each place in the text, the visibility rules
determine a set of declarations (with this identifier) that define possible
meanings of an occurrence of the identifier. A declaration is said to be
visible at a given place in the text when, accordingto the visibility rules, the
declaration defines a possible meaning of this occurrence. Two casesarise.

8.3

Visibility

Thevisibility rules determine at most one possible meaning. In such
a case the visibility rules are sufficient to determine the declaration
defining the meaning of the occurrenceof the identifier, or in the absence
of such a declaration, to determine that the occurrenceis not legal at the
given point.

Thevisibility rules determine more than one possible meaning. In such
a case the occurrenceof the identifier is legal at this point if and only if
8—4

exactly one visible declaration is acceptable for the overloading rules in
the given context (see section 6.6 for the rules of overloading and section
8.7 for the context used for overload resolution).
A declaration is only visible within a certain part of its scope; this part
starts at the end of the declaration except in a package specification, in
which case it starts at the reserved word is given after the identifier of
the package specification. (This rule applies, in particular, for implicit
declarations.)
Visibility is either by selection or direct. A declaration is visible by selection
at places that are defined asfollows.

(a)

For a declaration given in thevisible part of a package declaration:
at the place of the selector after the dot of an expanded name whose
prefix denotes the package.

(b)

For an entry declaration of a given task type: at the place of the selector after the dot of a selected component whose prefix is appropriate for
the task type.

(c)

For a component declaration of a given record type declaration: at
the place of the selector after the dot of a selected component whose
prefix is appropriate for the type; also at the place of a component
simple name(before the compound delimiter =>) in a named component
association of an aggregate of the type.

(d)

For a discriminant specification of a given type declaration: at the
sameplaces as for a component declaration; also at the place of a
discriminant simple name (before the compound delimiter =>) in a
named discriminant association of a discriminant constraint for the

type.

8-5

(e)

For a parameter specification of a given subprogram specification
or entry declaration: at the place of the formal parameter (before
the compound delimiter =>) in a named parameterassociation of a
corresponding subprogram or entry call.

(f)

For a generic parameter declaration of a given generic unit: at
the place of the generic formal parameter (before the compound
delimiter =>) in a named generic association of a corresponding generic
instantiation.

Finally, within the declarative region associated with a construct other than
a record type declaration, any declaration that occurs immediately within
the region is visible by selection at the place of the selector after the dot of
an expanded name whose prefix denotes the construct.

Visibility

8.3

14.

Whereit is not visible by selection, a visible declaration is said to be
directly visible. A declaration is directly visible within a certain part of
its immediate scope; this part extends to the end of the immediate scope
of the declaration, but excludes places where the declaration is hidden as
explained below. In addition, a declaration occurring immediately within

the visible part of a package can be madedirectly visible by meansof a use
clause according to the rules described in section 8.4. (See also section 8.6
for the visibility of library units.)

A declaration is said to be hidden within (part of) an inner declarative
region if the inner region contains a homographof this declaration; the

outer declaration is then hidden within the immediate scope of the inner

homograph. Each of two declarations is said to be a homograph of the other
if both declarations have the sameidentifier and overloading is allowed for

at most one of the two. If overloading is allowed for both declarations, then

each of the two is a homograph of the other if they have the sameidentifier,
operator symbol, or character literal, as well as the same parameter and

result type profile (see 6.6). 4
i¢

Within the specification of a subprogram, every declaration with the same

designator as the subprogram is hidden; the same holds within a generic
instantiation that declares a subprogram, and within an entry declaration
or the formal part of an accept statement; where hidden in this manner, a
declaration is visible neither by selection nor directly.2

17.

Two declarations that occur immediately within the same declarative region
must not be homographs, unless either or both of the following requirements
are met: (a) exactly one of them is the implicit declaration of a predefined
operation; (b) exactly one of them is the implicit declaration of a derived
subprogram. In such cases, a predefined operation is always hidden by

the other homograph; a derived subprogram hides a predefined operation,
but is hidden by any other homograph. Where hidden in this manner, an
implicit declaration is hidden within the entire scope of the other declaration
(regardless of which declaration occurs first); the implicit declaration is
visible neither by selection nor directly. ?
is

Whenevera declaration with a certain identifier is visible from a given point,
the identifier and the declared entity (if any) are also said to be visible from

that point. Direct visibility and visibility by selection are likewise defined
for character literals and operator symbols. An operatoris directly visible if
and only if the corresponding operator declaration is directly visible. Finally,

1 See also Appendix G, AI-00286.
2 See also Appendix G, AI-00370.
3 See also Appendix G, AI-00002 and AI-00330.
8.3

Visibility

8-6

the notation associated with a basic operation is directly visible within the
entire scope of this operation.4
19

Example:
procedure P is
A, B : BOOLEAN;
procedure © is
C

BOOLEAN;

B : BOOLEAN;
begin

an inner homograph of B

:= A;

means

Q0.B

P.A;

P.B;

means

Q.C

P.B;

:= B;

means

P.A

end;

begin
A

:= P.B;

Note on the visibility of library units:
20

The visibility of library units is determined by with clauses (see 10.1.1)
and by the fact that library units are implicitly declared in the package
STANDARD(see 8.6).
Note on homographs:

The sameidentifier may occur in different declarations and may thus be

associated with different entities, even if the scopes of these declarations
overlap. Overlap of the scopes of declarations with the same identifier can
result from overloading of subprograms and of enumeration literals. Such
overlaps can also occur for entities declared in package visible parts and for
entries, record components, and parameters, where thereis overlap of the
scopes of the enclosing package declarations, task declarations, record type
declarations, subprogram declarations, renaming declarations, or generic
declarations. Finally overlapping scopes can result from nesting.
Note on immediate scope,hiding, and visibility:

The rules defining immediate scope, hiding, and visibility imply that a

reference to an identifier within its own declaration is illegal (except for

packages and generic packages). The identifier hides outer homographs

within its immediate scope, that is, from the start of the declaration; on the

other hand, the identifier is visible only after the end of the declaration. For
this reason, all but the last of the following declarationsare illegal:
4 See also Appendix G, AI-00027.
8-7

Visibility

8.3

INTEGER

:= K * K;

--~-

illegal
illegal

procedure Q(X : REAL := Q);

---

illegal, even if there is
a function named Q

---~-

an inner declaration
is legal (although
confusing)

procedure R(R : REAL);

illegal

T : T;
procedure P(X : P);

References: accept statement 9.5, aggregate 4.3, appropriate for a type 4.1,

argument 2.8, basic operation 3.3.3, character literal 2.5, component association
4.3, component declaration 3.7, compound delimiter 2.2, declaration 3.1, declarative
region 8.1, designate 3.8, discriminant constraint 3.7.2, discriminant specification
3.7.1, entry call 9.5, entry declaration 9.5, entry family 9.5, enumerationliteral
specification 3.5.1, expanded name 4.1.3, extends 8.1, formal parameter 6.1, generic
association 12.3, generic formal parameter 12.1, generic instantiation 12.3, generic
package 12.1, generic parameter declaration 12.1, generic unit 12, identifier 2.3,

immediate scope 8.2, implicit declaration 3.1, lexical element 2.2, library unit

10.1, object 3.2, occur immediately within 8.1, operator 4.5, operator symbol6.1,

overloading 6.6 8.7, package 7, parameter 6.2, parameter association 6.4, parameter

specification 6.1, pragma 2.8, program unit 6, record type 3.7, reserved word 2.9,
scope 8.2, selected component 4.1.3, selector 4.1.3, simple name 4.1, subprogram 6,
subprogram call 6.4, subprogram declaration 6.1, subprogram specification 6.1, task
type 9.1, task unit 9, type 3.3, type declaration 3.3.1, use clause 8.4, visible part 7.2

8.4

Use Clauses
1
2

A use clause achieves direct visibility of declarations that appear in the

visible parts of named packages.

useclause ::= use package_name {, package_name};

For each use clause, there is a certain region of text called the scope of the
use clause. This region starts immediately after the use clause. If a use
clause is a declarative item of some declarative region, the scope of the
clause extends to the end of the declarative region. If a use clause occurs
within a context clause of a compilation unit, the scope of the use clause
extends to the end of the declarative region associated with the compilation

unit.

8.4

In order to define which declarations are madedirectly visible at a given
place by use clauses, consider the set of packages namedbyall use clauses
whose scopes enclose this place, omitting from this set any packages that
enclose this place. A declaration that can be made directly visible by a
use clause (a potentially visible declaration) is any declaration that occurs
immediately within the visible part of a package of the set. A potentially

Use Clauses

8-8

visible declaration is actually made directly visible except in the following
two cases:

A potentially visible declaration is not made directly visible if the
place considered is within the immediate scope of a homographof the
declaration.°

Potentially visible declarations that have the sameidentifier are not
made directly visible unless each of them is either an enumeration
literal specification or the declaration of a subprogram (by a subprogram
declaration, a renaming declaration, a generic instantiation, or an
implicit declaration).

The elaboration of a use clause has no othereffect.
Note:

The above rules guarantee that a declaration that is made directly visible by
a use clause cannot hide an otherwisedirectly visible declaration. The above
rules are formulated in termsof the set of packages namedby useclauses.

Consequently, the following lines of text all have the sameeffect (assuming
only one package P).
use P;
use P;

use

Example of conflicting names in two packages:
procedure R is
package TRAFFIC is
type COLOR is

(RED,

AMBER,

GREEN) ;

end TRAFFIC;

package WATERCOLORS is
type COLOR is

(WHITE, RED, YELLOW, GREEN,
BLUE, BROWN, BLACK) ;

end WATER_COLORS;
use TRAFFIC;
use WATERCOLORS;

COLOR,

two homographs of GREEN

----

RED,

AMBER,

and GREEN

are directly visible

are directly visible but
COLOR is no longer directly visible

5 See also Appendix G, AI-00286.
8-9

Use Clauses

8.4

subtype LIGHT is TRAFFIC.COLOR;
-- Subtypes are used
subtype SHADE is WATER_COLORS.COLOR; -- to resolve the
-- conflicting
—-- type name COLOR
SIGNAL

LIGHT;

PAINT

SHADE;

SIGNAL
PAINT

:= GREEN;
= GREEN;

begin

end R;

---

that of TRAFFIC
that of WATERCOLORS

Example of nameidentification with a use clause:
package D is

T, U, V : BOOLEAN;

end D;

procedure P is
package E is
B,

end E;

INTEGER;

procedure Q is

T, X : REAL;

use D,

begin

------

the
the
the
the
the

D.V or E.V must be used

name
name
name
name
name

T
U
B
W
X

means
means
means
means
means

Q.T,
D.U
E.B
E.W
Q.X

the name V is illegal

not D.T

: either

end Q;

begin

end P;

References: compilation unit 10.1, context clause 10.1, declaration 3.1, declarative

item 3.9, declarative region 8.1, direct visibility 8.3, elaboration 3.1 3.9, elaboration

has no other effect 3.1, enumeration literal specification 3.5.1, extends 8.1, hiding

8.3, homograph 8.3, identifier 2.3, immediate scope 8.2, name 4.1, occur immediately

within 8.1, package 7, scope 8.2, subprogram declaration 6.1, visible part 7.2

8.4

Use Clauses

8-10

8.5 Renaming Declarations
1

A renaming declaration declares another namefor an entity.
renamingdeclaration ::=
identifier : typemark
| identifier : exception
| package identifier
| subprogramspecification

renames object_name;
renames exceptionname;
renames packagename;
renames subprogram_or_entry_name;

The elaboration of a renaming declaration evaluates the namethat follows
the reserved word renames and thereby determines the entity denoted by
this name (the renamed entity). At any point where a renaming declaration
is visible, the identifier, or operator symbol of this declaration denotes the
renamed entity.

The first form of renaming declaration is used for the renamingof objects.

The renamed entity must be an object of the base type of the type mark.
The properties of the renamed object are not affected by the renaming

declaration. In particular, its value and whetheror not it is a constant are
unaffected; similarly, the constraints that apply to an object are not affected
by renaming (any constraint implied by the type mark of the renaming
declaration is ignored). The renaming declaration is legal only if exactly one
object has this type and can be denoted by the object name.°
The following restrictions apply to the renaming of a subcomponent that
depends on discriminants of a variable. The renamingis not allowed if

the subtype of the variable, as defined in a corresponding object declaration, component declaration, or component subtype indication, is an
unconstrained type; or if the variable is a generic formal object (of mode in
out). Similarly if the variable is a formal parameter, the renaming is not

allowed if the type mark given in the parameter specification denotes an

unconstrained type whose discriminants have default expressions. ’

The second form of renaming declaration is used for the renaming of
exceptions; the third form, for the renaming of packages.
The last form of renaming declaration is used for the renaming of subprograms and entries. The renamed subprogram or entry and the subprogram
specification given in the renaming declaration must have the same param-

eter and result type profile (see 6.6). The renaming declarationis legal only

if exactly one visible subprogram or entry satisfies the above requirements
and can be denoted by the given subprogram or entry name. In addition,

6 See also Appendix G, AI-00001.
7 See also Appendix G, AI-00170.
8-11

Renaming Declarations

8.5

parameter modes must be identical for formal parameters that are at the
same parameter position.

The subtypes of the parameters and result (if any) of a renamed subprogram
or entry are not affected by renaming. These subtypes are those given
in the original subprogramdeclaration, generic instantiation, or entry
declaration (not those of the renaming declaration); even for calls that use
the new name. On the other hand, a renaming declaration can introduce
parameter names and default expressions that differ from those of the
renamed subprogram; namedassociations of calls with the new subprogram
name must use the new parameter name; calls with the old subprogram
name must use the old parameter names®

A procedure can only be renamedas a procedure. Either of a function or

operator can be renamedaseither of a function or operator; for renaming as

an operator, the subprogram specification given in the renaming declaration
is subject to the rules given in section 6.7 for operator declarations.
Enumeration literals can be renamedas functions; similarly, attributes
defined as functions (such as SUCC and PRED) can be renamed as
functions. An entry can only be renamed as a procedure; the new nameis
only allowed to appear in contexts that allow a procedure name. An entry of
a family can be renamed, but an entry family cannot be renamed as a whole.
10

Examples:
declare

L : PERSON renames LEFTMOSTPERSON; -- see 3.8.1
begin
L.AGE := L.AGE + 1;

end;

FULL : exception renames TABLEMANAGER.TABLEFULL; -- see 7.5

package TM renames TABLEMANAGER;
function REALPLUS(LEFT, RIGHT
return REAL
renames "+";
function INTPLUS (LEFT, RIGHT
return INTEGER renames "+";

REAL

)

INTEGER)

function ROUGE return COLOR renames RED;
-function ROT
return COLOR renames RED;
function ROSSO return COLOR renames ROUGE;
function NEXT(X
-- see 3.5.5

COLOR)

see 3.5.1

return COLOR renames COLOR’ SUCC;

8 See also Appendix G, AI-00245.
8.5

Renaming Declarations

8-12

Example of a renaming declaration with new parameter names:
function "*"

-- see 6.1

(X,Y : VECTOR) return REAL renames DOTPRODUCT;

Example of a renaming declaration with a new default expression:
function MINIMUM(L
-- see 6.1

LINK

:= HEAD)

return CELL renames MINCELL;

Notes:

Renaming may be used to resolve nameconflicts and to act as a shorthand.
Renaming with a different identifier or operator symbol does not hide
the old name; the new nameandthe old name need notbevisible at the

same points. The attributes POS and VAL cannot be renamedsince the
corresponding specifications cannot be written; the same holds for the
predefined multiplying operators with a uwniversal_fixed result.

Calls with the new name of a renamed entry are procedure call statements
and are not allowed at places where the syntax requires an entry call
statement in conditional and timed entry calls; similarly, the COUNT
attribute is not available for the new name.
15

A task object that is declared by an object declaration can be renamed as an
object. However, a single task cannot be renamedsince the corresponding
task type is anonymous. For similar reasons, an object of an anonymous
array type cannot be renamed. No syntactic form exists for renaming a
generic unit.

A subtype can be used to achievethe effect of renaming a type (including a
task type) as in

subtype MODE is TEXT_IO.FILEMODE;

References: allow 1.6, attribute 4.1.4, base type 3.3, conditional entry call 9.7.2,
constant 3.2.1, constrained subtype 3.3, constraint 3.3, declaration 3.1, default
expression 6.1, depend on a discriminant 3.7.1, discriminant 3.7.1, elaboration 3.1
3.9, entry 9.5, entry call 9.5, entry call statement 9.5, entry declaration 9.5, entry
family 9.5, enumeration literal 3.5.1, evaluation of a name 4.1, exception 11, formal
parameter 6.1, function 6.5, identifier 2.3, legal 1.6, mode 6.1, name 4.1, object 3.2,
object declaration 3.2, operator 6.7, operator declaration 6.7, operator symbol 6.1,
package 7, parameter 6.2, parameter specification 6.1, procedure 6.1, procedure call
statement 6.4, reserved word 2.9, subcomponent 3.3, subprogram 6, subprogram call
6.4, subprogram declaration 6.1, subprogram specification 6.1, subtype 3.3.2, task
object 9.2, timed entry call 9.7.3, type 3.3, type mark 3.3.2, variable 3.2.1,
visibility 8.3

8-13

Renaming Declarations

8.5

8.6 The Package Standard
1

The predefined types (for example the types BOOLEAN, CHARACTER and
INTEGER)are the types that are declared in a predefined packagecalled
STANDARD; this package also includes the declarations of their predefined
operations. The package STANDARDis described in Annex C. Apart from

the predefined numeric types, the specification of the package STANDARD
must be the sameforall implementations of the language.

The package STANDARDformsa declarative region which encloses every
library unit and consequently the main program; the declaration of every
library unit is assumed to occur immediately within this package. The
implicit declarations of library units are assumedto be ordered in such a
way that the scope of a given library unit includes any compilation unit that
mentions the given library unit in a with clause. However, the only library
units that are visible within a given compilation unit are as follows: they
include the library units namedbyall with clauses that apply to the given
unit, and moreover, if the given unit is a secondary unit of some library unit,

they include this library unit. ?
Notes:

If all block statements of a program are named, then the nameof each
program unit can always be written as an expanded namestarting with
STANDARD (unless this packageis itself hidden).
If a type is declared in the visible part of a library package, then it is a

consequenceof the visibility rules that a basic operation (such as assignment) for this type is directly visible at places where the typeitself is not
visible (whether by selection or directly). However this operation can only
be applied to operands that are visible and the declaration of these operands
requires the visibility of either the type or one of its subtypes.
References: applicable with clause 10.1.1, block name 5.6, block statement 5.6,
declaration 3.1, declarative region 8.1, expanded name 4.1.3, hiding 8.3, identifier
2.3, implicit declaration 3.1, library unit 10.1, loop statement 5.5, main program
10.1, must 1.6, name 4.1, occur immediately within 8.1, operator 6.7, package 7,
program unit 6, secondary unit 10.1, subtype 3.3, type 3.8, visibility 8.3,

with clause 10.1.1

9 See also Appendix G, AI-00192.
8.6

The Package Standard

8-14

8.7

The Context of Overload Resolution
Overloading is defined for subprograms, enumeration literals, operators, and
single entries, and also for the operations that are inherent in several basic

operations such as assignment, membershiptests, allocators, the literal

null, aggregates, and stringliterals.

For overloaded entities, overload resolution determines the actual meaning

that an occurrence of an identifier has, wheneverthevisibility rules have

determined that more than one meaningis acceptable at the place of this

occurrence; overload resolution likewise determines the actual meaning of
an occurrence of an operator or some basic operation.
At such a place all visible declarations are considered. The occurrence is

only legal if there is exactly one interpretation of each constituent of the
innermost complete context; a complete context is one of the following:19
e

A declaration.

<A statement.

A representation clause.

Whenconsidering possible interpretations of a complete context, the only
rules considered are the syntax rules, the scope andvisibility rules, and the

rules of the form described below.1!

(a)

Any rule that requires a nameor expression to have a certain type, or

(b)

Any rule that requires the type of a name or expression to be a type of
a certain class; similarly, any rule that requires a certain type to be a

to have the same type as another nameor expression.12

discrete, integer, real, universal, character, boolean, or nonlimited type.

(c)

Any rule that requires a prefix to be appropriate for a certain type.

(d)

Any rule that specifies a certain type as the result type of a basic
operation, and any rule that specifies that this type is of a certain
class.

(e)

The rules that require the type of an aggregate or string literal to
be determinable solely from the enclosing complete context (see 4.3
and 4.2). Similarly, the rules that require the type of the prefix of an
attribute, the type of the expression of a case statement, or the type of

10 See also Appendix G, AI-00120.
11 See also Appendix G, AI-00157.
12 See also Appendix G, AI-00193.
8-15

The Context of Overload Resolution

8.7

the operand of a type conversion, to be determinable independently of
the context (see 4.1.4, 5.4, 4.6, and 6.4.1).

(f)

The rules given in section 6.6, for the resolution of overloaded
subprogram calls; in section 4.6, for the implicit conversions of
universal expressions; in section 3.6.1, for the interpretation of discrete
ranges with bounds having a universal type; and in section 4.1.3,
for the interpretation of an expanded name whoseprefix denotes a

subprogram or an accept statement.!®

Subprogram names used as pragma argumentsfollow a different rule: the
pragma can apply to several overloaded subprograms, as explained in section
6.3.2 for the pragma INLINE,in section 11.7 for the pragma SUPPRESS,
and in section 13.9 for the pragma INTERFACE.
Similarly, the simple names given in context clauses (see 10.1.1) and in

address clauses (see 13.5) follow different rules.
Notes:

If there is only one possible interpretation, the identifier denotes the corresponding entity. However, this does not mean that the occurrence is
necessarily legal since other requirements exist which are not considered for
overload resolution; for example, the fact that an expression is static, the
parameter modes, whether an object is constant, conformancerules, forcing

occurrences for a representation clause, order of elaboration, and so on.
17

Similarly, subtypes are not considered for overload resolution (the violation
of a constraint does not make a program illegal but raises an exception
during program execution).
Rules that require certain constructs to have the same parameter and result
type profile fall under the category (a); the sameholds for rules that require
conformance of two constructs since conformance requires that corresponding
names be given the same meaningbythevisibility and overloading rules.
A loop parameterspecification is a declaration, and hence a complete
context.

References: aggregate 4.3, allocator 4.8, assignment 5.2, basic operation 3.3.3,
case statement 5.4, class of type 3.3, declaration 3.1, entry 9.5, enumeration literal
3.5.1, exception 11, expression 4.4, formal part 6.1, identifier 2.3, legal 1.6, literal
4.2, loop parameter specification 5.5, membership test 4.5.2, name 4.1, null literal
3.8, operation 3.3.3, operator 4.5, overloading 6.6, pragma 2.8, representation clause
13.1, statement 5, static expression 4.9, static subtype 4.9, subprogram 6, subtype
3.3, type conversion 4.6, visibility 8.3

13 See also Appendix G, AI-00287.
8.7.

The Context of Overload Resolution

8-16

Rule of the form (a): address clause 13.5, assignment 5.2, choice 3.7.3 4.3.2 5.4,

component association 4.3.1 4.3.2, conformance rules 9.5, default expression 3.7 3.7.1
6.1 12.1.1, delay statement 9.6, discrete range 3.6.1 5.5 9.5, discriminant constraint
3.7.2, enumeration representation clause 13.8, generic parameter association
12.3.1, index constraint 3.6.1, index expression 4.1.1 4.1.2 9.5, initial value 3.2.1,

membership test 4.5.2, parameter association 6.4.1, parameter and result type
profile 8.5 12.3.6, qualified expression 4.7, range constraint 3.5, renaming of an
object 8.5, result expression 5.8
22

8-17

Rules of the form (b): abort statement 9.10, assignment 5.2, case expression 5.4,

condition 5.3 5.5 5.7 9.7.1, discrete range 3.6.1 5.5 9.5, fixed point type declaration
3.5.9, floating point type declaration 3.5.7, integer type declaration 3.5.4, length
clause 13.2, membership test 4.4, number declaration 3.2.2, record representation
clause 13.4, selected component 4.1.3, short-circuit control form 4.4, val
attribute 3.5.5

Rules of the form (c): indexed component 4.1.1, selected component 4.1.3,

slice 4.1.2

Rules of the form (d): aggregate 4.3, allocator 4.8, membership test 4.4, null
literal 4.2, numeric literal 2.4, short-circuit control form 4.4, string literal 4.2

The Context of Overload Resolution

8.7

Chapter 9

Tasks

The execution of a program that does not contain a task is defined in terms
of a sequential execution of its actions, according to the rules described
in other chapters of this manual. These actions can be considered to be
executed by a single logical processor.
Tasks are entities whose executions proceed in parallel in the following

sense. Each task can be considered to be executed by a logical processor of
its own. Different tasks (different logical processors) proceed independently,
except at points where they synchronize.

Some tasks have entries. An entry of a task can be called by other tasks. A
task accepts a call of one of its entries by executing an accept statement for
the entry. Synchronization is achieved by rendezvous between a task issuing
an entry call and a task accepting the call. Some entries have parameters;
entry calls and accept statements for such entries are the principal means of
communicating values between tasks.
The properties of each task are defined by a corresponding task unit which
consists of a task specification and a task body. Task units are one of the
four forms of program unit of which programs can be composed. The other
forms are subprograms, packages and generic units. The properties of task
units, tasks, and entries, and the statements that affect the interaction
between tasks (that is, entry call statements, accept statements, delay
statements, select statements, and abort statements) are described in this

chapter.

9—1

Note:

9.1

Parallel tasks (parallel logical processors) may be implemented on multicomputers, multiprocessors, or with interleaved execution on a single physical
processor. On the other hand, whenever an implementation can detect that
the sameeffect can be guaranteed if parts of the actions of a given task are
executed by different physical processors acting in parallel, it may choose
to execute them in this way; in such a case, several physical processors
implement a single logical processor.

References : abort statement 9.10, accept statement 9.5, delay statement 9.6,
entry 9.5, entry call statement 9.5, generic unit 12, package 7, parameter in an
entry call 9.5, program unit 6, rendezvous 9.5, select statement 9.7, subprogram 6,
task body 9.1, task specification 9.1

Task Specifications and Task Bodies
1

A task unit consists of a task specification and a task body. A task
specification that starts with the reserved words task type declares a task
type. The value of an object of a task type designates a task having the
entries, if any, that are declared in the task specification; these entries are

also called entries of this object. The execution of the task is defined by the
corresponding task body.
2

A task specification without the reserved word type defines a single
task. A task declaration with this form of specification is equivalent to
the declaration of an anonymous task type immediately followed by the
declaration of an object of the task type, and the task unit identifier names
the object. In the remainderof this chapter, explanations are given in terms
of task type declarations; the corresponding explanations for single task
declarations follow from the stated equivalence.
task_declaration ::= task_specification;
task_specification ::=
task [type]

identifier

[is

{entrydeclaration}
{representation_clause}
end [task_simplename] ]

9.1

Task Specifications and Task Bodies

9-2

task_body ::=

task body task_simplename is
[declarativepart]

begin
sequenceofstatements
[exception
exceptionhandler
{exceptionhandler} ]

end [tasksimplename];

The simple nameat the start of a task body must repeat the task unit
identifier. Similarly if a simple name appears at the end of the task
specification or body, it must repeat the task unit identifier. Within a task
body, the nameof the corresponding task unit can also be used to refer
to the task object that designates the task currently executing the body;
furthermore, the use of this name as a type markis not allowed within the
task unit itself.
For the elaboration of a task specification, entry declarations and representation clauses, if any, are elaborated in the order given. Such representation
clauses only apply to the entries declared in the task specification (see 13.5).
The elaboration of a task body has noothereffect than to establish that
the body can from then on be used for the execution of tasks designated by
objects of the corresponding task type.
The execution of a task body is invoked by the activation of a task object of
the corresponding type (see 9.3). The optional exception handlers at the end
of a task body handle exceptions raised during the execution of the sequence
of statements of the task body (see 11.4).
Examples of specifications of task types:
task type RESOURCE is
entry SEIZE;

entry RELEASE;

end RESOURCE;

task type KEYBOARDDRIVER is
entry READ

out CHARACTER) ;

entry WRITE(C : in
end KEYBOARDDRIVER;

CHARACTER) ;

Task Specifications and Task Bodies

9.1

Examples of specifications of single tasks:
task PRODUCERCONSUMER is
entry READ (V : out ITEM);
entry WRITE(E : in ITEM);
end;
task CONTROLLER is
entry REQUEST(LEVEL) (D

ITEM);

a family of entries

end CONTROLLER;

task USER;

has no entries

Example of task specification and corresponding body:
task PROTECTEDARRAY is
--

INDEX and ITEM are global types

entry READ

(N : in INDEX; V : out ITEM);

entry WRITE(N

end;

in INDEX;

task body PROTECTEDARRAY is
TABLE : array(INDEX) of ITEM

begin
loop
select
accept READ
V

ITEM);

(INDEX => NULLITEM);

(N : in INDEX; V : out ITEM)

:= TABLE (N);

end READ;

accept WRITE(N : in INDEX; E : in
TABLE (N)

end WRITE;
end select;
end loop;

ITEM)

:= E;

end PROTECTEDARRAY;

Note:

A task specification specifies the interface of tasks of the task type with
other tasks of the sameorof different types, and also with the main
program.
References : declaration 3.1, declarative part 3.9, elaboration 3.9, entry 9.5, entry

declaration 9.5, exception handler 11.2, identifier 2.3, main program 10.1, object 3.2,
object declaration 3.2.1, representation clause 13.1, reserved word 2.9, sequence of

statements 5.1, simple name 4.1, type 3.3, type declaration 3.3.1

9.1

Task Specifications and Task Bodies

9—4

9.2 Task Types and Task Objects
1

A task typeis a limited type (see 7.4.4). Hence neither assignment nor the

predefined comparison for equality and inequality are defined for objects of
task types; moreover, the mode out is not allowed for a formal parameter
whosetype is a task type.

A task object is an object whose type is a task type. The value of a task

object designates a task that has the entries of the corresponding task type,
and whose execution is specified by the corresponding task body. If a task
object is the object, or a subcomponentof the object, declared by an object
declaration, then the value of the task object is defined by the elaboration of

the object declaration. If a task object is the object, or a subcomponentof the

object, created by the evaluation of an allocator, then the value of the task

object is defined by the evaluation of the allocator. For all parameter modes,

if an actual parameter designates a task, the associated formal parameter

designates the same task; the same holds for a subcomponent of an actual

parameter and the corresponding subcomponentof the associated formal
parameter;finally, the same holds for generic parameters.

Examples:
CONTROL

: RESOURCE;

TELETYPE : KEYBOARDDRIVER;
POOL
>: array(1 .. 10) of KEYBOARDDRIVER;
-see also examples of declarations of single tasks

in 9.1

Example of access type designating task objects:
type KEYBOARD is access KEYBOARDDRIVER;
TERMINAL

KEYBOARD

:= new KEYBOARDDRIVER;

Notes:
Since a task type is a limited type, it can appear as the definition of a

limited private type in a private part, and as a generic actual parameter

associated with a formal parameter whose type is a limited type. On the

other hand, the type of a generic formal parameter of mode in must not be a
limited type and hence cannot be a task type.
Task objects behave as constants (a task object always designates the

same task) since their values are implicitly defined either at declaration

or allocation, or by a parameter association, and since no assignmentis
available. However the reserved word constantis not allowed in the
declaration of a task object since this would require an explicit initialization.
A task object that is a formal parameter of mode in is a constant (as is any
formal parameter of this mode).
Task Types and Task Objects

9.2

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 (see above example).
Assignmentis available for such an access type as for any access type.

Subtype declarations are allowed for task types as for other types, but there
are no constraints applicable to task types.

9.3

References: access type 3.8, actual parameter 6.4.1, allocator 4.8, assignment5.2,

component declaration 3.7, composite type 3.3, constant 3.2.1, constant declaration
3.2.1, constraint 3.3, designate 3.8 9.1, elaboration 3.9, entry 9.5, equality operator
4.5.2, formal parameter 6.2, formal parameter mode 6.2, generic actual parameter
12.8, generic association 12.3, generic formal parameter 12.1, generic formal parameter mode 12.1.1, generic unit 12, inequality operator 4.5.2, initialization 3.2.1,
limited type 7.4.4, object 3.2, object declaration 3.2.1, parameter association 6.4,
private part 7.2, private type 7.4, reserved word 2.9, subcomponent 3.3, subprogram
6, subtype declaration 3.3.2, task body 9.1, type 3.3

Task Execution—Task Activation
1

A task body defines the execution of any task that is designated by a task
object of the corresponding task type. The initial part of this execution is
called the activation of the task object, and also that of the designated task;
it consists of the elaboration of the declarative part, if any, of the task body.
The execution of different tasks, in particular their activation, proceeds in
parallel.

If an object declaration that declares a task object occurs immediately within
a declarative part, then the activation of the task object starts after the
elaboration of the declarative part (that is, after passing the reserved word
begin following the declarative part); similarly if such a declaration occurs
immediately within a package specification, the activation starts after the
elaboration of the declarative part of the package body. The same holds for
the activation of a task object that is a subcomponentof an object declared
immediately within a declarative part or package specification. Thefirst
statement following the declarative part is executed only after conclusion of

the activation of these task objects.
3

9.3

Should an exception be raised by the activation of one of these tasks,
that task becomes a completed task (see 9.4); other tasks are not directly
affected. Should one of these tasks thus become completed duringits
activation, the exception TASKING_ERRORis raised upon conclusion of the
activation of all of these tasks (whether successfully or not); the exception
is raised at a place that is immediately before the first statement following
the declarative part (immediately after the reserved word begin). Should

Task Execution—Task Activation

9-6

several of these tasks thus become completed during their activation, the
exception TASKING_ERRORis raised only once.!
4

Should an exception be raised by the elaboration of a declarative part or
package specification, then any task that is created (directly or indirectly)
by this elaboration and that is not yet activated becomes terminated andis
therefore never activated (see section 9.4 for the definition of a terminated
task).

For the above rules, in any package body without statements, a null
statement is assumed. For any package without a package body, an implicit
package body containing a single null statement is assumed. If a package
without a package body is declared immediately within some program
unit or block statement, the implicit package body occurs at the end of the
declarative part of the program unit or block statement; if there are several
such packages, the order of the implicit package bodies is undefined.”

A task object that is the object, or a subcomponent ofthe object, created by
the evaluation of an allocator is activated by this evaluation. The activation
starts after any initialization for the object created by the allocator; if
several subcomponents are task objects, they are activated in parallel. The
access value designating such an object is returned by the allocator only
after the conclusion of these activations.

Should an exception be raised by the activation of one of these tasks, that
task becomes a completed task; other tasks are not directly affected. Should
one of these tasks thus become completed duringits activation, the exception
TASKING_ERRORis raised upon conclusion of the activation of all of these
tasks (whether successfully or not); the exception is raised at the place
wheretheallocator is evaluated. Should several of these tasks thus become
completed during their activation, the exception TASKING_ERRORis raised
only once.

Should an exception be raised by theinitialization of the object created by
an allocator (hence before the start of any activation), any task designated
by a subcomponentof this object becomes terminated and is therefore never

activated*

1 See also Appendix G, AI-00268.
2 See also Appendix G, AI-00198.
3 See also Appendix G, AI-00237.
* See also Appendix G, AI-00198.
9-7

Task Execution—Task Activation

9.3

Example:
procedure P is
A,

C
begin
---

RESOURCE;

>: RESOURCE;

elaborate the task objects A,

elaborate the task object C

the tasks A, B, C are activated in parallel
before the first statement

end;

Notes:

An entry of a task can be called before the task has been activated. If
several tasks are activated in parallel, the execution of any of these tasks
need not await the end of the activation of the other tasks. A task may
become completed during its activation either because of an exception or
because it is aborted (see 9.10).

References: allocator 4.8, completed task 9.4, declarative part 3.9, elaboration
3.9, entry 9.5, exception 11, handling an exception 11.4, package body 7.1, parallel

execution 9, statement 5, subcomponent 3.3, task body 9.1, task object 9.2, task

termination 9.4, task type 9.1, tasking_error exception 11.1

9.4 Task Dependence—Termination of Tasks
1

Each task depends on at least one master. ° A master is a construct thatis
either a task, a currently executing block statement or subprogram,or a

library package (a package declared within another program unit is not a

master). The dependence on a masteris a direct dependence in the following

two cases:

(a)

The task designated by a task object that is the object, or a subcomponent of the object, created by the evaluation of an allocator depends on
the master that elaborates the corresponding access type definition.

(b)

The task designated by any other task object depends on the master
whose execution creates the task object.

Furthermore, if a task depends on a given master that is a block statement
executed by another master, then the task dependsalso on this other master,

in an indirect manner; the same holds if the given master is a subprogram

called by another master, and if the given masteris a task that depends

(directly or indirectly) on another master. Dependences exist for objects of a

private type whose full declaration is in termsof a task type.
5 See also Appendix G, AI-00167.
9.4

Task Dependence—Termination of Tasks

9-8

A task is said to have completed its execution whenit has finished the
execution of the sequence of statements that appears after the reserved
word begin in the corresponding body. Similarly a block or a subprogram
is said to have completed its execution when it has finished the execution
of the corresponding sequence of statements. For a block statement, the
execution is also said to be completed when it reaches an exit, return,
or goto statement transferring control out of the block. For a procedure,

the execution is also said to be completed when a corresponding return
statement is reached. For a function, the execution is also said to be
completed after the evaluation of the result expression of a return statement.
Finally the execution of a task, block statement, or subprogram is completed
if an exception is raised by the execution of its sequence of statements and
there is no corresponding handler, or, if there is one, when it has finished
the execution of the corresponding handler®
6

If a task has no dependenttask, its termination takes place when it
has completed its execution. After its termination, a task is said to be
terminated. If a task has dependent tasks, its termination takes place
when the execution of the task is completed and all dependent tasks are
terminated. A block statement or subprogram body whose execution is

completed is not left until all of its dependent tasks are terminated.’

Termination of a task otherwise takes place if and only if its execution has
reached an open terminate alternative in a select statement (see 9.7.1), and
the following conditions are satisfied:

The task depends on some master whose execution is completed (hence
not a library package).
Each task that depends on the master considered is either already

terminated or similarly waiting on an open terminate alternative of a

select statement.

When both conditions are satisfied, the task considered becomes terminated,

together with all tasks that depend on the master considered.

6 See also Appendix G, AI-00173.
7 See also Appendix G, AI-00441.
9-9

Task Dependence—Termination of Tasks

9.4

Example:
declare
type GLOBAL is access RESOURCE;
A,
G

begin

:
:

see 9.1

RESOURCE;
GLOBAL;

-activation of A and B
declare

type LOCAL is access RESOURCE;
X : GLOBAL := new RESOURCE;
-L
C

:
:

LOCAL
:= new RESOURCE;
RESOURCE;

activation of X.all
activation of L.all

begin
-- activation of C
G := X;
-- both G and X designate the same task object
end;
end;

await termination of C and L.all

await termination of A,

(but not X.all)

and G.all

Notes:

The rules given for termination imply that all tasks that depend (directly or
indirectly) on a given master and that are not already terminated, can be
terminated(collectively) if and only if each of them is waiting on an open
terminate alternative of a select statement and the execution of the given
master is completed.

The usual rules apply to the main program. Consequently, termination of
the main program awaits termination of any dependent task even if the
corresponding task type is declared in a library package. On the other hand,
termination of the main program does not await termination of tasks that
depend on library packages; the language does not define whether such
tasks are required to terminate.
In VAX Ada, the environmenttask that calls the main program (see 10.1) is
the master of tasks that depend on library packages. Thus, in accordance
with the rules of this section, the environment task awaits termination of

such tasks. In particular, the rules concerning terminate alternatives in
select statements apply.

14.

For an access type derived from another access type, the corresponding

access type definition is that of the parent type; the dependenceis on the

master that elaborates the ultimate parent access type definition.
is

9.4

Arenaming declaration defines a new namefor an existing entity and hence
creates no further dependence.

Task Dependence—Termination of Tasks

9-10

References : access type 3.8, allocator 4.8, block statement 5.6, declaration
3.1, designate 3.8 9.1, exception 11, exception handler 11.2, exit statement 5.7,
function 6.5, goto statement 5.9, library unit 10.1, main program 10.1, object
3.2, open alternative 9.7.1, package 7, program unit 6, renaming declaration 8.5,
return statement 5.8, selective wait 9.7.1, sequence of statements 5.1, statement5,
subcomponent 3.3, subprogram body 6.3, subprogram call 6.4, task body 9.1, task
object 9.2, terminate alternative 9.7.1

9.5 Entries, Entry Calls, and Accept Statements
1

Entry calls and accept statements are the primary meansof synchronization
of tasks, and of communicating values between tasks. An entry declaration
is similar to a subprogram declaration and is only allowed in a task
specification. The actions to be performed when an entry is called are
specified by corresponding accept statements.
entrydeclaration

::=

entry identifier

[{(discreterange)]

entrycallstatement

::= entry_name

[formalpart];

[actualparameterpart];

acceptstatement ::=
accept entrysimplename

sequenceofstatements

end

[(entryindex)]

[formalpart]

[do

[entrysimplename]];

entryindex ::= expression

An entry declaration that includes a discrete range (see 3.6.1) declares a
family of distinct entries having the same formal part (if any); that is, one
such entry for each value of the discrete range. The term single entry is
used in the definition of any rule that applies to any entry other than one of
a family. The task designated by an object of a task type has (or owns) the
entries declared in the specification of the task type.
Within the body of a task, each of its single entries or entry families can
be named by the corresponding simple name. The nameof an entry of a
family takes the form of an indexed component, the family simple name
being followed by the index in parentheses; the type of this index must be
the same as that of the discrete range in the corresponding entry family
declaration. Outside the body of a task an entry namehasthe form of a
selected component, whose prefix denotes the task object, and whoseselector
is the simple nameof oneof its single entries or entry families.

9-11

Entries, Entry Calls, and Accept Statements

9.5

A single entry overloads a subprogram, an enumerationliteral, or another

single entry if they have the same identifier. Overloading is not defined for

entry families. A single entry or an entry of an entry family can be renamed
as a procedure as explained in section 8. 5.8
6

The parameter modes defined for parameters of the formal part of an entry

An accept statement specifies the actions to be performed at a call of a
named entry (it can be an entry of a family). The formal part of an accept

declaration are the same as for a subprogram declaration and have the same
meaning (see 6.2). The syntax of an entry call statement is similar to that of
a procedure call statement, and the rules for parameter associations are the
same as for subprogram calls (see 6.4.1 and 6.4.2).

statement must conform to the formal part given in the declaration of the

single entry or entry family namedby the accept statement(see section 6.3.1

for the conformancerules). If a simple name appears at the end of an| accept
statement, it must repeat that given at the start.

An accept statement for an entry of a given task is only allowed within the
corresponding task body; excluding within the body of any program unit
that is, itself, inner to the task body; and excluding within another accept
statement for either the same single entry or an entry of the same family.
(One consequenceof this rule is that a task can execute accept statements
only for its own entries.) A task body can contain more than one accept
statement for the same entry.

For the elaboration of an entry declaration, the discrete range, if any, is
evaluated and the formal part, if any, is then elaborated as for a subprogram
declaration.

Execution of an accept statement starts with the evaluation of the entry
index (in the case of an entry of a family). Execution of an entry call
statement starts with the evaluation of the entry name;this is followed by
any evaluations required for actual parameters in the same mannerasfor a
subprogram call (see 6.4). Further execution of an accept statement and of a
corresponding entry call statement are synchronized.

Ifa given entry is called by only one task, there are twopossibilities:

Ifthe calling task issues an entry call statement before a corresponding
accept statement is reached by the task owningthe entry, the execution
of the calling task is suspended.

Ifatask reaches an accept statement prior to any call of that entry, the
execution of the task is suspended until such a call is received.

8 See also Appendix G, AI-00287.
9.5

Entries, Entry Calls, and Accept Statements

9-12

When anentry has been called and a corresponding accept statement has

been reached, the sequence of statements, if any, of the accept statement is

executed by the called task (while the calling task remains suspended). This
interaction is called a rendezvous. Thereafter, the calling task and the task
owning the entry continue their execution in parallel.

If several tasks call the same entry before a corresponding accept statement

is reached, the calls are queued; there is one queue associated with each
entry. Each execution of an accept statement removes one call from the

queue. Thecalls are processed in the orderof arrival.

An attempt to call an entry of a task that has completed its execution
raises the exception TASKING_ERRORatthe pointof the call, in the
calling task; similarly, this exception is raised at the point of thecall if
the called task completes its execution before accepting the call (see also

9.10 for the case when the called task becomes abnormal). The exception

CONSTRAINT_ERRORisraised if the index of an entry of a family is not

within the specified discrete range.

Examplesof entry declarations:
entry READ(V : out ITEM);
entry SEIZE;
entry REQUEST (LEVEL) (D : ITEM);

a family of entries

Examples of entry calls:

CONTROL. RELEASE;

see

9.2 and 9.1

PRODUCERCONSUMER.WRITE (E) ;

see

9.1

POOL (5) .READ (NEXTCHAR) ;

see

9.2 and 9.1

CONTROLLER. REQUEST (LOW) (SOMEITEM) ;

see

9.1

Examples of accept statements:
accept SEIZE;

accept READ(V : out ITEM)

V := LOCALITEM;

end READ;

accept REQUEST (LOW) (D

ITEM)

end REQUEST;

Entries, Entry Calls, and Accept Statements

9.5

Notes:
20

The formal part given in an accept statement is not elaborated; it is only
used to identify the corresponding entry.
An accept statement can call subprogramsthat issue entry calls. An accept
statement need not have a sequence of statements even if the corresponding
entry has parameters. Equally, it can have a sequence of statements even if
the corresponding entry has no parameters. The sequence of statements of
an accept statement can include return statements. A task can call its own
entries but it will, of course, deadlock. The language permits conditional
and timed entry calls (see 9.7.2 and 9.7.3). The language rules ensure that a
task can only be in one entry queue at a given time.
If the bounds of the discrete range of an entry family are integerliterals, the
index (in an entry nameor accept statement) must be of the predefined type
INTEGER(see 3.6.1).
References : abnormal task 9.10, actual parameter part 6.4, completed task 9.4,
conditional entry call 9.7.2, conformance rules 6.3.1, constraint_error exception 11.1,
designate 9.1, discrete range 3.6.1, elaboration 3.1 3.9, enumeration literal 3.5.1,

evaluation 4.5, expression 4.4, formal part 6.1, identifier 2.3, indexed component
4.1.1, integer type 3.5.4, name 4.1, object 3.2, overloading 6.6 8.7, parallel execution
9, prefix 4.1, procedure 6, procedure call 6.4, renaming declaration 8.5, return

statement 5.8, scope 8.2, selected component 4.1.3, selector 4.1.3, sequence of
statements 5.1, simple expression 4.4, simple name 4.1, subprogram 6, subprogram
body 6.8, subprogram declaration 6.1, task 9, task body 9.1, task specification 9.1,
tasking_error exception 11.1, timed entrycall 9.7.3

9.6

Delay Statements, Duration, and Time
1

The execution of a delay statement evaluates the simple expression, and
suspends further execution of the task that executes the delay statement,
for at least the duration specified by the resulting value. ?
delaystatement ::= delay simpleexpression;

The simple expression must be of the predefined fixed point type
DURATION;its value is expressed in seconds; a delay statement with
a negative value is equivalent to a delay statement with a zero value.

9 See also Appendix G, AI-00201 and AI-00464.
9.6

Delay Statements, Duration, and Time

9-14

Any implementation of the type DURATION must allow representation
of durations (both positive and negative) up to at least 86400 seconds
(one day); the smallest representable duration, DURATION’ SMALL
must not be greater than twenty milliseconds (wheneverpossible, a
value not greater than fifty microseconds should be chosen). Note that
DURATION’ SMALLneednot correspondto the basic clock cycle, the named
number SYSTEM.TICK(see 13.7). 1°

In VAX Ada, DURATION’ SMALLis 2~}4 seconds, or approximately 61

microseconds. The value does not correspond to the value of the named

number SYSTEM.TICK, whichis 10.0~2 seconds (10 milliseconds) in VAX

Ada. (SYSTEM.TICK represents the smallest unit of time used by the VMS
operating system in its time-related system services.)
5

The definition of the type TIMEis provided in the predef sed library package
CALENDAR.The function CLOCK returns the current value of TIME at the

time it is called. The functions YEAR, MONTH, DAY and SECONDSreturn
the corresponding values for a given value of the type TIME; 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 therelational operators for
times, have the conventional meaning.1!
In VAX Ada, the type TIME is implemented as VMSbinary time.
6

The exception TIME_ERRORis raised by the function TIME_OFif the
actual parameters do not form a proper date. This exception is also
raised by the operators “+” and “~” if, for the given operands, these operators
cannot return a date whose year numberis in the range of the corresponding
subtype, or if the operator “—” cannot return a result that is in the range of

the type DURATION.12
7

package CALENDAR is
type TIME is private;
subtype YEARNUMBER

is INTEGER

subtype MONTHNUMBER is INTEGER

range 1901
range 1

12;

2099;

subtype DAYNUMBER
is INTEGER range 1... 31;
subtype DAYDURATION is DURATION range 0.0 .. 86400.0;
function CLOCK return TIME;

10 See also Appendix G, AI-00201.
11 See also Appendix G, AI-00195 and AI-00201.
12 See also Appendix G, AI-00196.
9-15

Delay Statements, Duration, and Time

9.6

function YEAR
(DATE
function MONTH
(DATE
function DAY
(DATE
function SECONDS(DATE
procedure SPLIT

:
:
:
:

TIME)
TIME)
TIME)
TIME)

(DATE

>: in

YEAR
MONTH

:
:

out YEARNUMBER;
out MONTHNUMBER;

DAY

out

DAYNUMBER;

SECONDS

out

DAYDURATION) ;

function TIMEOF (YEAR

MONTH
DAY
SECONDS
function

"+"

function "+"
function "-"
function "-"
function
function
function
function

"<"
"<="
">"
">="

return YEARNUMBER;
return MONTHNUMBER;
return DAYNUMBER;
return DAYDURATION;
TIME;

YEARNUMBER;

:
:
:

MONTHNUMBER;
DAYNUMBER;
DAYDURATION := 0.0)

(LEFT

RIGHT

DURATION)

(LEFT
RIGHT
(LEFT
RIGHT
(LEFT

:
:
:
:
:

DURATION;
TIME)
return TIME;
TIME;
DURATION) return TIME;
£xTIME;

RIGHT

TIME)

(LEFT,
(LEFT,
(LEFT,
(LEFT,

RIGHT
RIGHT
RIGHT
RIGHT

TIME;
return

TIME;

return DURATION;

:
:
:
:

TIME)
TIME)
TIME)
TIME)

return
return
return
return

can be raised by TIMEOF,

"+",

and "-"

TIMEERROR : exception;
--

return TIME;

BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;

private
-- implementation-dependent

end; 13

Examples:
delay 3.0;

delay 3.0 seconds

declare
use CALENDAR;

INTERVAL is a global constant of type DURATION

NEXTTIME

TIME

:= CLOCK + INTERVAL;

begin
loop
delay NEXTTIME - CLOCK;
-- some actions
NEXTTIME

end loop;
end;

:= NEXTTIME + INTERVAL;

13 See also Appendix G, AI-00355.
9.6

Delay Statements, Duration, and Time

9-16

Notes:
The second example causesthe loop to be repeated every INTERVAL seconds

on average. This interval between two successive iterations is only approximate. However, there will be no cumulative drift as long as the duration of
each iteration is (sufficiently) less than INTERVAL.
References : adding operator 4.5, duration C, fixed point type 3.5.9, function call
6.4, library unit 10.1, operator 4.5, package 7, private type 7.4, relational operator
4.5, simple expression 4.4, statement 5, task 9, type 3.3

named number3.2, system predefined package 13.7 13.7.1

9.7

Select Statements
There are three forms of select statements. One form provides a selective
wait for one or more alternatives. The other two provide conditional and
timed entry calls.

selectstatement ::= selectivewait
| conditionalentrycall | timed_entrycall
References : selective wait 9.7.1, conditional entry call 9.7.2, timed entry call 9.7.3

9.7.1

Selective Waits
This form of the select statement allows a combination of waiting for, and
selecting from, one or more alternatives. The selection can depend on
conditions associated with each alternative of the selective wait.
selectivewait ::=
select
selectalternative
{or
selectalternative}
[else
sequenceofstatements]
end select;
selectalternative ::=
[when condition =>]

selectivewaitalternative

selectivewaitalternative ::= acceptalternative
| delayalternative | terminatealternative

9-17

Selective Waits

9.7.1

acceptalternative ::= accept_statement

[sequenceofstatements]

delayalternative

[sequence_ofstatements]

::= delaystatement

terminatealternative ::= terminate;

A selective wait must contain at least one accept alternative. In addition
a selective wait can contain either a terminate alternative (only one), or

one or more delay alternatives, or an else part; these three possibilities are
mutually exclusive.
4

A select alternative is said to be open if it does not start with when and a

For the execution of a selective wait, any conditions specified after when
are evaluated in someorder that is not defined by the language; open
alternatives are thus determined. For an open delay alternative, the delay
expression is also evaluated. Similarly, for an open accept alternative for an
entry of a family, the entry index is also evaluated. Selection and execution
of one open alternative, or of the else part, then completes the execution of
the selective wait; the rules for this selection are described below.14

Open accept alternatives arefirst considered. Selection of one such alternative takes place immediately if a corresponding rendezvousis possible, that
is, if there is a corresponding entry call issued by another task and waiting
to be accepted. If several alternatives can thus be selected, one of them is
selected arbitrarily (that is, the language does not define which one). When
such an alternative is selected, the corresponding accept statement and possible subsequent statements are executed. If no rendezvous is immediately
possible and there is no else part, the task waits until an open selective wait
alternative can be selected.

Selection of the other forms of alternative or of an else part is performed as
follows:

An open delay alternative will be selected if no accept alternative can
be selected before the specified delay has elapsed (immediately, for
a negative or zero delay in the absence of queued entry calls); any
subsequent statements of the alternative are then executed. If several
delay alternatives can thus be selected (that is, if they have the same
delay), one of them is selected arbitrarily.

Theelse part is selected and its statements are executed if no accept
alternative can be immediately selected, in particular, if all alternatives
are closed.

condition, or if the condition is TRUE. It is said to be closed otherwise.

14 See also Appendix G, AI-00030.
9.7.1

Selective Waits

9-18

An open terminate alternative is selected if the conditions stated in

The exception PROGRAM_ERRORisraisedif all alternatives are closed and
there is no else part.

Examples of a select statement:

section 9.4 are satisfied. It is a consequence of other rules that a
terminate alternative cannot be selected while there is a queued entry
call for any entry of the task.

select
accept DRIVERAWAKESIGNAL;
or

delay 30.0*SECONDS;

STOPTHETRAIN;
end select;

Example of a task body with a select statement:
task body RESOURCE is
BUSY

BOOLEAN

begin
loop
select

:= FALSE;

when not BUSY =>

accept SEIZE do
BUSY
end;

:= TRUE;

accept RELEASE do
BUSY
end;

:= FALSE;

or
terminate;
end select;

end loop;

end RESOURCE;

Notes:

A selective wait is allowed to have several open delay alternatives. A
selective wait is allowed to have several open accept alternatives for the
same entry.

9-19

References : accept statement 9.5, condition 5.3, declaration 3.1, delay expression
9.6, delay statement 9.6, duration 9.6, entry 9.5, entry call 9.5, entry index 9.5, program_error exception 11.1, queued entry call 9.5, rendezvous 9.5, select statement
9.7, sequence of statements 5.1, task 9

Selective Waits

9.7.1

9.7.2

Conditional Entry Calls
1

A conditional entry call issues an entry call that is then canceled if a

rendezvous is not immediately possible.1°
conditionalentrycall ::=

select
entrycallstatement
[sequenceofstatements]
else
sequenceofstatements
end select;

For the execution of a conditional entry call, the entry nameis first evalu-

ated. This is followed by any evaluations required for actual parameters as

in the case of a subprogram call (see 6.4).

The entry call is canceled if the execution of the called task has not reached
a point where it is ready to accept thecall (that is, either an accept statement for the corresponding entry, or a select statement with an open accept

alternative for the entry), or if there are prior queued entry calls for this

entry. If the called task has reached a select statement, the entrycall is

canceled if an accept alternative for this entry is not selected.

If the entry call is canceled, the statements of the else part are executed.
Otherwise, the rendezvous takes place; and the optional sequence of
statements after the entry call is then executed.

The execution of a conditional entry call raises the exception TASKING_

ERRORif the called task has already completed its execution (see also 9.10
for the case when the called task becomes abnormal).
Example:
procedure SPIN(R

begin
loop

RESOURCE)

select
R.SEILZE;

return;
else

null;

busy waiting

end select;

end loop;

end;

15 See also Appendix G, AI-00276 and AI-00444.

9.7.2

Conditional Entry Calls

9-20

References : abnormal task 9.10, accept statement 9.5, actual parameter part
6.4, completed task 9.4, entry call statement 9.5, entry family 9.5, entry index
9.5, evaluation 4.5, expression 4.4, open alternative 9.7.1, queued entry call 9.5,

rendezvous 9.5, select statement 9.7, sequence of statements 5.1, task 9, tasking_

error exception 11.1

9.7.3.

Timed Entry Calls
1

A timed entry call issues an entrycall that is canceled if a rendezvous is not

started within a given delay.

timed_entrycall ::=
select
entrycallstatement
[sequenceofstatements]
or
delayalternative

end select;

For the execution of a timed entry call, the entry nameis first evaluated.
This is followed by any evaluations required for actual parameters as in the
case of a subprogram call (see 6.4). The expression stating the delay is then
evaluated, and the entrycall is finally issued.
If a rendezvous can be started within the specified duration (or immediately,
as for a conditional entry call, for a negative or zero delay), it is performed
and the optional sequence of statements after the entry call is then executed.
Otherwise, the entry call is canceled when the specified duration has
expired, and the optional sequence of statements of the delay alternativeis

executed. 16

The execution of a timed entry call raises the exception TASKING_ERROR
if the called task completes its execution before accepting the call (see also
9.10 for the case when the called task becomes abnormal).
Example:
select
or

CONTROLLER. REQUEST (MEDIUM) (SOMEITEM) ;

delay 45.0;
-- controller too busy, try something else

end select;

16 See also Appendix G, AI-00276.
9-21

Timed Entry Calls

9.7.3

9.8

References : abnormal task 9.10, accept statement 9.5, actual parameter part
6.4, completed task 9.4, conditional entry call 9.7.2, delay expression 9.6, delay
statement 9.6, duration 9.6, entry call statement 9.5, entry family 9.5, entry index
9.5, evaluation 4.5, expression 4.4, rendezvous 9.5, sequence of statements 5.1, task
9, tasking_error exception 11.1

Priorities
1

Each task may (but need not) have a priority, which is a value of the
subtype PRIORITY (of the type INTEGER)declared in the predefined
library package SYSTEM (see 13.7). 1” A lower value indicates a lower
degree of urgency; the rangeof priorities is implementation-defined. A
priority is associated with a task if a pragma 18
pragma PRIORITY

(static_expression);

appears in the corresponding task specification; the priority is given by the
value of the expression. A priority is associated with the main program if
such a pragma appearsin its outermost declarative part. At most one such
pragma can appear within a given task specification or for a subprogram
that is a library unit, and these are the only allowed places for this pragma.
A pragma PRIORITY has noeffect if it occurs in a subprogram other than
the main program.

VAX Adaspecifies the subtype PRIORITY to be of the type INTEGER with
a range of 0..15. A VAX Ada task whosepriority has not been explicitly
specified has a default priority of 7.
3

The specification of a priority is an indication given to assist the implementation in the allocation of processing resources to parallel tasks when there
are more taskseligible for execution than can be supported simultaneously
by the available processing resources. The effect of priorities on scheduling
is defined by the following rule:

If two tasks with different priorities are both eligible for execution and
could sensibly be executed using the same physical processors and the

same other processing resources, then it cannot be the case that the

task with the lower priority is executing while the task with the higher
priority is not. 19

17 See also Appendix G, AI-00197.
18 See also Appendix G, AI-00031.

19 See also Appendix G, AI-00032 and AI-00288.
9.8

Priorities

9-22

For tasks of the same priority, the scheduling orderis not defined by the
language. For tasks without explicit priority, the scheduling rules are
not defined, except when such tasks are engaged in a rendezvous. If the
priorities of both tasks engaged in a rendezvousare defined, the rendezvous
is executed with the higher of the two priorities. If only one of the two
priorities is defined, the rendezvous is executed with at least that priority. If
neither is defined, the priority of the rendezvous is undefined.
Notes:
The priority of a task is static and therefore fixed. However, the prior-

ity during a rendezvousis not necessarily static since it also depends on
the priority of the task calling the entry. Priorities should be used only
to indicate relative degrees of urgency; they should not be used for task
synchronization.
References: declarative part 3.9, entry call statement 9.5, integer type 3.5.4, main
program 10.1, package system 13.7, pragma 2.8, rendezvous 9.5, static expression
4.9, subtype 3.3, task 9, task specification 9.1

9.8a Time Slicing
In VAX Ada, a task is executed either until it becomes suspendedor until
a task of higher priority becomeseligible for execution. Tasks of the same
priority are executedin first-in first-out order (by default).
To allow additional control over the fairness of task scheduling, VAX Ada
provides the pragma TIME_SLICE. This pragma enables round-robin task
scheduling. In other words, the pragma causesthe task scheduler to limit
the amount of continuous execution time given to a task when other tasks of
the samepriority are also eligible for execution. The form of this pragmais
as follows:
pragma TIMESLICE (static_expression);

The static expression gives the value of a time slice in seconds; it must be
of the predefined fixed point type DURATION.A positive, nonzero value
enables round-robin scheduling; a negative or zero value disablesit.
This pragmais only allowed in the outermost declarative part of a subprogram thatis a library unit; at most one such pragmais allowed in a
subprogram. If it occurs in a subprogram other than the main program,this
pragmahasnoeffect.

9-23

Time Slicing

9.8a

The following rules define the effect of enabling round-robin scheduling with
the pragma TIME_SLICE:
e

The value applies to the scheduling of every task in the program.

As long as an executing task is not preempted from the processor by a
task of higher priority and as long as it does not become suspended,it
will execute for at most the numberof seconds (approximate elapsed
time) specified by the pragma. Then,if other tasks of the samepriority
are eligible for execution, the executing task will stop executing, and the
task that has been waiting the longest will be selected for execution.

Notes:

The amountof scheduling overhead needed to support round-robin task
scheduling increases as the valueof a time slice decreases. See the VAX Ada

Run-Time Reference Manual for the recommended minimum value.

The VAX Ada predefined package SYSTEM_RUNTIME_TUNINGalso has
operations that enable time slicing. See the VAX Ada Run-Time Reference
Manualfor more information on this package.
References: allow 1.6, declarative part 3.9, duration 9.6, fixed point type 3.5.9,

library unit 10.1, main program 10.1, pragma 2.8, priority of a task 9.8, static
expression 4.9, subprogram 6, task 9

9.9 Task and Entry Attributes
1

For a task object or value T the following attributes are defined:

T’ CALLABLE

Yields the value FALSE when the execution of the task

designated by T is either completed or terminated,

or when the task is abnormal. Yields the value
TRUEotherwise. The value of this attribute is of the

predefined type BOOLEAN.

9.9

T’ TERMINATED

Yields the value TRUE if the task designated by T
is terminated. Yields the value FALSE otherwise.
The value of this attribute is of the predefined type
BOOLEAN.

In addition, the representation attributes STORAGE_SIZE, SIZE, and

ADDRESSare defined for a task object T or a task type T (see 13.7.2).

Task and Entry Attributes

9-24

The attribute COUNTis defined for an entry E of a task unit T. The entry
can be either a single entry or an entry of a family (in either case the name
of the single entry or entry family can be either a simple or an expanded

name). This attribute is only allowed within the body of T, but excluding

within any program unit thatis, itself, inner to the body ofT.
6

E’ COUNT

Yields the numberof entry calls presently queued

on the entry E (if the attribute is evaluated by the
execution of an accept statement for the entry E, the
count does not include the calling task). The value of
this attribute is of the type universal_integer.20

Note:

Algorithms interrogating the attribute E’ COUNT should take precautions to

References : abnormal task 9.10, accept statement 9.5, attribute 4.1.4, boolean
type 3.5.3, completed task 9.4, designate 9.1, entry 9.5, false boolean value 3.5.3,
queue of entry calls 9.5, storage unit 13.7, task 9, task object 9.2, task type 9.1,
terminated task 9.4, timed entry call 9.7.3, true boolean value 3.5.3, universal_
integer type 3.5.4

9.10

allow for the increase of the value of this attribute for incoming entrycalls,
and its decrease, for example with timed entry calls.

Abort Statements
1
2

An abort statement causes one or more tasks to become abnormal, thus
preventing any further rendezvous with such tasks.
abortstatement

::= abort task_name {,

task_name};

The determination of the type of each task nameuses the fact that the type

For the execution of an abort statement, the given task names are evaluated
in someorder that is not defined by the language. Each named task then
becomes abnormal unless it is already terminated; similarly, any task that

of the nameis a task type.

depends on a named task becomes abnormal unless it is already terminated.

Any abnormal task whose execution is suspended at an accept statement,

a select statement, or a delay statement becomes completed; any abnormal
task whose execution is suspended at an entry call, and that is not yet in a
corresponding rendezvous, becomes completed and is removed from the entry
queue; any abnormal task that has not yet started its activation becomes

20 See also Appendix G, AI-00034.
9-25

Abort Statements

9.10

completed (and hence also terminated). This completes the execution of the
abort statement. 7!
6

The completion of any other abnormal task need not happen before

completion of the abort statement. It must happen no later than when the
abnormal task reaches a synchronization point that is one of the following:
the end of its activation; a point where it causes the activation of another

task; an entry call; the start or the end of an accept statement; a select
statement; a delay statement; an exception handler; or an abort statement.
If a task that calls an entry becomes abnormal while in a rendezvous, its

termination does not take place before the completion of the rendezvous

(see 11:5). 22

The call of an entry of an abnormal task raises the exception TASKING_
ERRORat the place of the call. Similarly, the exception TASKING_ERROR
is raised for any task that has called an entry of an abnormaltask, if the
entry call is still queued or if the rendezvousis not yet finished (whether

the entry call is an entry call statement, or a conditional or timed entry
call); the exception is raised no later than the completion of the abnormal
task. The value of the attribute CALLABLE is FALSE for any task that is
abnormal (or completed).
8
9

If the abnormal completion of a task takes place while the task updates a

variable, then the value of this variable is undefined.

Example:
abort USER,

TERMINAL.all, POOL(3);

Notes:

An abort statement should be used only in extremely severe situations
requiring unconditional termination. A task is allowed to abort any task,
includingitself.

The rules for an abort statement permit either an asynchronous or a synchronous implementation of abnormal task completion. An asynchronous
implementation causes an abnormal task to become completed at arbitrary points in its execution (except where prohibited by the aboverules).
A synchronous implementation causes an abnormal task to become completed only at specific points in its execution (these points must include the
synchronization points listed above).

21 See also Appendix G, AI-00198.
22 See also Appendix G, AI-00446.
9.10

Abort Statements

9-26

VAX Ada uses the synchronous implementation. A meansof ensuring the
completion of an abnormaltask at a particular point in a VAX Ada program
is to insert a delay 0.0 statement at that point.
For more information on the VAX Ada implementation of the abort statement, see the VAX Ada Run-Time Reference Manual.
11

References : abnormal in rendezvous 11.5, accept statement 9.5, activation 9.3,

attribute 4.1.4, callable (predefined attribute) 9.9, conditional entry call 9.7.2, delay

statement 9.6, dependent task 9.4, entry call statement 9.5, evaluation of a name
4.1, exception handler 11.2, false boolean value 3.5.3, name 4.1, queue of entry

calls 9.5, rendezvous 9.5, select statement 9.7, statement 5, task 9, tasking_error
exception 11.1, terminated task 9.4, timed entrycall 9.7.3

9.11

Shared Variables
The normal means of communicating values between tasks is by entry calls
and accept statements.

If two tasks read or update a shared variable (that is, a variable accessible

by both), then neither of them may assume anything about the order in
which the other performs its operations, except at the points where they

synchronize. Two tasks are synchronized at the start and at the end of

their rendezvous. At the start and at the end of its activation, a task is
synchronized with the task that causes this activation. A task that has

completed its execution 1s synchronized with any other task.

For the actions performed by a program that uses shared variables, the
following assumptions can always be made:
e

If between two synchronization points of a task, this task reads a shared
variable whose type is a scalar or access type, then the variableis not
updated by any other task at any time between these twopoints.

If between two synchronization points of a task, this task updates a
shared variable whose type is a scalar or access type, then the variable
is neither read nor updated by any other task at any time between these
two points.

The execution of the program is erroneous if any of these assumptionsis

violated.

If a given task reads the value of a shared variable, the above assumptions
allow an implementation to maintain local copies of the value (for example,
in registers or in some other form of temporary storage); and for as long as
the given task neither reaches a synchronization point nor updates the value

9-27

Shared Variables

9.11

of the shared variable, the above assumptions imply that, for the given task,
reading a local copy is equivalent to reading the shared variableitself.
8

Similarly, if a given task updates the value of a shared variable, the above

assumptions allow an implementation to maintain a local copy of the value,

and to defer the effective store of the local copy into the shared variable
until a synchronization point, provided that every further read or update
of the variable by the given task is treated as a read or update of the local
copy. On the other hand, an implementation is not allowed to introduce a
store, unless this store would also be executed in the canonical order
(see 11.6).

The pragma SHAREDcan be usedto specify that every read or update of

a variable is a synchronization point for that variable; that is, the above
assumptions always hold for the given variable (but not necessarily for other

variables). The form of this pragmais as follows:23
pragma SHARED (variablesimplename);

This pragmais allowed only for a variable declared by an object declaration

An implementation must restrict the objects for which the pragma SHARED

and whose typeis a scalar or access type; the variable declaration and
the pragma must both occur (in this order) immediately within the same
declarative part or package specification; the pragma must appear before
any occurrence of the nameof the variable, other than in an addressclause.
is allowed to objects for which each of direct reading and direct updating is

implemented as an indivisible operation.

VAX Ada does not allow the pragma SHAREDfor objects of floating point
types whose representation is not the sameas the representation of the
type STANDARD.FLOAT(F_floating). Also, VAX Ada does not allow the
pragma SHAREDfor objects of generic formal floating point types and types
derived therefrom. See the VAX Ada Run-Time Reference Manual for more
information on the representation of types and objects and on the use of the
pragma SHARED.
In addition to the pragma SHARED, VAX Ada provides the pragma
VOLATILEto allow variables that are subject to asynchronous modification
to be specified as such.
The pragma VOLATILE prevents the compiler from referring to an earlier

read or write of the variable to deduce the variable’s current value. Thus, —

every read of the variable reads the variable itself, rather than a copy of
the variable located in temporary storage. Likewise, every update of the
variable updates the variable itself, rather than a temporary copy. Note,
23 See also Appendix G, AI-00141.
9.11

Shared Variables

9-28

however, that if the variable is in memory shared by two or more VMS
processes, each process may have its own cached copy of the variable. A
write to this kind of variable must be synchronized by a rendezvous, a VAX
interlocked instruction, or a write to an object that has been specified with
the pragma SHARED.
Unlike the pragma SHARED, the pragma VOLATILE does not guarantee
indivisible access to the shared variable. In other words, it is possible
to read partially updated values of the variable if other synchronization
mechanisms (rendezvous, VAX interlocked instructions, and so on) have
not been used; tasks that share a volatile variable must provide their own
means of synchronizing their references. The form of this pragmais as
follows:
pragma VOLATILE (variablesimplename)

This pragmais allowed only for a variable declared by an object declaration;
the variable can be of any type. The variable declaration and the pragma
must both occur (in this order) immediately within the same declarative
part or package specification; the pragma must appear before any occurrence
of the nameof the variable, other than in an address clause or in one of
the VAX Ada pragmas IMPORT_OBJECT, EXPORT_OBJECT, or PSECT_
OBJECT. It must not occur in combination with the pragma SHARED.
The variable simple name mustnot be the result of a renaming declaration.
If a variable is specified with the pragma VOLATILE, then any renaming of
it, or any of its components,is also volatile.
Example:
CONSTANTFIVE
: constant INTEGER := 5;
VOLATILEVAR, DUMMY : INTEGER;
pragma VOLATILE (VOLATILEVAR) ;
begin
VOLATILEVAR

end;

DUMMY

:= CONSTANTFIVE;

:= VOLATILEVAR;

-- statement 1
-- statement 2

In this example, statement 1 represents an update of the variable
VOLATILE_VAR, and statement 2 represents a read of the variable
VOLATILE_VAR. The pragma VOLATILE indicates to the compiler that
the variable VOLATILE_VAR maybesubject to asynchronous modification—
it may be read or updated by a parallel task or asynchronous system service
at unpredictable times. Consequently, the compiler will always refer to the
variable VOLATILE_VAR itself, rather than to a local copy.

9-29

Shared Variables

9.11

To further illustrate, suppose that another task or a VMSsystem service
operation (such as SYS$QIO) were to update the value of VOLATILE_VAR
between statements 1 and 2. Then, the pragma VOLATILEensures that the
value of VOLATILE_VAR used in statement 2 is the value updated by the
parallel task or system service, and not the value assigned in statement1.
Suppose, instead, that another task or aVMS system service operation

were to read the value of VOLATILE_VAR sometimeafter statement 1, but

before statement 2. Then, the pragma VOLATILEensures that the value of
VOLATILE_VAR used by that task or system service is the value assigned
by statement 1.
Notes:

Any variable in VAX Ada that is asynchronously read or written by a VMS
system service must be specified with a pragma VOLATILE,or the program
will be erroneous (see the VMS System Services Reference Manual for information on which system services have parameters that are asynchronously
modified).
If a variable is shared among tasks such that the assumptions about
shared variables given at the beginning of section 9.11 hold, then a pragma
VOLATILEis not needed.
Because of rules about forcing occurrences (see section 13.1), a pragma
VOLATILE or pragma SHARED for an object specified with an address
clause must follow the addressclause.
References : accept statement 9.5, activation 9.3, assignment 5.2, canonical order

11.6, declarative part 3.9, entry call statement 9.5, erroneous 1.6, global 8.1, package
specification 7.1, pragma 2.8, read a value 6.2, rendezvous 9.5, simple name 3.1 4.1,
task 9, type 3.3, update a value 6.2, variable 3.2.1
allow 1.6, component 3.3, f_floating representation 3.5.7, name 4.1, object declaration
3.2.1, package standard C, renaming declaration 8.5

9.12 Example of Tasking
1

The following example defines a buffering task to smooth variations
between the speed of output of a producing task and the speed of input of
some consuming task. For instance, the producing task may contain the
statements

9.12

Example of Tasking

9-30

loop
-produce the next character CHAR
BUFFER.WRITE (CHAR) ;
exit when CHAR = ASCII.EOT;.

end loop;

and the consuming task may contain the statements

loop
BUFFER. READ (CHAR) ;

consume the character CHAR

exit when CHAR = ASCII.EOT;

end loop;

The buffering task contains an internal pool of characters processed in a
round-robin fashion. The pool has two indices, an IN_INDEX denoting the
space for the next input character and an OUT_INDEX denoting the space
for the next output character.

task BUFFER is
entry READ (C

out CHARACTER) ;

entry WRITE(C : in
end;

CHARACTER) ;

task body BUFFER is
POOLSIZE : constant INTEGER := 100;
POOL
> array(1 .. POOLSIZE) of CHARACTER;

COUNT

ININDEX,

: INTEGER range 0 .. POOLSIZE := 0;

OUT_INDEX

INTEGER range 1

begin
loop
select
when COUNT < POOLSIZE =>
accept WRITE(C : in CHARACTER)
POOL(ININDEX)
end;

POOLSIZE

:= 1;

:= C;

ININDEX := ININDEX mod POOLSIZE + 1;

COUNT

:= COUNT + 1;

or when COUNT > 0 =>

accept READ(C : out CHARACTER)

C
end;

OUTINDEX

COUNT

:= POOL (OUT_INDEX) ;
:= OUTINDEX mod POOLSIZE

= COUNT - 1;

terminate;

end select;
end loop;
end BUFFER;

9-31

Example of Tasking

9.12

9.12a Task Entries and VMS Asynchronous System Traps
An asynchronous system trap (AST) is a call made by the VMSoperating
system in response to certain events detected or caused by the operating
system. In general, an AST occurs upon successful completion of a requested
system service, if the appropriate parameters have been specified as part of
the system service call. ASTs can be handled in VAX Ada through use of the
pragma AST_ENTRY and the AST_ENTRYattribute.
VMSsystem services that deliver ASTs can be called in VAX Ada with the
subprograms provided in the VAX Ada package STARLET. (The package
TASKING_SERVICESalso provides subprogramsfor calling those system
services that generate ASTs, but no AST handler can be provided by the
Ada program calling these operations.) For information on which system
services provide an AST option, and for a detailed description of ASTs, see
the Introduction to VMS System Routines. For information on using AST
system services in an Ada program, see the VAX Ada Run-Time Reference
Manual.
The pragma AST_ENTRYidentifies an Ada task entry as one that can
subsequently be called to handle an AST. This pragma must be used in

combination with the AST_ENTRYattribute, and is allowed only in the

same task type specification (or single task) as the entry to whichit applies.
The form of this pragmais as follows:
pragma ASTENTRY

(entrysimplename);

The entry simple name must denote a unique entry declared with either
zero or one formal parameter; it may not denote an entry family or member
of an entry family. At most one such pragma maybegiven for any one entry.
Whenthe AST occurs, an entry call is queued to the given entry and the
AST is dismissed. Task execution then proceeds according to normal Ada
rules; in particular, the rendezvous that results from the AST does not
execute “at AST level.”
|
If the entry has a formal parameter, the parameter must be ofa discrete,

address, or access type, and the parameter must be of mode in. When the

AST occurs and the entry is called, the formal parameter receives the value
of the astprm parameter provided by the system service.

9.12a

Task Entries and VMS Asynchronous System Traps

9-32

To connect VMS ASTs with Ada task entries, VAX Ada provides the following
attribute, where E is the nameofa single entry of a task:
E’ AST_ENTRY

Yields a value of the predefined type AST_HANDLER
(declared in the predefined package SYSTEM)that
enables the given entry, E, to be called when an AST

occurs. If the name to which the attribute applies
has not been specified with the pragma AST_ENTRY,
this attribute returns the value SYSTEM.NO_AST_
HANDLERand no ASToccurs. If the entry is for a
task that is not callable (T’ CALLABLEis false), the

exception PROGRAM_ERRORis raised. If an AST
occurs for an entry of a task that is terminated, the

program is erroneous.

KE’ AST_ENTRYis typically used and generally only useful as an actual
parameter corresponding to the astadr formal parameter of a VMS system
service that provides an AST option.
Example:
with TEXTI0; use TEXTIO;
with STARLET; use STARLET;

with CONDITIONHANDLING; use CONDITIONHANDLING;
procedure ASTEXAMPLE is

RETURNSTATUS: CONDVALUETYPE;
IOCHANNEL:
CHANNELTYPE;

FUNCTIONCODE: FUNCTIONCODETYPE;

task ASTHANDLER is
entry RECEIVEAST (ASTPRM: in INTEGER) ;
pragma ASTENTRY (RECEIVEAST);
end ASTHANDLER;
task body ASTHANDLER is

begin
loop
select

accept RECEIVEAST(ASTPRM:

in INTEGER)

if ASTPRM = 3 then
PUTLINE("Received the expected AST parameter") ;

end if;

end;

terminate;
end select;
end loop;

end ASTHANDLER;

9-33

Task Entries and VMS Asynchronous System Traps

9.12a

begin

-- Code to initialize the IOCHANNEL and FUNCTION_CODE

-- variables

-- Call the VMS SYSSQIO system service using the
-- VAX Ada package STARLET interface
> RETURNSTATUS,
IOCHANNEL,
FUNCTIONCODE,
ASTHANDLER.RECEIVEAST’ASTENTRY,
3);

let Ww tou
V V V V

STARLET .QIO (STATUS
CHAN
FUNC
ASTADR
ASTPRM
end ASTEXAMPLE;

Note:

Because it depends on the VAX Ada defined type AST_HANDLER,the
AST_ENTRYattribute can only be used in a compilation unit to which the
predefined package SYSTEM applies.
References: access type 3.8, actual parameter 6.4 6.4.1, address type 13.7 13.7a.1,

allow 1.6, attribute 4.1.4, callable (predefined attribute) 9.9, discrete type 3.5, entry
9.5, entry call 9.5 9.7.2 9.7.3, entry family 9.5, entry name 9.5, erroneous 1.6, formal
parameter 6.1 6.2, import pragma 13.9a, mode in 6.2, package system 13.7, pragma
import_valued_procedure 13.9a.1.1, pragma interface 13.9, procedure 6, program_
error exception 11.1, rendezvous 9.5, subprogram 6, system.ast_handler 13.7a.4,
system.no_ast_handler 13.7a.4, task specification 9.1, task type 9.2

9.12a

Task Entries and VMS Asynchronous System Traps

9-34

Chapter 10

Program Structure and Compilation Issues
The overall structure of programs andthefacilities for separate compilation
are described in this chapter. A program is a collection of one or more
compilation units submitted to a compiler in one or more compilations.
Each compilation unit specifies the separate compilation of a construct
which can be a subprogram declaration or body, a package declaration or
body, a generic declaration or body, or a generic instantiation. Alternatively
this construct can be a subunit, in which case it includes the body of a
subprogram, package, task unit, or generic unit declared within another
compilation unit.
References: compilation 10.1, compilation unit 10.1, generic body 12.2, generic
declaration 12.1, generic instantiation 12.3, package body 7.1, package declaration
7.1, subprogram body 6.3, subprogram declaration 6.1, subunit 10.2, task body 9.1,
task unit 9

10.1

Compilation Units—Library Units
The text of a program can be submitted to the compiler in one or more
compilations. Each compilation is a succession of compilation units.
compilation ::= {compilationunit}

subprogram_body

secondaryunit ::= libraryunitbody | subunit
libraryunitbody ::= subprogram_body

| package_body

Compilation Units—Library Units

10.1

The compilation units of a program are said to belong to a program

library. A compilation unit defines either a library unit or a secondary

unit. A secondary unit is either the separately compiled proper body of a

library unit, or a subunit of another compilation unit. The designator of a
separately compiled subprogram (whethera library unit or a subunit) must
be an identifier. Within a program library the simple namesofall library
units must be distinct identifiers./
4

The effect of compiling a library unit is to define (or redefine) this unit as

one that belongs to the program library. For the visibility rules, each library

unit acts as a declaration that occurs immediately within the package
STANDARD.
5

The effect of compiling a secondary unit is to define the body of a library

unit, or in the case of a subunit, to define the proper body of a program unit
that is declared within another compilation unit.
A subprogram body given in a compilation unit is interpreted as a secondary

unit if the program library already contains a library unit that is a
subprogram with the same name; it is otherwise interpreted both as a
library unit and as the corresponding library unit body (that is, as a
secondary unit).”

The compilation units of a compilation are compiled in the given order. A
pragma that applies to the whole of a compilation must appear before the
first compilation unit of that compilation.

A subprogram that is a library unit can be used as a main programin the

usual sense. Each main program acts as if called by some environment
task; the means by which this execution is initiated are not prescribed
by the language definition. An implementation may imposecertain

requirements on the parameters and on theresult, if any, of a main program

(these requirements must be stated in Appendix F). In any case, every

implementation is required to allow, at least, main programs that are

parameterless procedures, and every main program must be a subprogram

that is a library unit.

VAX Ada permits a library unit to be used as a main program under the
following conditions:

Ifitis a procedure with no formal parameters. In this case, the status
returned to the VMSenvironment upon normal completion of the
procedure is the value 1.

1 See also Appendix G, AI-00418.
2 See also Appendix G, AI-00199, AI-00225, and AI-00266.
10.1.

Compilation Units—Library Units

10-2

Ifit is a function with no formal parameters whose returned valueis of a
discrete type. In this case, the status returned to the VMS environment
upon normal completion of the function is the function value.

Ifit is a procedure declared with the pragma EXPORT_VALUED_
PROCEDURE,andit has one formal out parameterthat is of a discrete
type. In this case, the status returned to the VMS environment upon
normal completion of the procedure is the value of the first (and only)
parameter.

Note that when a main function or a main procedure declared with the
pragma EXPORT_VALUED_PROCEDUREreturnsa discrete value whose
size is less than 32 bits, the value is zero- or sign-extended as appropriate.
Notes:
9

A simple program mayconsist of a single compilation unit. A compilation
need not have any compilation units; for example, its text can consist of
pragmas.

The designator of a library function cannot be an operator symbol, but a

renaming declaration is allowed to renamea library function as an operator.

Two library subprograms must have distinct simple names and hence

cannot overload each other. However, renaming declarations are allowed

to define overloaded names for such subprograms, and a locally declared

subprogram is allowed to overload a library subprogram. The expanded

name STANDARD.L can be used for a library unit L (unless the name
STANDARDis hidden) since library units act as declarations that occur
immediately within the package STANDARD.
11

References: allow 1.6, context clause 10.1.1, declaration 3.1, designator 6.1,

environment 10.4, generic declaration 12.1, generic instantiation 12.3, hiding 8.3,

identifier 2.3, library unit 10.5, local declaration 8.1, must 1.6, name 4.1, occur

immediately within 8.1, operator 4.5, operator symbol 6.1, overloading 6.6 8.7,
package body 7.1, package declaration 7.1, parameter of a subprogram 6.2, pragma
2.8, procedure 6.1, program unit 6, proper body 3.9, renaming declaration 8.5, simple
name 4.1, standard package 8.6, subprogram 6, subprogram body 6.3, subprogram
declaration 6.1, subunit 10.2, task 9, visibility 8.3

discrete type 3.5, formal parameter 6.1, function 6.5, pragma export_valued_
procedure 13.9a.1.4

10-3

Compilation Units—Library Units

10.1

10.1.1

Context Clauses—With Clauses
1

A context clause is used to specify the library units whose names are needed
within a compilation unit.

contextclause ::= {withclause {useclause} }

withclause ::= with unit_simplename {, unit_simplename};

The names that appear in a context clause must be the simple names of
library units. The simple nameof any library unit is allowed within a with

clause. The only names allowed in a use clause of a context clause are the
simple namesof library packages mentioned by previous with clauses of the

context clause. A simple name declared by a renaming declaration is not
allowed in a context clause.

The with clauses and use clauses of the context clause of a library unit
apply to this library unit and also to the secondary unit that defines the
corresponding body (whether such a clause is repeated or not for this
unit). Similarly, the with clauses and use clauses of the context clause of a
compilation unit apply to this unit and also to its subunits, if any.°
If a library unit is named by a with clause that applies to a compilation unit,

then this library unit is directly visible within the compilation unit, except

where hidden; the library unit is visible as if declared immediately within
the package STANDARD(see 8.6).

Dependences among compilation units are defined by with clauses; that
is, a compilation unit that mentions other library units in its with clauses
depends on those library units. These dependences between units are taken
into account for the determination of the allowed order of compilation (and
recompilation) of compilation units, as explained in section 10.3, and for the
determination of the allowed order of elaboration of compilation units, as
explained in section 10.5.
Notes:

A library unit named by a with clause of a compilation unit is visible (except
where hidden) within the compilation unit and hence can be used as a
corresponding program unit. Thus within the compilation unit, the name
of a library package can be given in use clauses and can be used to form
expanded names; a library subprogram can be called; and instances of a
library generic unit can be declared.

3 See also Appendix G, AI-00226.
10.1.1.

Context Clauses—With Clauses

10-4

The rules given for with clauses are such that the sameeffect is obtained

whether the nameof a library unit is mentioned once or more than once by

the applicable with clauses, or even within a given with clause.
Example 1: A main program:

The following is an example of a main program consisting of a single compi-

lation unit: a procedure for printing the real roots of a quadratic equation.
The predefined package TEXT_IO and a user-defined package REAL_
OPERATIONS(containing the definition of the type REAL and of the packages REAL_IO and REAL_FUNCTIONS)are assumedto be already present
in the program library. Such packages may be used by other main programs.
with TEXTIO,

REALOPERATIONS;

procedure QUADRATICEQUATION is
A,

use REALIO,

begin

REAL;

use REALOPERATIONS;

achieves direct visibility of

GET and PUT for REAL

TEXTIO,

---

achieves direct visibility of
PUT for strings and of NEWLINE

REALFUNCTIONS;

achieves direct visibility of SQRT

GET (A); GET(B); GET(C);
D := B**2 - 4.0*A*C;

if D < 0.0 then
PUT ("Imaginary Roots.");

else
PUT ("Real Roots
PUT((-B

Xl = ");

2.0*A));
SORT(D))/(
)

PUT("

");

PUT((-B + SQRT(D))/(2.0*A));

end if;

NEWLINE;
end QUADRATICEQUATION;

Notes on the example:
The with clauses of a compilation unit need only mention the namesof those
library subprograms and packages whosevisibility is actually necessary
within the unit. They need not (and should not) mention other library units

that are used in turn by some of the units namedin the with clauses, unless
these other library units are also used directly by the current compilation
unit. For example, the body of the package REAL_OPERATIONS may need
elementary operations provided by other packages. The latter packages
should not be named by the with clause of QUADRATIC_EQUATIONsince
these elementary operations are not directly called within its body.

10-5

Context Clauses—With Clauses

10.1.1

References: allow 1.6, compilation unit 10.1, direct visibility 8.3, elaboration 3.9,

generic body 12.2, generic unit 12.1, hiding 8.3, instance 12.3, library unit 10.1,
main program 10.1, must 1.6, name 4.1, package 7, package body 7.1, package

declaration 7.1, procedure 6.1, program unit 6, secondary unit 10.1, simple name
4.1, standard predefined package 8.6, subprogram body 6.3, subprogram declaration
6.1, subunit 10.2, type 3.3, use clause 8.4, visibility 8.3

10.1.2

Examples of Compilation Units
1

A compilation unit can be split into a numberof compilation units. For
example, consider the following program.

procedure PROCESSOR is
SMALL : constant := 20;
TOTAL : INTEGER
:= 0;
package STOCK is
LIMIT
TABLE

:
:

constant
array (1

:= 1000;
.. LIMIT)

procedure RESTART;

of INTEGER;

end STOCK;

package body STOCK is
procedure RESTART is
begin
for N in 1... LIMIT loop
TABLE (N)

end loop;
end;
begin

:= N;

RESTART;
end STOCK;
procedure UPDATE(X
use STOCK;

INTEGER)

begin

TABLE (X)

TABLE(X)

SMALL;

end UPDATE;

begin
STOCK.RESTART;

-- reinitializes TABLE

end PROCESSOR;

10.1.2

The following three compilation units define a program with an effect
equivalent to the above example (the broken lines between compilation units
serve to remind the reader that these units need not be contiguoustexts).

Examples of Compilation Units

10-6

Example 2: Several compilation units:
package STOCK is
LIMIT : constant := 1000;
TABLE : array (1 .. LIMIT)
procedure RESTART;
end STOCK;

of INTEGER;

package body STOCK is
procedure RESTART is
begin
for Nin 1 .. LIMIT loop
TABLE (N)

end loop;

:= N;

end;

begin

RESTART;
end STOCK;

with STOCK;
procedure PROCESSOR is
SMALL : constant := 20;
TOTAL

INTEGER

= 0;

procedure UPDATE(X
use STOCK;

INTEGER)

begin

TABLE (X)

:= TABLE(X)

+ SMALL;

end UPDATE;

begin

STOCK.RESTART;

reinitializes TABLE

end PROCESSOR;

Note that in the latter version, the package STOCK has novisibility of outer
identifiers other than the predefined identifiers (of the package STANDARD).
In particular, STOCK does not use any identifier declared in PROCESSOR
such as SMALL or TOTAL; otherwise STOCK could not have been extracted

from PROCESSOR in the above manner. The procedure PROCESSOR, on
the other hand, depends on STOCK and mentions this package in a with
clause. This permits the inner occurrences of STOCK in the expanded name
STOCK.RESTARTandin the use clause.

These three compilation units can be submitted in one or more compilations.
For example, it is possible to submit the package specification and the
package body together and in this order in a single compilation.
Examples of Compilation Units

10.1.2

References: compilation unit 10.1, declaration 3.1, identifier 2.3, package 7,
package body 7.1, package specification 7.1, program 10, standard package 8.6, use
clause 8.4, visibility 8.3, with clause 10.1.1

10.2 Subunits of Compilation Units
1

A subunit is used for the separate compilation of the proper body of a

program unit declared within another compilation unit. This method of

splitting a program permits hierarchical program development.

bodystub ::=
subprogramspecification is separate;

| package body packagesimplename is separate;
| task body task_simplename is separate;

subunit ::=
separate

(parentunitname)

properbody

A body stub is only allowed as the body of a program unit (a subprogram, a
package, a task unit, or a generic unit) if the body stub occurs immediately
within either the specification of a library package or the declarative part of

another compilation unit.*

If the body of a program unit is a body stub, a separately compiled subunit
containing the corresponding proper body is required. In the case of a
subprogram, the subprogram specifications given in the proper body and in
the body stub must conform (see 6.3.1).
Each subunit mentions the nameof its parent unit, that is, the compilation

unit where the corresponding body stub is given. If the parent unit is a
library unit, it is called the ancestor library unit. If the parent unitis itself
a subunit, the parent unit name must be given in full as an expanded name,
starting with the simple name of the ancestor library unit. The simple
namesof all subunits that have the same ancestor library unit must be

distinct identifiers.°

Visibility within the proper body of a subunit is the visibility that would
be obtained at the place of the corresponding body stub (within the parent
unit) if the with clauses and use clauses of the subunit were appendedto
the context clause of the parent unit. If the parent unit is itself a subunit,
then the samerule is used to define thevisibility within the proper body of
the parent unit.

4 See also Appendix G, AI-00035.
5 See also Appendix G, AI-00289.

10.2

Subunits of Compilation Units

10-8

The effect of the elaboration of a body stub is to elaborate the proper body of
the subunit.
Notes:

Two subunits of different library units in the same program library need not
havedistinct identifiers. In any case, their full expanded namesaredistinct,
since the simple namesof library units are distinct and since the simple
namesof all subunits that have a given library unit as ancestor unit are also
distinct. By means of renaming declarations, overloaded subprogram names
that rename(distinct) subunits can be introduced.
A library unit that is named by the with clause of a subunit can be hidden
by a declaration (with the same identifier) given in the proper body of the
subunit. Moreover, such a library unit can even be hidden by a declaration given within a parent unit since a library unit acts as if declared in
STANDARD; this however does not affect the interpretation of the with
clauses themselves, since only namesof library units can appear in with
clauses.
10

References: compilation unit 10.1, conform 6.3.1, context clause 10.1.1, declaration
3.1, declarative part 3.9, direct visibility 8.3, elaboration 3.9, expanded name4.1.3,

generic body 12.2, generic unit 12, hidden declaration 8.3, identifier 2.3, library unit
10.1, local declaration 8.1, name 4.1, occur immediately within 8.1, overloading 8.3,

package 7, package body 7.1, package specification 7.1, program 10, program unit 6,
proper body 3.9, renaming declaration 8.5, separate compilation 10.1, simple name
4.1, subprogram 6, subprogram body 6.3, subprogram specification 6.1, task 9, task

body 9.1, task unit 9.1, use clause 8.4, visibility 8.3, with clause 10.1.1

10.2.1.

Examples of Subunits
1
2

The procedure TOPis first written as a compilation unit without subunits.
with TEXTIO;
procedure TOP is
type REAL is digits 10;
R,

REAL

:= 1.0;

package FACILITY is
PI : constant
function
F(X

procedure G(Y,

:= 3.1415926536;
: REAL) return REAL;

Z : REAL);

end FACILITY;

package body FACILITY is
-some local declarations followed by

10-9

Examples of Subunits

10.2.1

function F(X : REAL)
begin
--

return REAL is

sequence of statements of F

end F;
procedure G(Y,

REAL)

local procedures using TEXTIO

begin
--

sequence of statements of G

end G;

end FACILITY;
procedure TRANSFORM(U : in out REAL)

use FACILITY;

begin
U := F(U);

end TRANSFORM;

begin -- TOP

TRANSFORM (R) ;
FACILITY.G(R,

S);

end TOP;

The body of the package FACILITY and that of the procedure TRANSFORM
can be madeinto separate subunits of TOP. Similarly, the body of the
procedure G can be madeinto a subunit of FACILITY asfollows.

Example 3:

procedure TOP is
type REAL is digits 10;
R,

REAL

:= 1.0;

package FACILITY is
PI : constant
function
F(X

procedure G(Y,

:= 3.1415926536;
: REAL) return REAL;

: REAL);

end FACILITY;

package body FACILITY is separate;
procedure TRANSFORM(U

begin

in out REAL)

stub of FACILITY

is separate;
-stub of TRANSFORM

TOP

TRANSFORM (R) ;
FACILITY.G(R,

S);

end TOP;

10.2.1.

Examples of Subunits

10-10

separate

(TOP)

procedure TRANSFORM(U : in out REAL)

use FACILITY;

begin
U

:= F(U);

end TRANSFORM;
cee ey me me cry ee ee re men my a me ay se ew we ee ee ey ee ee

separate

(TOP)

package body FACILITY is
-~-

some local declarations

function F(X : REAL)
begin
--

followed by

return REAL is

sequence of statements of F

end F;
procedure G(Y,
end FACILITY;

: REAL)

is separate;

-- stub of G

mm ms ec em re we ws re we wee se i i ee

with TEXT I0;
separate (TOP.FACILITY)
procedure G(Y, Z : REAL)

-is

full name of FACILITY

local procedures using TEXTIO

begin
--

sequence of statements of G

end G;

In the above example TRANSFORM and FACILITY are subunits of TOP,
and G is a subunit of FACILITY. The visibility in the split version is the
sameas in the initial version except for one change: since TEXT_IO is
only used within G, the corresponding with clause is written for G instead
of for TOP. Apart from this change, the sameidentifiers are visible at
corresponding program points in the two versions. For example,all of the

following are (directly) visible within the proper body of the subunit G:
the procedure TOP, the type REAL, the variables R and S, the package
FACILITY and the contained named number PI and subprograms F and G.
References: body stub 10.2, compilation unit 10.1, identifier 2.3, local declaration
8.1, named number 3.2, package 7, package body 7.1, procedure 6, procedure body
6.3, proper body 3.9, subprogram 6, type 3.3, variable 3.2.1, visibility 8.3, with
clause 10.1.1

10-11

Examples of Subunits

10.2.1

10.3 Order of Compilation
1

The rules defining the order in which units can be compiled are direct

consequencesof the visibility rules and, in particular, of the fact that any
library unit that is mentioned by the context clause of a compilation unit is

visible in the compilation unit.

A compilation unit must be compiled after all library units named byits
context clause. A secondary unit that is a subprogram or package body must
be compiled after the corresponding library unit. Any subunit of a parent
compilation unit must be compiled after the parent compilation unit.
If any error is detected while attempting to compile a compilation unit, then
the attempted compilation is rejected and it has no effect whatsoever on the
program library; the same holds for recompilations (no compilation unit can
become obsolete because of such a recompilation).®
The order in which the compilation units of a program are compiled must be
consistent with the partial ordering defined by the aboverules.

Similar rules apply for recompilations. A compilation unit is potentially

affected by a change in any library unit named byits context clause. A

secondary unit is potentially affected by a change in the corresponding
library unit. The subunits of a parent compilation unit are potentially
affected by a change of the parent compilation unit. If a compilation unit
is successfully recompiled, the compilation units potentially affected by
this change are obsolete and must be recompiled unless they are no longer
needed. An implementation may be able to reduce the compilation costs if
it can deduce that some of the potentially affected units are not actually
affected by the change.
The subunits of a unit can be recompiled without affecting the unit itself.
Similarly, changes in a subprogram or package body do not affect other
compilation units (apart from the subunits of the body) since these compilation units only have access to the subprogram or package specification.
An implementation is only allowed to deviate from this rule for inline inclusions, for certain compiler optimizations, and for certain implementations of
generic program units, as described below.’

6 See also Appendix G, AI-00261.
7 See also Appendix G, AI-00408.
10.3.

Order of Compilation

10-12

Ifa pragma INLINEis applied to a subprogram declaration given in
a package specification, inline inclusion will only be achievedif the
package body is compiled before units calling the subprogram. In such
a case, inline inclusion creates a dependence of the calling unit on the
package body, and the compiler must recognize this dependence when
deciding on the need for recompilation. If a calling unit is compiled

before the package body, the pragma may be ignored by the compiler

for such calls (a warning that inline inclusion was not achieved may
be issued). Similar considerations apply to a separately compiled

subprogram for which an INLINE pragmaisspecified. ®

In VAX Ada, if a pragma INLINE_GENERICis applied to a generic
instantiation, either by naming the instantiation or by naming the
generic declaration from which the instantiation was derived, inline
inclusion will only be achieved if the corresponding generic body is
compiled before the instantiation. In such a case, inline inclusion
creates a dependence of the instantiation on the generic body, and the
compiler recognizes this dependence when deciding on the need for
recompilation. If an instantiation is compiled before the generic body,
the pragma will be ignored by the compiler for such instantiations (a
diagnostic message that inline inclusion was not achieved will be issued).

For optimization purposes, an implementation may compile several units
of a given compilation in a way that creates further dependences among
these compilation units. The compiler must then take these dependences
into account when deciding on the need for recompilations.

An implementation may require that a generic declaration and the
corresponding proper body be part of the same compilation, whether
the generic unit is itself separately compiled or is local to another

compilation unit. An implementation may also require that subunits of
a generic unit be part of the same compilation.?
VAX Ada does not require that a generic declaration and the corresponding proper body be part of the same compilation, nor does VAX
Ada require that the subunits of a generic unit be part of the same
compilation. The instantiation of a generic declaration before the corresponding bodyis available results in an incomplete compilation. See
Developing Ada Programs on VMS Systems for information on compiling
and recompiling VAX Ada compilation units.

8 See also Appendix G, AI-00200.
9 See also Appendix G, AI-00257.

10-13

Order of Compilation

10.3

Examples of Compilation Order:

(a)

In example 1 (see 10.1.1): The procedure QUADRATIC_EQUATION
must be compiled after the library packages TEXT_IO and REAL_
OPERATIONSsince they appearin its with clause.

(b)

In example 2 (see 10.1.2): The package body STOCK must be compiled

(c)

after the corresponding package specification.

In example 2 (see 10.1.2): The specification of the package STOCK

must be compiled before the procedure PROCESSOR. Onthe other

hand, the procedure PROCESSORcan be compiled either before or

after the package body STOCK.

(d)

In example 3 (see 10.2.1): The procedure G must be compiled after the
package TEXT_IO since this package is named by the with clause
of G. On the other hand, TEXT_IO can be compiled either before or

after TOP.
15

(e)

In example 3 (see 10.2.1): The subunits TRANSFORM and FACILITY

must be compiled after the main program TOP. Similarly, the subunit
G must be compiled after its parent unit FACILITY.

Notes:

i¢

For library packages,it follows from the recompilation rules that a package

body is made obsolete by the recompilation of the corresponding specifica-

tion. If the new package specification is such that a package body is not

required (that is, if the package specification does not contain the declara-

tion of a program unit), then the recompilation of a body for this packageis
not required. In any case, the obsolete package body must not be used and

can therefore be deleted from the program library.

References: compilation 10.1, compilation unit 10.1, context clause 10.1.1, elab-

oration 3.9, generic body 12.2, generic declaration 12.1, generic unit 12, library
unit 10.1, local declaration 8.1, name 4.1, package 7, package body 7.1, package
specification 7.1, parent unit 10.2, pragma inline 6.3.2, procedure 6.1, procedure
body 6.3, proper body 3.9, secondary unit 10.1, subprogram body 6.3, subprogram
declaration 6.1, subprogram specification 6.1, subunit 10.2, type 3.3, variable 3.2.1,
visibility 8.3, with clause 10.1.1
generic body 12.2, instantiation 12.3

10.3

Order of Compilation

10-14

10.4 The Program Library
1

Compilers are required to enforce the language rules in the same manner

for a program consisting of several compilation units (and subunits) as for
a program submitted as a single compilation. Consequently, a library file
containing information on the compilation units of the program library must

be maintained by the compiler or compiling environment. This information
may include symbol tables and other information pertaining to the order of

previous compilations.

A normal submission to the compiler consists of the compilation unit(s)
and thelibrary file. The latter is used for checks and is updated for each
compilation unit successfully compiled.
Notes:

A single program library is implied for the compilation units of a compilation. The possible existence of different program libraries and the means by
which they are namedare not concernsof the language definition; they are
concerns of the programming environment.

There should be commandsfor creating the program library of a given
program or of a given family of programs. These commands may permit the
reuse of units of other program libraries. Finally, there should be commands
for interrogating the status of the units of a program library. The form of
these commandsis not specified by the language definition.
VAX Ada program library management, as well as commandsfor creating
program libraries and for determining the status of the units of a program
library, is described in Developing Ada Programs on VMS Systems.
References: compilation unit 10.1, context clause 10.1.1, order of compilation 10.3,

program 10.1, program library 10.1, subunit 10.2, use clause 8.4, with clause 10.1.1

10.5

Elaboration of Library Units
Before the execution of a main program, all library units needed by the main
program are elaborated, as well as the corresponding library unit bodies, if

any. The library units needed by the main program are: those named by
with clauses applicable to the main program, to its body, and to its subunits;
those named by with clauses applicable to these library units themselves, to
the corresponding library unit bodies, and to their subunits; and so on, in a

transitive manner.19
10 See also Appendix G, AI-00158.
10-15

Elaboration of Library Units

10.5

The elaboration of these library units and of the corresponding library unit
bodies is performed in an order consistent with the partial ordering defined
by the with clauses (see 10.3). In addition, a library unit mentioned by

the context clause of a subunit must be elaborated before the body of the

ancestor library unit of the subunit]!

An order of elaboration that is consistent with this partial ordering does not
always ensure that each library unit body is elaborated before any other
compilation unit whose elaboration necessitates that the library unit body be
already elaborated. If the prior elaboration of library unit bodies is needed,
this can be requested by a pragma ELABORATE. The form of this pragma is
as follows:

pragma ELABORATE

(libraryunit_simple_name

{, library _unit_simplename});

These pragmas are only allowed immediately after the context clause of
a compilation unit (before the subsequent library unit or secondary unit).
Each argument of such a pragma must be the simple nameofa library
unit mentioned by the context clause, and this library unit must have a
library unit body. Such a pragmaspecifies that the library unit body must
be elaborated before the given compilation unit. If the given compilation
unit is a subunit, the library unit body must be elaborated before the body

of the ancestor library unit of the subunit. 12

The program is illegal if no consistent order can be found (thatis, if a
circularity exists). The elaboration of the compilation units of the program
is performed in someorder that is otherwise not defined by the language.
References: allow 1.6, argument of a pragma 2.8, compilation unit 10.1, context
clause 10.1.1, dependence between compilation units 10.3, elaboration 3.9, illegal
1.6, in some order 1.6, library unit 10.1, name 4.1, main program 10.1, pragma 2.8,

secondary unit 10.1, separate compilation 10.1, simple name 4.1, subunit 10.2, with

clause 10.1.1

10.6 Program Optimization
1

Optimization of the elaboration of declarations and the execution of

statements may be performed by compilers. In particular, a compiler may be
able to optimize a program by evaluating certain expressions, in addition to
those that are static expressions. Should one of these expressions, whether
static or not, be such that an exception would be raised by its evaluation,
then the code in that path of the program can be replaced by code to raise
11 See also Appendix G, AI-00354.
12 See also Appendix G, AI-00236, AI-00298, and AI-00355.

10.6

Program Optimization

10-16

the exception; the same holds for exceptions raised by the evaluation of
names and simple expressions. (See also section 11.6.)
A compiler may find that some statements or subprograms will never be
executed, for example, if their execution depends on a condition known to be
FALSE. The corresponding object machine code can then be omitted. This
rule permits the effect of conditional compilation within the language.
Note:

An expression whose evaluation is known to raise an exception need not
represent an error if it occurs in a statement or subprogram that is never
executed. The compiler may warn the programmerof a potential error.
References: condition 5.3, declaration 3.1, elaboration 3.9, evaluation 4.5, excep-

tion 11, expression 4.4, false boolean value 3.5.3, program 10, raising of exceptions
11.3, statement 5, static expression 4.9, subprogram 6

10-17

Program Optimization

10.6

Chapter 11

Exceptions
1

This chapter defines the facilities for dealing with errors or other exceptional
situations that arise during program execution. Such situation is called an
exception. To raise an exception is to abandon normal program execution so
as to draw attention to the fact that the corresponding situation has arisen.
Executing some actions, in response to the arising of an exception, is called
handling the exception.

An exception declaration declares a name for an exception. An exception can

be raised by a raise statement, or it can be raised by another statement or
operation that propagates the exception. When an exception arises, control
can be transferred to a user-provided exception handler at the end of a block
statement or at the end of the body of a subprogram, package, or task unit.

Note:

In VAX Ada, exceptions are implemented using the VAX Condition Handling
Facility (CHF). The VAX Ada Run-Time Reference Manual describes the
implementation of exceptions and its implications in more detail.
3

11.1

Exception Declarations
1

41-1

References: block statement 5.6, error situation 1.6, exception handler 11.2, name
4.1, package body 7.1, propagation of an exception 11.4.1 11.4.2, raise statement
11.8, subprogram body 6.3, task body 9.1

An exception declaration declares a name for an exception. The name of
an exception can only be used in raise statements, exception handlers, and
renaming declarations.
exceptiondeclaration ::= identifierlist : exception;

Exception Declarations

11.1

An exception declaration with several identifiers is equivalent to a sequence
of single exception declarations, as explained in section 3.2. Each single
exception declaration declares a namefor a different exception. In particular, if a generic unit includes an exception declaration, the exception
declarations implicitly generated by different instantiations of the generic
unit refer to distinct exceptions (but all have the same identifier). The
particular exception denoted by an exception nameis determined at compilation time and is the same regardless of how many times the exception
declaration is elaborated. Hence, if an exception declaration occurs in a
recursive subprogram, the exception name denotes the same exception for

all invocations of the recursive subprogram.

The following exceptions are predefined in the language; they are raised
when the situations described are detected.
CONSTRAINT_ERROR This exception is raised in any of the following

situations: upon an attempt to violate a range
constraint, an index constraint, or a discriminant
constraint; upon an attempt to use a record

component that does not exist for the current
discriminant values; and upon an attempt to use
a selected component, an indexed component, a

slice, or an attribute, of an object designated by an
access value, if the object does not exist because

the access value is null.

In VAX Ada, this exception is also raised by
the execution of a predefined numeric operation
that cannot deliver a correct result (within the
declared accuracy for real types). It is raised
for integer overflow, floating point overflow, and
integer and floating point division by zero. This
exception is not raised by floating point underflow
(floating point underflow is not defined as an

exception in VAX Ada); underflow can be handled

as an imported VAX condition (see 13.9a.3.1 for
information on importing VAX conditions).
6

11.1

NUMERIC_ERROR

Exception Declarations

This exception is raised by the execution of

a predefined numeric operation that cannot
deliver a correct result (within the declared
accuracy for real types); this includes the case
where an implementation uses a predefined
numeric operation for the execution, evaluation,
or elaboration of some construct. The rules
given in section 4.5.7 define the cases in which
11-2

an implementation is not required to raise this

exception when such an error situation arises; see
also section 11.6. /

VAX Ada raises NUMERIC_ERRORonly when
it is explicitly raised with a raise statement.

Whereverthis standard requires that NUMERIC_
ERROR beraised, CONSTRAINT_ERRORwill be
raised instead.”

PROGRAM_ERROR

This exception is raised upon an attemptto

call a subprogram, to activate a task, or to

elaborate a generic instantiation, if the body

of the corresponding unit has not yet been
elaborated. This exception is also raised if the end
of a function is reached (see 6.5); or during the
execution of a selective wait that has noelse part,
if this execution determines thatall alternatives
are closed (see 9.7.1). Finally, depending on the
implementation, this exception may be raised upon
an attempt to execute an action that is erroneous,
and for incorrect order dependences(see 1.6).
In VAX Ada, this exception is raised for some

erroneoussituations; it is not raised for incorrect

order dependences.
8

STORAGE_ERROR

This exception is raised in any of the following
situations: when the dynamic storage allocated
to a task is exceeded; during the evaluation of an
allocator, if the space available for the collection
of allocated objects is exhausted; or during the
elaboration of a declarative item, or during the
execution of a subprogram call, if storage is not
sufficient.

TASKINGERROR

This exception 1s raised when exceptions arise

during intertask communication (see 9 and 11.5).

In addition to these exceptions, VAX Ada provides two packagesof inputoutput exceptions: IO_EXCEPTIONS(predefined by the language), and

AUX_IO_EXCEPTIONS(defined for use with the VAX Ada relative and

indexed input-output packages). The input-output exceptions are described
in 14.4.

1 See also Appendix G, AI-00311, AI-00312, and AI-00387.
2 See also Appendix G, AI-00387.
11-3

Exception Declarations

11.1

VAX Ada also defines the exception NON_ADA_ERROR (in package
SYSTEM); see sections 11.2 and 13.7.5.
Note:

The situations described above can arise without raising the corresponding
exceptions, if the pragma SUPPRESShas been used to give permission to

omit the corresponding checks(see 11.7).

In addition to the pragma SUPPRESS, VAX Ada provides the pragma
SUPPRESS_ALL(see 11.7).
Examples of user-defined exception declarations:
SINGULAR : exception;
ERROR
: exception;
OVERFLOW,

UNDERFLOW

exception;

References: access value 3.8, collection 3.8, declaration 3.1, exception 11, exception handler 11.2, generic body 12.2, generic instantiation 12.3, generic unit 12,
identifier 2.3, implicit declaration 12.3, instantiation 12.3, name 4.1, object 3.2,
raise statement 11.3, real type 3.5.6, record component 3.7, return statement 5.8,
subprogram 6, subprogram body6.3, task 9, task body 9.1
aux_io_exceptions package 14.4, erroneous 1.6, imported VAX condition 13.9a.3.1,
indexed input-output 14.2a 14.2a.1 14.2a.4 14.2b.9, indexed_io package 14.2a.5,
indexed_mixed_io package 14.2b.10, io_exceptions package 14.4, non_ada_error
exception 13.7a, package system 13.7, relative input-output 14.2a 14.2a.1 14.2a.2
14.2b.7, relative_io package 14.2a.3, relative_mixed_io package 14.2b.8

Constraint_error exception contexts: aggregate 4.3.1 4.3.2, allocator 4.8,

assignment statement 5.2 5.2.1, constraint 3.3.2, discrete type attribute 3.5.5,

discriminant constraint 3.7.2, elaboration of a generic formal parameter 12.3.1
12.3.2 12.3.4 12.3.5, entry index 9.5, exponentiating operator 4.5.6, index constraint
3.6.1, indexed component 4.1.1, logical operator 4.5.1, null access value 3.8, object
declaration 3.2.1, parameter association 6.4.1, qualified expression4.7, range

constraint 3.5, selected component 4.1.3, slice 4.1.2, subtype indication 3.3.2, type

conversion 4.6
14

Numeric_error exception contexts: discrete type attribute 3.5.5, implicit
conversion 3.5.4 3.5.6 4.6, numeric operation 3.5.5 3.5.8 3.5.10, operator of a
numeric type 4.5 4.5.7
Program_error exception contexts: collection 3.8, elaboration 3.9, elaboration
check 3.9 7.3 9.3 12.2, erroneous 1.6, incorrect order dependence 1.6, leaving a
function 6.5, selective wait 9.7.1

Storage_error exception contexts: allocator 4.8

Tasking_error exception contexts: abort statement 9.10, entry call 9.5 9.7.2
9.7.3, exceptions during task communication 11.5, task activation 9.3

11.1.

Exception Declarations

11-4

11.2 Exception Handlers
1

The response to one or more exceptionsis specified by an exception handler.
exceptionhandler ::=

when exceptionchoice

sequenceofstatements

exceptionchoice}

exceptionchoice ::= exceptionname

others

An exception handler occurs in a construct that is either a block statement
or the body of a subprogram, package, task unit, or generic unit. Such a
construct will be called a frame in this chapter. In each case the syntax of a
frame that has exception handlers includes the following part:
begin
sequenceofstatements
exception
exceptionhandler
{exceptionhandler}
end

The exceptions denoted by the exception names given as exception choices
of a frame mustall be distinct. The exception choice othersis only allowed
for the last exception handler of a frame andasits only exception choice;
it stands for all exceptions not listed in previous handlers of the frame,
including exceptions whose namesare not visible at the place of the
exception handler.

The exception handlers of a frame handle exceptions that are raised by

the execution of the sequence of statements of the frame. The exceptions

handled by a given exception handler are those named by the corresponding
exception choices.

When non-Ada code is imported in an Ada program (see 13.9a), any VAX
conditions that may be signaled can be handled by an others choice in
the Ada frame that calls the non-Ada routines. Alternatively, the VAX
Ada predefined exception SYSTEM.NON_ADA_ERRORcanbe used as an
exception choice (see 13.7a.5). The handling of a VAX condition from an Ada
program, however, means that once control is passed to the Ada exception
handler, it cannot return to the point where the condition was signaled (see
11.4). See the VAX Ada Run-Time Reference Manual for more information
on handling VAX conditions from Ada programs.

11-5

Exception Handlers

11.2

Example:
begin
--

sequence of statements

exception
when SINGULAR | NUMERICERROR =>
PUT(" MATRIX IS SINGULAR ");
when others =>
PUT(" FATAL ERROR ");

end;

raise ERROR;

Note:

The same kinds of statement are allowed in the sequence of statements of
each exception handler as are allowed in the sequence of statements of the
frame. For example, a return statementis allowed in a handler within a
function body.
References: block statement 5.6, declarative part 3.9, exception 11, exception

handling 11.4, function body 6.3, generic body 12.2, generic unit 12.1, name 4.1,

package body 7.1, raise statement 11.3, return statement 5.8, sequence of statements
5.1, statement 5, subprogram body 6.3, task body 9.1, task unit 9 9.1, visibility 8.3

import pragma 13.9a, non_ada_error exception 13.7a, package system 13.7

11.3

Raise Statements
1

A raise statement raises an exception.
raisestatement ::= raise [exception_name];

For the execution of a raise statement with an exception name, the named
exception is raised. A raise statement without an exception nameis
only allowed within an exception handler (but not within the sequence of
statements of a subprogram, package, task unit, or generic unit, enclosed
by the handler); it raises again the exception that caused transfer to the
innermost enclosing handler.

Examples:
raise SINGULAR;
raise NUMERICERROR;
raise;

---

explicitly raising a predefined
exception

only within an exception handler

References: exception 11, generic unit 12, name 4.1, package 7, sequence of
statements 5.1, subprogram 6, task unit 9

11.3

Raise Statements

11-6

11.4

Exception Handling
1

When an exception is raised, normal program execution is abandoned
and control is transferred to an exception handler. The selection of this
handler depends on whether the exception is raised during the execution of
statements or during the elaboration of declarations.@
Note:

By providing the pragma IMPORT_EXCEPTION(see 13.9a.3.1), VAX Ada
allows Ada exception handlers to handle any VMSconditions raised in Ada
code or in imported (non-Ada) code. VAX Adaalso provides the package
CONDITION_HANDLINGto allow additional control over VAX condition

handling. Similarly, by providing the pragma EXPORT_EXCEPTION(see
—13.9a.3.2), VAX Ada allows handlers written in other languages to handle
exported Ada exceptions. See the VAX Ada Run-Time Reference Manualfor
implementation details and for information on using these pragmas and
packages.
2

11.4.1

References: declaration 3.1, elaboration 3.1 3.9, exception 11, exception handler
11.2, raising of exceptions 11.3, statement 5

Exceptions Raised During the Execution of Statements
1

The handling of an exception raised by the execution of a sequence of
statements depends on whether the innermost frame or accept statement
that encloses the sequence of statements is a frame or an accept statement.
The case where an accept statement is innermost is described in section
11.5. The case where a frame is innermost is presented here.

Different actions take place, depending on whetheror not this frame has
a handler for the exception, and on whether the exception is raised in the
sequence of statements of the frameor in that of an exception handler.

If an exception is raised in the sequence of statements of a frame that has
a handler for the exception, execution of the sequence of statements of the
frame is abandoned andcontrol is transferred to the exception handler.
The execution of the sequence of statements of the handler completes the
execution of the frame(or its elaboration if the frame is a package body).4

3 See also Appendix G, AI-00446.
4 See also Appendix G, AI-00455.
11-7

Exceptions Raised During the Execution of Statements

11.4.1

If an exception is raised in the sequence of statements of a frame that

does not have a handler for the exception, execution of this sequence of
statements is abandoned. The next action depends on the nature of the

frame: |
5

(a)

For a subprogram body, the same exception is raised again at the point
of call of the subprogram, unless the subprogram is the main program

itself, in which case execution of the main program is abandoned.
6

(b)

(c)

For a block statement, the same exception is raised again immediately

after the block statement(that is, within the innermost enclosing frame
or accept statement).
For a package body that is a declarative item, the same exception
is raised again immediately after this declarative item (within the
enclosing declarative part). If the package body is that of a subunit,

the exception is raised again at the place of the corresponding body
stub. If the package is a library unit, execution of the main program is
abandoned.
8

(d)

For a task body, the task becomes completed.

An exception that is raised again (as in the above cases (a), (b), and
(c)) is said to be propagated, either by the execution of the subprogram,
the execution of the block statement, or the elaboration of the package
body. No propagation takes place in the case of a task body. If the frame
is a subprogram or a block statement and if it has dependent tasks, the
propagation of an exception takes place only after termination of the
dependent tasks.

Finally, if an exception is raised in the sequence of statements of an

exception handler, execution of this sequence of statements is abandoned.

Subsequent actions (including propagation, if any) are as in the cases (a) to

(d) above, depending on the nature of the frame.
11

Example:
function FACTORIAL

POSITIVE)

return FLOAT(N)

FACTORIAL (N-1);

begin

return FLOAT is

if N = 1 then
return 1.0;
else
end if;

exception

when NUMERICERROR =>

return FLOAT’ SAFELARGE;

end FACTORIAL;

11.4.1.

Exceptions Raised During. the Execution of Statements

11-8

If the multiplication raises NUMERIC_ERROR, then FLOAT’ SAFE_LARGE
is returned by the handler. This value will cause further NUMERIC_

ERRORexceptions to be raised by the evaluationof the expression in each
of the remaining invocations of the function, so that for large values of N the

function will ultimately return the value FLOAT’ SAFE_LARGE.

Example:
procedure P is
ERROR : exception;
procedure R;

procedure ©Q is
begin
R;
wee

error situation

when ERROR =>

handler E2

error situation

(3)

error situation

(1)

handler El

exception

(2)

end 0Q;

procedure R is
begin
a
end R;

begin
wae
QO;

exception
when ERROR =>
end P;

The following situations can arise:
(1)

(2)

(3)

Ifthe exception ERRORis raised in the sequence of statements of the
outer procedure P, the handler E1 provided within P is used to complete
the execution ofP.
Ifthe exception ERRORis raised in the sequence of statementsof Q,

the handler E2 provided within Q is used to complete the execution
of Q. Control will be returned to the point of call of Q upon completion
of the handler.
Ifthe exception ERRORis raised in the body of R, called by Q, the

execution of R is abandoned and the same exception is raised in the

body of Q. The handler E2 is then used to complete the execution of Q,
as in situation (2).

11-9

Exceptions Raised During the Execution of Statements

11.4.1

Note that in the third situation, the exception raised in R results in (indirectly) transferring control to a handler that is part of Q and hence not
enclosed by R. Note also that if a handler were provided within R for the

exception choice others, situation (3) would cause execution of this handler,

rather than direct termination of R.

Lastly, if ERROR had been declared in R, rather than in P, the handlers E1

and E2 could not provide an explicit handler for ERRORsincethis identifier

would not be visible within the bodies of P and Q. In situation (3), the

exception could however be handled in Q by providing a handler for the
exception choice others.

Notes:
20

The language does not define what happens when the execution of the main
program is abandonedafter an unhandled exception.

The predefined exceptions are those that can be propagated by the basic
operations and the predefined operators.

The case of a frame that is a generic unit is already covered by the rules
for subprogram and package bodies, since the sequence of statements of
such a frame is not executed but is the template for the corresponding
sequences of statements of the subprograms or packages obtained by generic
instantiation.
References: accept statement 9.5, basic operation 3.3.3, block statement 5.6, body
stub 10.2, completion 9.4, declarative item 3.9, declarative part 3.9, dependent task
9.4, elaboration 3.1 3.9, exception 11, exception handler 11.2, frame 11.2, generic

instantiation 12.3, generic unit 12, library unit 10.1, main program 10.1, numeric_
error exception 11.1, package 7, package body 7.1, predefined operator 4.5, procedure
6.1, sequence of statements 5.1, statement 5, subprogram 6, subprogram body6.3,
subprogram call 6.4, subunit 10.2, task 9, task body 9.1

11.4.2

Exceptions Raised During the Elaboration of Declarations
1

If an exception is raised during the elaboration of the declarative part of a

given frame, this elaboration is abandoned. The next action depends on the
nature of the frame:

11.4.2

(a)

For a subprogram body, the same exception is raised again at the point
of call of the subprogram, unless the subprogram is the main program
itself, in which case execution of the main program is abandoned.

(b)

For a block statement, the same exception is raised again immediately
after the block statement.

Exceptions Raised During the Elaboration of Declarations

11-10

(c)

For a package body that is a declarative item, the same exception is

raised again immediately after this declarative item, in the enclosing
declarative part. If the package body is that of a subunit, the exception

is raised again at the place of the corresponding body stub. If the
packageis a library unit, execution of the main program is abandoned.

(d)

For a task body, the task becomes completed, and the exception
TASKING_ERRORis raised at the point of activation of the task, as
explained in section 9.3.

Similarly, if an exception is raised during the elaboration of either a package

declaration or a task declaration, this elaboration is abandoned; the next

action depends on the nature of the declaration.
(e)

For a package declaration or a task declaration, that is a declarative

item, the exception is raised again immediately after the declarative

item in the enclosing declarative part or package specification. For the
declaration of a library package, the execution of the main program is
abandoned.

An exception that is raised again (as in the above cases (a), (b), (c) and
(e)) is said to be propagated, either by the execution of the subprogram
or block statement, or by the elaboration of the package declaration, task
declaration or package body.
Example of an exception in the declarative part of a block statement

(case (b)):

procedure P is
begin
declare
:
N : INTEGER := F;
begin

the function F may raise ERROR

handler El

handler E2

exception
when ERROR =>
end;

exception
when ERROR =>
end P;

---

11-11

if the exception ERROR is raised in the declaration of N,
it is handled by E2

Exceptions Raised During the Elaboration of Declarations

11.4.2

References: activation 9.3, block statement 5.6, body stub 10.2, completed task

9.4, declarative item 3.9, declarative part 3.9, elaboration 3.1 3.9, exception 11,

frame 11.2, library unit 10.1, main program 10.1, package body 7.1, package
declaration 7.1, package specification 7.1, subprogram 6, subprogram body 6.3,
subprogram call 6.4, subunit 10.2, task 9, task body 9.1, task declaration 9.1,
tasking_error exception 11.1

11.5 Exceptions Raised During Task Communication
1

An exception can be propagated to a task communicating, or attempting to

communicate, with another task. An exception can also be propagated to a
calling task if the exception is raised during a rendezvous.

When task calls an entry of another task, the exception TASKING_

ERRORis raised in the calling task, at the place of the call, if the called

task is completed before accepting the entrycall or is already completed at
the time of thecall.
A rendezvous can be completed abnormally in two cases:
(a)

When an exception is raised within an accept statement, but not

handled within an inner frame. In this case, the execution of the

accept statement is abandoned and the same exception is raised again
immediately after the accept statement within the called task; the

exception is also propagated to the calling task at the point of the entry

call.
(b)

When the task containing the accept statement is completed abnormally as the result of an abort statement. In this case, the exception
TASKING_ERRORis raised in the calling task at the point of the entry
call.

On the other hand,if a task issuing an entry call becomes abnormal(as the
result of an abort statement) no exception is raised in the called task. If the
rendezvous has not yet started, the entry call is cancelled. If the rendezvous
is in progress, it completes normally, and the called task is unaffected.

References: abnormal task 9.10, abort statement 9.10, accept statement 9.5,
completed task 9.4, entry call 9.5, exception 11, frame 11.2, rendezvous 9.5, task 9,
task termination 9.4, tasking_error exception 11.1

11.5

Exceptions Raised During Task Communication

11-12

11.6 Exceptions and Optimization
1

The purpose of this section is to specify the conditions under which an
implementation is allowed to perform certain actions either earlier or later
than specified by other rules of the language.
In general, when the language rules specify an order for certain actions

(the canonical order), an implementation may only use an alternative order
if it can guarantee that the effect of the program is not changed by the

reordering. In particular, no exception should arise for the execution of the
reordered program if none arises for the execution of the program in the
canonical order. When, on the other hand, the order of certain actions is not

defined by the language, any order can be used by the implementation. (For
example, the arguments of a predefined operator can be evaluated in any
order since the rules given in section 4.5 do not require a specific order of
evaluation.)

Additional freedom is left to an implementation for reordering actions

involving predefined operations that are either predefined operators or basic
operations other than assignments. This freedom isleft, as defined below,

even in the case where the execution of these predefined operations may
propagate a (predefined) exception:

(a)

For the purpose of establishing whether the sameeffect is obtained by
the execution of certain actions in the canonical and in an alternative
order, it can be assumed that none of the predefined operations invoked
by these actions propagates a (predefined) exception, provided that
the two following requirements are met by the alternative order:
first, an operation must not be invokedin the alternative orderif it
is not invoked in the canonical order; second, for each operation, the
innermost enclosing frame or accept statement must be the same in
the alternative order as in the canonical order, and the same exception

handlers must apply.
(b)

Within an expression, the association of operators with operandsis

specified by the syntax. However, for a sequence of predefined operators

of the same precedence level (and in the absence of parentheses
imposing a specific association), any association of operators with
operandsis allowedif it satisfies the following requirement: an integer

result must be equal to that given by the canonicalleft-to-right order;
a real result must belong to the result model interval defined for the
canonical left-to-right order (see 4.5.7). Such a reordering is allowed
even if it may remove an exception, or introduce a further predefined
exception.

11-13

Exceptions and Optimization

11.6

Similarly, additional freedom is left to an implementation for the evaluation

of numeric simple expressions. For the evaluation of a predefined operation,

an implementation is allowed to use the operation of a type that has a range
wider than that of the base type of the operands, provided that this delivers
the exact result (or a result within the declared accuracy, in the case of a
real type), even if some intermediate results lie outside the range of the
base type. The exception NUMERIC_ERRORneednot be raised in such a

case. In particular, if the numeric expression is an operand of a predefined

relational operator, the exception NUMERIC_ERRORneednot be raised by

the evaluation of the relation, provided that the correct BOOLEAN result is
obtained. ©
7

A predefined operation need not be invokedatall, if its only possible effect
is to propagate a predefined exception. Similarly, a predefined operation
need not be invoked if the removal of subsequent operations by the above
rule renders this invocation ineffective.
Notes:

Rule (b) applies to predefined operators but not to the short-circuit control

The expression SPEED < 300_000.0 can be replaced by TRUE if the value
300_000.0 lies outside the base type of SPEED, even though the implicit
conversion of the numeric literal would raise the exception NUMERIC_
ERROR.

Example:

forms.

declare
N : INTEGER;

begin
N := 0;
-for Jin 1 .. 10 loop
N := N + J**A(K);
-end loop;

(1)
A and K are global variables

PUT (N) ;

exception

when others => PUT("Some error arose");

end;

PUT(N);

The evaluation of A(K) may be performed before the loop, and possibly
immediately before the assignment statement (1) even if this evaluation can
raise an exception. Consequently, within the exception handler, the value
of N is either the undefined initial value or a value later assigned. On the
other hand, the evaluation of A(K) cannot be moved before begin since an
exception would then be handled by a different handler. For this reason, the

5 See also Appendix G, AI-00267.
11.6

Exceptions and Optimization

11-14

initialization of N in the declaration itself would exclude thepossibility of
having an undefined initial value of N in the handler.
References: accept statement 9.5, accuracy of real operations 4.5.7, assignment
5.2, base type 3.3, basic operation 3.3.3, conversion 4.6, error situation 11, exception
11, exception handler 11.2, frame 11.2, numeric_error exception 11.1, predefined
operator 4.5, predefined subprogram 8.6, propagation of an exception 11.4, real type
3.5.6, undefined value 3.2.1

11.7 Suppressing Checks
The presence of a SUPPRESS pragma gives permission to an implementation to omit certain run-time checks. The form of this pragmais as
follows:
pragma SUPPRESS (identifier

[ON =>]

name]);

The identifier is that of the check that can be omitted. The name(if
present) must be either a simple name or an expanded name and it must
denote either an object, a type or subtype, a task unit, or a generic unit;
alternatively the name can be a subprogram name, in which case it can
stand for several visible overloaded subprograms.
A pragma SUPPRESSis only allowed immediately within a declarative part
or immediately within a package specification. In the latter case, the only
allowed form is with a name that denotes an entity (or several overloaded
subprograms) declared immediately within the package specification.
The permission to omit the given check extends from the place of the
pragmato the end of the declarative region associated with the innermost
enclosing block statement or program unit. For a pragma given in a package
specification, the permission extends to the end of the scope of the named
entity.

If the pragma includes a name, the permission to omit the given check is
further restricted: it is given only for operations on the namedobject or
on all objects of the base type of a named type or subtype; for calls of a
named subprogram; for activations of tasks of the named task type; or for
instantiations of the given generic unit.
In addition to the pragma SUPPRESS, VAX Adaprovides the pragma
SUPPRESS_ALL for the purpose of suppressing all run-time checksin a
compilation unit. The form of this pragmais asfollows:
pragma SUPPRESSALL;
The pragma SUPPRESS_ALLis only allowed following a compilation unit.
The scope of the pragmais the entire unit or subunit that it follows.

11-15

Suppressing Checks

11.7

The following checks correspond to situations in which the exception
CONSTRAINT_ERROR mayberaised; for these checks, the name(if
present) must denote either an object or a type.

ACCESS_CHECK

Whenaccessing a selected component, an

indexed component,a slice, or an attribute,

of an object designated by an access value,
check that the access value is not null.

DISCRIMINANT_CHECK

Check that a discriminant of a composite
value has the value imposed by a discriminant constraint. Also, when accessing a

record component, check that it exists for the

current discriminant values.

INDEX_CHECK

Check that the bounds of an array value
are equal to the corresponding boundsof

an index constraint. Also, when accessing a
component of an array object, check for each

dimension that the given index value belongs
to the range defined by the boundsof the
array object. Also, when accessinga slice of

an array object, check that the given discrete

range is compatible with the range defined by

the bounds of the array object.
9

LENGTH_CHECK

Check that there is a matching component
for each componentof an array, in the case
of array assignments, type conversions,

and logical operators for arrays of boolean

components.

RANGECHECK

Check that a value satisfies a range constraint. Also, for the elaboration of a subtype

indication, check that the constraint (if
present) is compatible with the type mark.

Also, for an aggregate, check that an index or
discriminant value belongs to the corresponding subtype. Finally, check for any constraint
checks performed by a generic instantiation.
In VAX Ada, when explicitly passing an array
by reference to an imported subprogram
(and one of the unaligned descriptors ‘would
have applied if the default descriptor passing
mechanism had been used), check if the array
is aligned on a byte boundary. Also, when
11.7

Suppressing Checks

11-16

a VAX descriptoris created or used to pass

a parameterto or accept a function result

from an imported subprogram, check that the
descriptor length field is large enough to hold
the actual parameteror result length. See
section 13.9a.1.2 and the VAX Ada Run-Time

Reference Manual for more information on

when VAX descriptors are created or used.
The following checks correspond to situations in which the exception
NUMERIC_ERRORis raised. The only allowed names in the corresponding
pragmas are names of numeric types.
DIVISION_CHECK
OVERFLOW_CHECK

Check that the second operandis not zero for
the operations /, rem and mod.
Check that the result of a numeric operation
does not overflow.

The following check correspondsto situations in which the exception

PROGRAM_ERRORisraised. The only allowed namesin the corresponding

pragmas are names denoting task units, generic units, or subprograms.
15

ELABORATION_CHECK

Wheneither a subprogram 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.
16

The following check corresponds to situations in which the exception

STORAGE_ERRORis raised. The only allowed names in the corresponding

pragmas are names denoting access types, task units, or subprograms.
17

STORAGE_CHECK

Check that execution of an allocator does not
require more space thanis available for a
collection. Check that the space available for
a task or subprogram has not been exceeded.

If an error situation arises in the absence of the corresponding run-time
checks, the execution of the program is erroneous (the results are not defined
by the language).
Examples:
pragma SUPPRESS (RANGECHECK) ;
pragma SUPPRESS (INDEXCHECK, ON => TABLE);

11-17

Suppressing Checks

11.7

Notes:

For certain implementations, it may be impossible or too costly to suppress
certain checks. The corresponding SUPPRESS pragma can be ignored.
Hence, the occurrence of such a pragma within a given unit does not guarantee that the corresponding exception will not arise; the exceptions may
also be propagated by called units.
The pragma SUPPRESS_ALL does not suppress some checks that are
always performed by the VAX hardware and run-time system. For example, DIVISION_CHECK and OVERFLOW_CHECKcorrespond to hard-

ware checks that cannot be suppressed; the exceptions that correspond to

ACCESS_CHECK and STORAGE_CHECKmayalso be raised when the

pragma SUPPRESS_ALLis in effect. For more information, see the VAX
Ada Run-Time Reference Manual.
21

References: access type 3.8, access value 3.8, activation 9.3, aggregate 4.3, allocator 4.8, array 3.6, attribute 4.1.4, block statement 5.6, collection 3.8, compatible

3.3.2, component of an array 3.6, component of a record 3.7, composite type 3.3,

constraint 3.3, constraint_error exception 11.1, declarative part 3.9, designate 3.8,

dimension 3.6, discrete range 3.6, discriminant 3.7.1, discriminant constraint 3.7.2,
elaboration 3.1 3.9, erroneous 1.6, error situation 11, expanded name 4.1.3, generic
body 11.1, generic instantiation 12.3, generic unit 12, identifier 2.3, index 3.6, index
constraint 3.6.1, indexed component 4.1.1, null access value 3.8, numeric operation
3.5.5 3.5.8 3.5.10, numeric type 3.5, numeric_error exception 11.1, object 3.2, oper-

ation 3.3.3, package body 7.1, package specification 7.1, pragma 2.8, program_error
exception 11.1, program unit 6, propagation of an exception 11.4, range constraint
3.5, record type 3.7, simple name 4.1, slice 4.1.2, subprogram 6, subprogram body
6.3, subprogram call 6.4, subtype 3.38, subunit 10.2, task 9, task body 9.1, task type
9.1, task unit 9, type 3.3, type mark 3.3.2

actual parameter 6.4 6.4.1, allow 1.6, compilation unit 10.1, function result 6.5,
importing subprograms 13.9a.1.1, parameter 6.2, reference parameter passing
mechanism 13.9a.1.2, scope 8.2

11.7

Suppressing Checks

11-18

Chapter 12

Generic Units
A generic unit is a program unit that is either a generic subprogram or a
generic package. A generic unit is a template, which is parameterized or
not, and from which corresponding (nongeneric) subprograms or packages

can be obtained. The resulting program units are said to be instances of the
original generic unit.

A generic unit is declared by a generic declaration. This form of declaration
has a generic formal part declaring any generic formal parameters. An

instance of a generic unit is obtained as the result of a generic instantiation
with appropriate generic actual parameters for the generic formal
parameters. An instance of a generic subprogram is a subprogram. An

instance of a generic packageis a package.

Generic units are templates. As templates they do not have the properties

that are specific to their nongeneric counterparts. For example, a generic
subprogram can be instantiated but it cannot be called. In contrast, the
instance of a generic subprogram is a nongeneric subprogram; hence,this
instance can be called but it cannot be used to produce further instances.
References: declaration 3.1, generic actual parameter 12.3, generic declaration

12.1, generic formal parameter 12.1, generic formal part 12.1, generic instantiation
12.3, generic package 12.1, generic subprogram 12.1, instance 12.3, package 7,
program unit 6, subprogram 6

12.1

Generic Declarations
A generic declaration declares a generic unit, which is either a generic
subprogram or a generic package. A generic declaration includes a

generic formal part declaring any generic formal parameters. A generic

formal parameter can be an object; alternatively (unlike a parameterof a
subprogram), it can be a type or a subprogram.

12-1

Generic Declarations

12.1

genericdeclaration ::= genericspecification;
genericspecification ::=
genericformalpart subprogram_specification
| genericformalpart packagespecification
genericformalpart ::=
generic {genericparameterdeclaration}
genericparameterdeclaration ::=
|
|
|
|

identifierlist

[in

[out]]

typemark

[:= expression];

type identifier is generictypedefinition;
privatetypedeclaration
with subprogram_specification [is name];
with subprogramspecification [is <>];

The terms generic formal object (or simply, formal object), generic formal
type (or simply, formal type), and generic formal subprogram (or simply,
formal subprogram) are used to refer to corresponding generic formal
parameters.

The only form of subtype indication allowed within a generic formal part
is a type mark (that is, the subtype indication must not include an explicit
constraint). The designator of a generic subprogram must be an identifier.
Outside the specification and body of a generic unit, the nameof this

program unit denotes the generic unit. In contrast, within the declarative
region associated with a generic subprogram, the nameof this program unit
denotes the subprogram obtained by the current instantiation of the generic
unit. Similarly, within the declarative region associated with a generic

package, the nameof this program unit denotes the package obtained by the
current instantiation!

The elaboration of a generic declaration has no othereffect.

Examples of generic formal parts:
generic

parameterless

generic
SIZE : NATURAL;
generic
LENGTH

INTEGER

AREA

INTEGER

formal object
200;

:= LENGTH*LENGTH;

-- formal object with a
-- default expression
-- formal object with a

-- default expression

1 See also Appendix G, AI-00286, AI-00367, and AI-00412.
12.1.

Generic Declarations

12-2

generic
type ITEM

is private;

—- formal type

type INDEX is (<>);
-- formal type
type ROW
is array(INDEX range <>) of ITEM; -- formal type
with function "<"(X, Y : ITEM) return BOOLEAN; -- formal
-- subprogram

Examples of generic declarations declaring generic subprograms:
generic
type ELEM is private;
procedure EXCHANGE (U, V : in out ELEM);
generic
type ITEM is private;
with function "*"(U, V :
function SQUARING(X : ITEM)

ITEM) return ITEM is <>;
return ITEM;

Example of a generic declaration declaring a generic package:
generic

type ITEM
is private;
type VECTOR is array (POSITIVE range <>)

with function SUM(X,

package ONVECTORS is
function SUM
(A,
function SIGMA(A

Y
:
:

ITEM)

VECTOR)
VECTOR)

LENGTHERROR : exception;

of ITEM;

return ITEM;
return VECTOR;
return ITEM;

end;

Notes:
10

Within a generic subprogram, the nameof this program unit acts as the

name of a subprogram. Hence this name can be overloaded, and it can

appear in a recursive call of the current instantiation. For the same reason,
this name cannot appear after the reserved word new in a (recursive)
generic instantiation.
11

An expression that occurs in a generic formal part is either the default
expression for a generic formal object of mode in, or a constituent of an
entry name given as default namefor a formal subprogram,or the default
expression for a parameter of a formal subprogram. Default expressions
for generic formal objects and default names for formal subprograms are
only evaluated for generic instantiations that use such defaults. Default
expressions for parameters of formal subprogramsare only evaluated for

calls of the formal subprograms that use such defaults. (The usual visibility

rules apply to any name used in a default expression: the denoted entity

must therefore be visible at the place of the expression.)

Neither generic formal parameters nor their attributes are allowed con-

stituents of static expressions(see 4.9).

12-3

Generic Declarations

12.1

References: access type definition 3.8, array type definition 3.6, attribute 4.1.4,

constraint 3.3, declaration 3.1, designator 6.1, elaboration has no othereffect

3.1, entity 3.1, expression 4.4, function 6.5, generic instantiation 12.3, identifier
2.3, identifier list 3.2, instance 12.3, name 4.1, object 3.2, overloading 6.6 8.7,

package specification 7.1, parameter of a subprogram 6.2, private type definition 7.4,
procedure 6.1, reserved word 2.9, static expression 4.9, subprogram 6, subprogram
specification 6.1, subtype indication 3.3.2, type 3.3, type mark 3.3.2

12.1.1

Generic Formal Objects
1

The first form of generic parameter declaration declares generic formal

objects. The type of a generic formal object is the base type of the type
denoted by the type mark given in the generic parameter declaration. A

generic parameter declaration with several identifiers is equivalent to a

sequence of single generic parameter declarations, as explained in
section 3.2.

A generic formal object has a modethat is either in or in out. In the absence of an explicit mode indication in a generic parameter declaration, the
mode in is assumed; otherwise the modeis the one indicated. If a generic

parameter declaration ends with an expression, the expression is the default
expression of the generic formal parameter. A default expression is only
allowed if the modeis in (whether this modeis indicated explicitly or implicitly). The type of a default expression must be that of the corresponding
generic formal parameter.

A generic formal object of mode in is a constant whose valueis a copy of
the value supplied as the matching generic actual parameter in a generic
instantiation, as described in section 12.3. The type of a generic formal

object of mode in must not be a limited type; the subtype of such a generic

formal object is the subtype denoted by the type mark given in the generic
parameter declaration.

A generic formal object of mode in out is a variable and denotes the
object supplied as the matching generic actual parameter in a generic

instantiation, as described in section 12.3. The constraints that apply to

the generic formal object are those of the corresponding generic actual
parameter.

12.1.1.

Generic Formal Objects

12-4

Note:

The constraints that apply to a generic formal object of mode in out are
those of the corresponding generic actual parameter (not those implied by
the type mark that appears in the generic parameter declaration). Whenever
possible (to avoid confusion) it is recommendedthat the nameof a base type
be used for the declaration of such a formal object. If, however, the

base type is anonymous, it is recommended that the subtype name defined
by the type declaration for the base type be used.
References: anonymoustype 3.3.1, assignment 5.2, base type 3.3, constant
declaration 3.2, constraint 3.3, declaration 3.1, generic actual parameter 12.3,
generic formal object 12.1, generic formal parameter 12.1, generic instantiation

12.3, generic parameter declaration 12.1, identifier 2.3, limited type 7.4.4, matching
generic actual parameter 12.3, mode 6.1, name 4.1, object 3.2, simple name 4.1,

subtype 3.3, type declaration 3.3, type mark 3.3.2, variable 3.2.1

12.1.2

Generic Formal Types
A generic parameter declaration that includes a generic type definition or
a private type declaration declares a generic formal type. A generic formal

type denotes the subtype supplied as the corresponding actual parameter in

a generic instantiation, as described in 12.3(d). However, within a generic
unit, a generic formal type is considered as being distinct from all other
(formal or nonformal) types. The form of constraint applicable to a formal
type in a subtype indication depends on theclass of the type as for a

nonformal type.

The only form of discrete range that is allowed within the declaration of a
generic formal (constrained) array type is a type mark.
The discriminant part of a generic formal private type must not include
a default expression for a discriminant. (Consequently, a variable that is
declared by an object declaration must be constrained if its type is a generic
formal type with discriminants.)
Within the declaration and body of a generic unit, the operations available
for values of a generic formal type (apart from any additional operation
specified by a generic formal subprogram) are determined by the generic
parameter declaration for the formal type:
(a)

12-5

For a private type declaration, the available operations are those
defined in section 7.4.2 (in particular, assignment, equality, and
inequality are available for a private type unless it is limited).

Generic Formal Types

12.1.2

(b)

For an array type definition, the available operations are those defined
in section 3.6.2 (for example, they include the formation of indexed
components andslices).

(c)

The four forms of generic type definition in which a box appears(that is, the

For an access type definition, the available operations are those defined

in section 3.8.2 (for example, allocators can be used).

compound delimiter <>) correspond to the following major forms of scalar

type:

(d)

Discrete types: <>
The available operations are the operations common to enumeration
and integer types; these are defined in section 3.5.5.

(e)

Integer types: range <>
The available operations are the operations of integer types defined in
section 3.5.5.

~«©6©(f)

Floating point types: digits <>
The available operations are those defined in section 3.5.8.

(g)

Fixed point types: delta <>
The available operations are those defined in section 3.5.10.

~+In all of the above cases (a) through (f), each operation implicitly associated
with a formal type (that is, other than an operation specified by a formal
subprogram) is implicitly declared at the place of the declaration of the

formal type. The sameholds for a formal fixed point type, except for the

multiplying operators that deliver a result of the type wniversal_fixed (see

4.5.5), since these special operators are declared in the package STANDARD.

14.

For an instantiation of the generic unit, each of these operations is the
corresponding basic operation or predefined operator of the matching actual
type. For an operator, this rule applies even if the operator has been
redefined for the actual type or for some parent type of the actual type.

Examples of generic formal types:
type ITEM is private;
type BUFFER(LENGTH : NATURAL)
type
type
type
type

ENUM
INT
ANGLE
MASS

is (<>);
is range <>;
is delta <>;
is digits <>;

type TABLE is array

12.1.2

.
is limited private;

Generic Formal Types

(ENUM)

of ITEM;

12-6

Example of a generic formal part declaring a formal integer type:
generic
type RANK is range <>;
FIRST
SECOND

:
:

RANK
RANK

:= RANK’ FIRST;
:= FIRST + 1;

the operator "+"

the type RANK

References: access type definition 3.8, allocator 4.8, array type definition 3.6,
assignment 5.2, body of a generic unit 12.2, class of type 3.3, constraint 3.3,
declaration 3.1, declaration of a generic unit 12.1, discrete range 3.6, discrete type
3.5, discriminant part 3.7.1, enumeration type 3.5.1, equality 4.5.2, fixed point type
3.5.9, floating point type 3.5.7, generic actual type 12.3, generic formal part 12.1,
generic formal subprogram 12.1.3, generic formal type 12.1, generic parameter
declaration 12.1, generic type definition 12.1, indexed component 4.1.1, inequality
4.5.2, instantiation 12.3, integer type 3.5.4, limited private type 7.4.4, matching
generic actual type 12.3.2 12.3.3 12.3.4 12.3.5, multiplying operator 4.5 4.5.5,
operation 3.3, operator 4.5, parent type 3.4, private type definition 7.4, scalar type
3.5, slice 4.1.2, standard package 8.6 C, subtype indication 3.3.2, type mark 3.3.2,
universal_fixed 3.5.9

12.1.3.

Generic Formal Subprograms
41

A generic parameter declaration that includes a subprogram specification
declares a generic formal subprogram.

Two alternative forms of defaults can be specified in the declaration of a
generic formal subprogram. In these forms, the subprogram specification
is followed by the reserved word is and either a box or the nameof a
subprogram or entry. The matching rules for these defaults are explained in
section 12.3.6.
A generic formal subprogram denotes the subprogram, enumeration literal,
or entry supplied as the corresponding generic actual parameter in a generic
instantiation, as described in section 12.3(f).

Examples of generic formal subprograms:
with

function

INCREASE (X

with function SUM(X,

INTEGER)

ITEM)

return

INTEGER;

return ITEM;

with function "+"(X, Y : ITEM) return ITEM is <>;
with function IMAGE(X : ENUM) return STRING is ENUM’ IMAGE;
with procedure UPDATE is DEFAULTUPDATE;

12-7

Generic Formal Subprograms

12.1.3

Notes:

The constraints that apply to a parameter of a formal subprogram are
those of the corresponding parameter in the specification of the matching
actual subprogram (not those implied by the corresponding type mark
in the specification of the formal subprogram). A similar remark applies
to the result of a function. Whenever possible (to avoid confusion), it is
recommended that the nameof a base type be used rather than the name of
a subtype in any declaration of a formal subprogram. If, however, the base
type is anonymous,it is recommendedthat the subtype namedefined by the
type declaration be used.

The type specified for a formal parameter of a generic formal subprogram

can be any visible type, including a generic formal type of the same generic

formal part.
7

References: anonymoustype 3.3.1, base type 3.3, box delimiter 12.1.2, constraint

3.3, designator 6.1, generic actual parameter 12.3, generic formal function 12.1,

generic formal subprogram 12.1, generic instantiation 12.8, generic parameter
declaration 12.1, identifier 2.3, matching generic actual subprogram 12.3.6, operator
symbol 6.1, parameter of a subprogram 6.2, renaming declaration 8.5, reserved word
2.9, scope 8.2, subprogram 6, subprogram specification 6.1, subtype 3.3.2, type 3.3,
type mark 3.3.2

12.1a Pragma INLINEGENERIC
VAX Ada provides the pragma INLINE_GENERICto allow the desire for
inline expansion of the generic body to be indicated for each instantiation of
the named generic declarations, or for the particular named instances. The
form of this pragmais as follows:
pragma INLINEGENERIC

(name

name});

Each nameis either the nameof a generic declaration or the name of
an instance of a generic declaration. The pragma INLINE_GENERICis
only allowed at the place of a declarative item in a declarative part or
packagespecification, or after a library unit in a compilation, but before any
subsequent compilation unit.
If the pragma appearsat the place of a declarative item, each name must
denote a generic subprogram or package, or a (nongeneric) subprogram or
package that is an instance of a generic subprogram or package, declared
by an earlier declarative item of the same declarative part or package
specification. If several (nongeneric, overloaded) subprogramssatisfy this
requirement, the pragma applies to all of them. If the pragma appears
after a given library unit, the only name allowed is the nameof that unit.
12.1a

Pragma INLINE_GENERIC

12-8

If the name of a subprogram that is an instance of a generic subprogram
is mentioned in the pragma, it indicates that only inline expansion of the
instance itself is desired (it does not indicate that inline expansion ofcalls of
the subprogram is desired).
If the name specified by a pragma INLINE_GENERICis an instantiation
declared by a renaming declaration, the pragma INLINE_GENERIC applies
to the instantiation only if the instantiation that has been renamed, the
renaming declaration, and the pragmaall occur in the same declarative part
or package specification. The pragmais ignored if these conditions are not
satisfied.
The meaning of an instantiation is not changed by the pragma INLINE_
GENERIC.
Inline expansion of an instance creates a dependence of the unit containing
the instantiation upon the corresponding generic proper body (the template
and its subunits, if any); VAX Ada recognizes this dependence when deciding
on the need for recompilation. See Developing Ada Programs on VMS
Systems for more information on VAX Ada recompilation requirements.
Notes:

The pragma INLINE_GENERICcausesinline expansion of the generic body
(and substitution of actual parameters for any generic formal parameters)
at the point of any instantiation to which the pragmaapplies. Because
of this effect, the pragma INLINE_GENERICdiffers from the pragma
INLINE in two respects. First, the pragma INLINE_GENERICfor a generic
subprogram or an instance of a generic subprogram does not indicate a
desire that calls of the subprogramsare to be expandedinline. Second, the
pragma INLINE_GENERIC can be given for a generic package or for an
instance of a generic package (while the pragma INLINE cannot).
If the pragma INLINEis given for a generic subprogram, the pragma
INLINE_GENERIC mayalso be given; similarly, if the pragma INLINE
is given for an instance of a generic subprogram, the pragma INLINE_
GENERIC mayalso be given. In such cases, if calls are expandedinline,
then the pragma INLINE_GENERIC has no additional effect. However, if
calls are not expandedinline, the instance maystill be expandedinline. (If
only the pragma INLINEis given, and calls are not expandedinline, then
the instance cannot be expandedinline either.)
If a pragma INLINE_GENERIC appearsat the place of a declarative item
and a namein the pragmais overloaded, the pragma applies only to those
instantiations whose declarations occur (explicitly) earlier in the same
declarative part or package specification.

12-9

Pragma INLINE_GENERIC

12.1a

References: compilation unit 10.1, declarative item 3.9, declarative part: 3.9,

generic declaration 12.1, generic package 12.1, generic subprogram 12.1, generic
template 12 12.2, instance 12.3, instantiation 12.3, library unit 10.1, name 4.1,
package specification 7.1, renaming declaration 8.5, subprogram 6, subunit 10.2

12.16 Pragma SHARE_GENERIC
VAX Ada provides the pragma SHARE_GENERICto allow the desire for
generic code sharing to be indicated for each instantiation of the named
generic declarations, or for the particular named instances. The form of this
pragmais as follows:
pragma SHAREGENERIC (name {, name});

Each nameis either the nameof a generic declaration or the name of
an instance of a generic declaration. The pragma SHARE_GENERICis
only allowed at the place of a declarative item in a declarative part or
package specification, or after a library unit in a compilation, but before any
subsequent compilation unit.
If the pragma appears at the place of a declarative item, each name must
denote a generic subprogram or package, or a (nongeneric) subprogram or
package that is an instance of a generic subprogram or package, declared
by an earlier declarative item of the same declarative part or package
specification. If several (nongeneric, overloaded) subprogramssatisfy this
requirement, the pragmaapplies to all of them. If the pragma appearsafter
a given library unit, the only nameallowed is the nameof that unit.
If the namespecified by a pragma SHARE_GENERICis an instantiation
declared by a renaming declaration, the pragma SHARE_GENERICapplies
to the instantiation only if the instantiation that has been renamed, the
renaming declaration, and the pragmaall occur in the same declarative part
or package specification. The pragmais ignored if these conditions are not
satisfied.
The meaning of an instantiation is not changed by the pragma SHARE_
GENERIC.
The pragmas SHARE_GENERIC and INLINE_GENERICcannot apply to
the same generic declaration. However, the pragma INLINE_GENERIC
can be specified for an instance even if the pragma SHARE_GENERIC
applies to the corresponding generic declaration. In this case, the pragma
specified for the instance overrides the pragma that applies to the generic
declaration, and the expansion of the particular instance is expandedinline.
Similarly, the pragma SHARE_GENERICcanbespecified for an instance
even if the pragma INLINE_GENERICapplies to the corresponding generic
12.1b

Pragma SHARE_GENERIC

12-10

declaration. Again, the pragmaspecified for the instance overrides the
pragma that applies to the generic declaration.
Notes:

The pragma SHARE_GENERICcauses the code for an instance to be
generated in such a mannerasto allow the samecode to be shared by other
instances of the same generic under someconditions.
References: compilation unit 10.1, declarative item 3.9, declarative part 3.9,
generic declaration 12.1, generic package 12.1, generic subprogram 12.1, generic

template 12 12.2, instance 12.3, instantiation 12.3, library unit 10.1, name 4.1,

packagespecification 7.1, renaming declaration 8.5, subprogram 6, subunit 10.2

12.2

Generic Bodies
1

The body of a generic subprogram or generic package is a template for
the bodies of the corresponding subprograms or packages obtained by
generic instantiations. The syntax of a generic body is identical to that of a

nongeneric body.2

For each declaration of a generic subprogram, there must be a corresponding

body.

The elaboration of a generic body has no other effect than to establish
that the body can from then on be used as the template for obtaining the
corresponding instances.

Example of a generic procedure body:
procedure EXCHANGE (U, V : in out ELEM) is -- see example in 12.1
T : ELEM;
-- the generic formal type
begin
T := U;
U := V;
Vi := T;
end EXCHANGE;

Example of a generic function body:
function SQUARING(X :
begin
return X*X;

end;

ITEM)

return ITEM is -- see example in 12.1

the formal operator "*"

2 See also Appendix G, AI-00328.
12—11

Generic Bodies

12.2

Example of a generic package body:
package body ONVECTORS is
function SUM(A,

see example in 12.1

VECTOR)

RESULT : VECTOR (A’ RANGE) ;
BIAS

begin

constant INTEGER

return VECTOR is

the formal type VECTOR

:= B’FIRST - A’FIRST;

if A’ LENGTH /= B’ LENGTH then

raise LENGTHERROR;

end if;

for N in A’RANGE loop
RESULT(N)

SUM(A(N),

B(N

BIAS));

end loop;

the

function SUM

formal

the

type ITEM

--~-

the formal
function SUM

return RESULT;
end;
function SIGMA(A
TOTAL

ITEM

VECTOR)

return ITEM is

:= A(A’FIRST);

begin
for N in A’FIRST + 1 .. A’LAST loop
TOTAL := SUM(TOTAL, A(N));

end loop;

formal

return TOTAL;
end;
end;

12.3

References: body 3.9, elaboration 3.9, generic body 12.1, generic instantiation
12.3, generic package 12.1, generic subprogram 12.1, instance 12.3, package body
7.1, package 7, subprogram 6, subprogram body 6.3

Generic Instantiation
1
2

An instance of a generic unit is declared by a generic instantiation.
genericinstantiation ::=
package identifier is
new genericpackagename [genericactualpart];
| procedure identifier is
new genericprocedurename [genericactualpart];
| function designator is
new genericfunctionname [genericactualpart];

genericactualpart ::=

(genericassociation {,

genericassociation ::=

generic_association})

[genericformalparameter =>]

12.3

Generic Instantiation

genericactualparameter

12-12

genericformalparameter
parametersimplename

::=
| operatorsymbol

genericactualparameter ::= expression
|

subprogramname

entryname

variablename

typemark

An explicit generic actual parameter must be supplied for each generic
formal parameter, unless the corresponding generic parameter declaration
specifies that a default can be used. Generic associations can be either
positional or named in the same manner as parameter associations of
subprogram calls (see 6.4). If two or more formal subprograms have
the same designator, then namedassociations are not allowed for the
corresponding generic parameters.

Each generic actual parameter must match the corresponding generic formal
parameter. An expression can match a formal object of mode in; a variable
name can match a formal object of mode in out; a subprogram nameor

an entry name can match a formal subprogram; a type mark can match a

formal type. The detailed rules defining the allowed matches are given in
sections 12.3.1 to 12.3.6; these are the only allowed matches.

The instance is a copy of the generic unit, apart from the generic formal
part; thus the instance of a generic package is a package, that of a generic
procedure is a procedure, and that of a generic function is a function. For

each occurrence, within the generic unit, of a name that denotes a given

entity, the following list defines which entity is denoted by the corresponding

occurrence within the instance.®
(a)
(b)

For a namethat denotes the generic unit: The corresponding occur-

rence denotes the instance.

For a name that denotes a generic formal object of mode in: The

corresponding name denotes a constant whose valueis a copy of the
value of the associated generic actual parameter.

(c)

For anamethat denotes a generic formal object of mode in out: The
corresponding name denotes the variable named by the associated
generic actual parameter.

(d)

For a name that denotes a generic formal type: The corresponding
name denotes the subtype namedby the associated generic actual
parameter(the actual subtype).

(e)

For a namethat denotes a discriminant of a generic formal type: The

corresponding name denotes the corresponding discriminant (there
must be one) of the actual type associated with the generic formal type.

3 See also Appendix G, AI-00398 and AI-00409.
12-13

Generic Instantiation

12.3

(f)

For a name that denotes a generic formal subprogram: The correspond-

ing name denotes the subprogram, enumeration literal, or entry named
by the associated generic actual parameter (the actual subprogram).

(g)

For a name that denotes a formal parameter of a generic formal

subprogram: The corresponding name denotes the corresponding

formal parameter of the actual subprogram associated with the formal
subprogram.
(h)

For a name that denotes a local entity declared within the generic

unit: The corresponding name denotes the entity declared by the

corresponding local declaration within the instance.

Gi)

For a namethat denotes a global entity declared outside of the generic
unit: The corresponding name denotes the same global entity.

Similar rules apply to operators and basic operations: in particular, formal

operators follow a rule similar to rule (f), local operations follow a rule

similar to rule (h), and operations for global types follow a rule similar
to rule (1). In addition, if within the generic unit a predefined operator
or basic operation of a formal type is used, then within the instance the
corresponding occurrence refers to the corresponding predefined operation of

the actual type associated with the formal type.

The above rules apply also to any type mark or (default) expression given

within the generic formal part of the generic unit.

For the elaboration of a generic instantiation, each expression supplied
as an explicit generic actual parameteris first evaluated, as well as each
expression that appears as a constituent of a variable name or entry name
supplied as an explicit generic actual parameter; these evaluations proceed
in some order that is not defined by the language. Then, for each omitted
generic association (if any), the corresponding default expression or default
nameis evaluated; such evaluations are performed in the order of the
generic parameter declarations. Finally, the implicitly generated instance
is elaborated. The elaboration of a generic instantiation may also involve
certain constraint checks as described in later subsections.4
18

Recursive generic instantiation is not allowed in the following sense: if a
given generic unit includes an instantiation of a second generic unit, then
the instance generated by this instantiation must not include an instance
of the first generic unit (whether this instance is generated directly, or
indirectly by intermediate instantiations).

4 See also Appendix G, AI-00237 and AI-00365.
12.3

Generic Instantiation

12-14

Examples of generic instantiations (see 12.1):
procedure

SWAP

new EXCHANGE (ELEM =>

INTEGER) ;

procedure SWAP is new EXCHANGE (CHARACTER);

SWAP is overloaded

function SQUARE is new SQUARING(INTEGER);

---

"*" of INTEGER
used by default

function SQUARE is new SQUARING(ITEM => MATRIX,
"xN
=> MATRIXPRODUCT) ;
function SQUARE is new SQUARING (MATRIX,

MATRIXPRODUCT) ;

—-- same as previous

package INTVECTORS is new ONVECTORS (INTEGER,
20

TABLE,

"+");

Examples of uses of instantiated units:
SWAP (A, B);
A := SQUARE (A);
T : TABLE(1 .. 5) := (10, 20, 30, 40, 50);
N : INTEGER := INTVECTORS.SIGMA(T); -- 150 (see 12.2 for
--

use INTVECTORS;
M : INTEGER := SIGMA(T);

the body of SIGMA)

150

Notes:
21

Omission of a generic actual parameteris only allowed if a corresponding

default exists. If default expressions or default names (other than simple
names) are used, they are evaluated in the order in which the corresponding
generic formal parameters are declared.
22

If two overloaded subprograms declared in a generic package specification
differ only by the (formal) type of their parameters and results, then there
exist legal instantiations for whichall calls of these subprograms from
outside the instance are ambiguous. For example:
generic

type A is

(<>);

type B is private;
package G is
function NEXT(X
function NEXT(X
end;

:
:

A)
B)

return A;
return B;

package P is new G(A => BOOLEAN,

-- calls of P.NEXT are ambiguous

12-15

B => BOOLEAN) ;

Generic Instantiation

12.3

References: declaration 3.1, designator 6.1, discriminant 3.7.1, elaboration 3.1
3.9, entity 3.1, entry name 9.5, evaluation 4.5, expression 4.4, generic formal object
12.1, generic formal parameter 12.1, generic formal subprogram 12.1, generic formal
type 12.1, generic parameter declaration 12.1, global declaration 8.1, identifier 2.3,
implicit declaration 3.1, local declaration 8.1, mode in 12.1.1, mode in out 12.1.1,

name 4.1, operation 3.3, operator symbol 6.1, overloading 6.6 8.7, package 7, simple
name 4.1, subprogram 6, subprogram call 6.4, subprogram name6.1, subtype
declaration 3.3.2, type mark 3.3.2, variable 3.2.1, visibility 8.3

12.3.1

Matching Rules for Formal Objects
A generic formal parameter of mode in of a given type is matched by an

expression of the same type. If a generic unit has a generic formal object
of mode in, a check is made that the value of the expression belongs to the
subtype denoted by the type mark, as for an explicit constant declaration

(see 3.2.1). The exception CONSTRAINT_ERRORis raised if this check

fails.

A generic formal parameter of mode in out of a given type is matched by
the nameof a variable of the same type. The variable must not be a formal

parameter of mode out or a subcomponent thereof. The name must denote a
variable for which renamingis allowed (see 8.5).
Notes:

The type of a generic actual parameter of mode in must not be a limited

type. The constraints that apply to a generic formal parameter of mode in

out are those of the corresponding generic actual parameter (see 12.1.1).

References: constraint 3.3, constraint_error exception 11.1, expression 4.4, formal

parameter 6.1, generic actual parameter 12.8, generic formal object 12.1.1,- generic

formal parameter 12.1, generic instantiation 12.3, generic unit 12.1, limited type

7.4.4, matching generic actual parameter 12.3, mode in 12.1.1, mode in out 12.1.1,
mode out 6.2, name 4.1, raising of exceptions 11, satisfy 3.8, subcomponent 3.3, type
3.3, type mark 3.3.2, variable 3.2.1

12.3.2

Matching Rules for Formal Private Types
1

A generic formal private type is matched by any type or subtype (the actual
subtype) that satisfies the following conditions:

e¢

Ifthe formal typeis not limited, the actual type must not be a limited
type. (If, on the other hand, the formal typeis limited, no such condition
is imposed on the corresponding actual type, which can be limited or not
limited.)

12.3.2

Matching Rules for Formal Private Types

12-16

Ifthe formal type has a discriminant part, the actual type must be a

type with the same numberof discriminants; the type of a discriminant

that appears at a given position in the discriminant part of the actual
type must be the sameasthe type of the discriminant that appears
at the same position in the discriminant part of the formal type; and
the actual subtype must be unconstrained. (If, on the other hand, the
formal type has no discriminants, the actual type is allowed to have

discriminants. )

Furthermore, consider any occurrence of the name of the formal type at a
place where this nameis used as an unconstrained subtype indication. The

actual subtype must not be an unconstrained array type or an unconstrained
type with discriminants, if any of these occurrences is at a place where
either a constraint or default discriminants would be required for an array
type or for a type with discriminants (see 3.6.1 and 3.7.2). The same
restriction applies to occurrences of the nameof a subtype of the formal
type, and to occurrences of the name of any type or subtype derived, directly
or indirectly, from the formal type.®

If a generic unit has a formal private type with discriminants, the elabora-

tion of a corresponding generic instantiation checks that the subtype of each

discriminant of the actual type is the same as the subtype of the corresponding discriminant of the formal type. The exception CONSTRAINT_ERROR
is raised if this check fails.
References: array type 3.6, constraint 3.3, constraint_error exception 11.1,
default expression for a discriminant 3.7.1, derived type 3.4, discriminant 3.7.1,
discriminant part 3.7.1, elaboration 3.9, generic actual type 12.3, generic body 12.2,

generic formal type 12.1.2, generic instantiation 12.3, generic specification 12.1,

limited type 7.4.4, matching generic actual parameter 12.3, name 4.1, private type
7.4, raising of exceptions 11, subtype 3.3, subtype indication 3.3.2, type 3.3, type
with discriminants 3.3, unconstrained array type 3.6, unconstrained subtype 3.3

12.3.3.

Matching Rules for Formal Scalar Types
1

A generic formal type defined by (<>) is matched by any discrete subtype
(that is, any enumeration or integer subtype). A generic formal type defined
by range <> is matched by any integer subtype. A generic formal type
defined by digits <> is matched by any floating point subtype. A generic
formal type defined by delta <> is matched by anyfixed point subtype. No
other matchesare possible for these generic formal types.

5 See also Appendix G, AI-00037.
12-17

Matching Rules for Formal Scalar Types

12.3.3

References: box delimiter 12.1.2, discrete type 3.5, enumeration type 3.5.1, fixed
point type 3.5.9, floating point type 3.5.7, generic actual type 12.3, generic formal
type 12.1.2, generic type definition 12.1, integer type 3.5.4, matching generic actual
parameter 12.3, scalar type 3.5

12.3.4

Matching Rules for Formal Array Types
1

A formal array type is matched by an actual array subtype that satisfies the
following conditions:
¢

The formal array type and the actual array type must have the same

dimensionality; the formal type and the actual subtype must be either

both constrained or both unconstrained.
e

For each index position, the index type must be the samefor the actual

array type as for the formal array type.

The component type must be the same for the actual array type as for

the formal array type. If the component type is other than a scalar type,

then the component subtypes must be either both constrained or both
unconstrained.

If a generic unit has a formal array type, the elaboration of a corresponding
instantiation checks that the constraints (if any) on the component type are
the samefor the actual array type as for the formal array type, and likewise
that for any given index position the index subtypes or the discrete ranges
have the same bounds. The exception CONSTRAINT_ERRORisraisedif
this checkfails.
Example:
--

given the generic package

generic
type ITEM

type INDEX

is private;

is (<>);

type VECTOR is array
type TABLE is array
package P is

(INDEX range <>) of ITEM;
(INDEX) of ITEM;

end;
--

and the types

type MIX

is array

type OPTION is array
--

(COLOR range <>)

(COLOR)

then MIX can match VECTOR and OPTION can match TABLE

package R is new P (ITEM

=> BOOLEAN,

VECTOR => MIX,

12.3.4

of BOOLEAN;

Matching Rules for Formal Array Types

INDEX => COLOR,
TABLE => OPTION);

12-18

—--

Note that MIX cannot match TABLE and

OPTION

cannot

match VECTOR

Note:

For the aboverules, if any of the index or component types of the formal
array typeis itself a formal type, then within the instance its name denotes

the corresponding actual subtype (see 12.3(d)).

References: array type 3.6, array type definition 3.6, component of an array
3.6, constrained array type 3.6, constraint 3.3, constraint_error exception 11.1,
elaboration 3.9, formal type 12.1, generic formal type 12.1.2, generic instantiation
12.3, index 3.6, index constraint 3.6.1, matching generic act1al parameter 12.3, raise
statement 11.3, subtype 3.3, unconstrained array type 3.6

12.3.5

Matching Rules for Formal Access Types
1

A formal access type is matched by an actual access subtype if the type
of the designated objects is the same for the actual type as for the formal
type. If the designated type is other than a scalar type, then the designated
subtypes must be either both constrained or both unconstrained.
If a generic unit has a formal access type, the elaboration of a corresponding

instantiation checks that any constraints on the designated objects are
the same for the actual access subtype as for the formal access type. The
exception CONSTRAINT_ERRORisraised if this checkfails.

Example:
--

the formal types of the generic package

generic
type NODE is private;
type LINK is access NODE;
package P is
end;
--

can be matched by the actual types

type CAR;

type CARNAME is access CAR;
type CAR is
record
PRED, SUCC
NUMBER
OWNER
end record;

:
:
:

CARNAME;
LICENSENUMBER;
PERSON;

in the following generic instantiation

package R is new P(NODE => CAR,

12-19

LINK => CAR_NAME) ;

Matching Rules for Formal Access Types

12.3.5

Note:

For the above rules, if the designated type is itself a formal type, then within
the instance its name denotes the corresponding actual subtype (see 12.3(d)).

References: access type 3.8, access type definition 3.8, constraint 3.3, constraint_
error exception 11.1, designate 3.8, elaboration 3.9, generic formal type 12.1.2,
generic instantiation 12.3, matching generic actual parameter 12.3, object 3.2, raise
statement 11.3, value of access type 3.8

12.3.6

Matching Rules for Formal Subprograms
1

A formal subprogram is matched by an actual subprogram, enumeration
literal, or entry if both have the same parameter and result type profile (see

6.6); in addition, parameter modes must be identical for formal parameters
that are at the same parameterposition.

If a generic unit has a default subprogram specified by a name, this name

must denote a subprogram, an enumeration literal, or an entry, that matches

the formal subprogram (in the above sense). The evaluation of the default

name takes place during the elaboration of each instantiation that uses the

default, as defined in section 12.3.6

If a generic unit has a default subprogram specified by a box, the corresponding actual parameter can be omitted if a subprogram, enumeration

literal, or entry matching the formal subprogram, and with the same desig-

nator as the formal subprogram,is directly visible at the place of the generic
instantiation; this subprogram, enumerationliteral, or entry is then used by

default (there must be exactly one subprogram, enumerationliteral, or entry
satisfying the previous conditions).

Example:
--

given the generic function specification

generic
type ITEM is private;
with function "*" (U, V : ITEM) return ITEM is <>;
function SQUARING(X : ITEM) return ITEM;

and the function

function MATRIXPRODUCT(A, B : MATRIX)
--

return MATRIX;

the following instantiation is possible

6 See also Appendix G, AI-00038.
12.3.6

Matching Rules for Formal Subprograms

12-20

function SQUARE is new SQUARING (MATRIX, MATRIXPRODUCT) ;
--

the following instantiations are equivalent

function SQUARE is new SQUARING(ITEM => INTEGER,
function SQUARE is new SQUARING(INTEGER, "*");
function SQUARE is new SQUARING (INTEGER) ;

"*" => "X");

Notes:

The matching rules for formal subprograms state requirements that are
similar to those applying to subprogram renaming declarations (see 8.5). In
particular, the name of a parameter of the formal subprogram need not be
the same as that of the corresponding parameter of the actual subprogram;
similarly, for these parameters, default expressions need not correspond.
A formal subprogram is matched by an attribute of a type if the attributeis
a function with a matching specification. An enumeration literal of a given
type matches a parameterless formal function whose result type is the given
type.

References: attribute 4.1.4, box delimiter 12.1.2, designator 6.1, entry 9.5,
function 6.5, generic actual type 12.3, generic formal subprogram 12.1.8, generic
formal type 12.1.2, generic instantiation 12.3, matching generic actual parameter
12.3, name 4.1, parameter and result type profile 6.3, subprogram 6, subprogram
specification 6.1, subtype 3.3, visibility 8.3

12.4 Example of a Generic Package
The following example provides a possible formulation of stacks by means of
a generic package. Thesize of each stack and the type of the stack elements
are provided as generic parameters.
generic
SIZE

POSITIVE;

type ITEM is private;
package STACK is
procedure PUSH(E : in ITEM);
procedure POP (E : out ITEM);
OVERFLOW,

end STACK;

UNDERFLOW

exception;

package body STACK is
type TABLE is array (POSITIVE range <>)
SPACE
INDEX

12-21

:
:

TABLE(1
NATURAL

of ITEM;

.. SIZE);
:= 0;

Example of a Generic Package

12.4

procedure PUSH(E : in ITEM)
begin
if INDEX >= SIZE then
raise OVERFLOW;

end if;
INDEX

INDEX +

SPACE (INDEX)

:= E;

end PUSH;

procedure POP(E : out ITEM)
begin
1f INDEX = 0 then
raise UNDERFLOW;

end if;
E := SPACE (INDEX);
INDEX := INDEX - 1;
end POP;
end STACK;

Instances of this generic package can be obtained as follows:
package STACKINT

is new STACK(SIZE => 200,

package STACK_BOOL is new STACK(100,

ITEM => INTEGER);

BOOLEAN) ;

Thereafter, the procedures of the instantiated packages can be called as
follows:

STACKINT.PUSH(N) ;
STACKBOOL.PUSH (TRUE) ;
5

Alternatively, a generic formulation of the type STACKcan be given as

follows (package body omitted):
generic
type ITEM is private;

package ONSTACKS is

type STACK(SIZE : POSITIVE)

procedure PUSH(S
procedure POP (S

OVERFLOW,
private

:
:

is limited private;

in out STACK;
in out STACK;

UNDERFLOW : exception;

E
E

:
:

in
ITEM);
out ITEM);

type TABLE is array (POSITIVE range <>)
type STACK(SIZE : POSITIVE) is

of ITEM;

record

SPACE : TABLE(1
INDEX : NATURAL
end record;

.. SIZE);
:= 0;

end;

12.4

Example of a Generic Package

12-22

In order to use such a package, an instantiation must be created and
thereafter stacks of the corresponding type can be declared:
declare
package STACKREAL is new ON_STACKS (REAL); use STACKREAL;
S

begin

STACK (100);

PUSH(S,

2.54);

end;

12-23

Example of a Generic Package

12.4

Chapter 13

Representation Clauses and
Implementation-Dependent Features
1

This chapter describes representation clauses, certain implementationdependent features, and other features that are used in system
programming.

13.1

Representation Clauses
1

Representation clauses specify how the types of the language are to be
mapped onto the underlying machine. They can be provided to give more

efficient representation or to interface with features that are outside the
domain of the language (for example, peripheral hardware).
representationclause ::=
typerepresentationclause

addressclause

typerepresentationclause ::= lengthclause
| enumerationrepresentationclause
| recordrepresentationclause

A type representation clause applies either to a type or to a first named

subtype (that is, to a subtype declared by a type declaration, the base

type being therefore anonymous). Such a representation clause applies to

all objects that have this type or this first named subtype. At most one

enumeration or record representation clause is allowed for a given type: an
enumeration representation clause is only allowed for an enumeration type;
a record representation clause, only for a record type. (On the other hand,

more than one length clause can be provided for a given type; moreover, both
a length clause and an enumeration or record representation clause can be
provided.) A length clause is the only form of representation clause allowed

13-1

Representation Clauses

13.1

for a type derived from a parent type that has (user-defined) derivable
subprograms.1
4

An address clause applies either to an object; to a subprogram, package,or

task unit; or to an entry. At most one addressclause is allowed for any of
these entities.

In VAX Ada, an address clause can apply only to an object. See section 13.5
for more information.
5

A representation clause and the declaration of the entity to which the
clause applies must both occur immediately within the same declarative
part, package specification, or task specification; the declaration must occur
before the clause. In the absence of a representation clause for a given

declaration, a default representation of this declaration is determined by
the implementation. Such a default determination occurs no later than the
end of the immediately enclosing declarative part, package specification, or
task specification. For a declaration given in a declarative part, this default
determination occurs before any enclosed body.
6

In the case of a type, certain occurrences of its name imply that the representation of the type must already have been determined. Consequently
these occurrences force the default determination of any aspect of the
representation not already determined by a prior type representation clause.
This default determination is also forced by similar occurrences of the name
of a subtype of the type, or of the name of any type or subtype that has
subcomponents of the type. A forcing occurrence is any occurrence other
than in a type or subtype declaration, a subprogram specification, an entry

declaration, a deferred constant declaration, a pragma, or a representation

clause for the typeitself. In any case, an occurrence within an expression is

always forcing.2

A representation clause for a given entity must not appear after an

occurrence of the nameof the entity if this occurrence forces a default
determination of representation for the entity.?
Similar restrictions exist for address clauses. For an object, any occurrence

of its name (after the object declaration) is a forcing occurrence. For a
subprogram, package, task unit, or entry, any occurrence of a representation
attribute of such an entity is a forcing occurrence.

The effect of the elaboration of a representation clause is to define the
corresponding aspects of the representation.

1 See also Appendix G, AI-00040, AI-00138, and AI-00422.
2 See also Appendix G, AI-00039, AI-00186, AI-00321, and AI-00322.

3 See also Appendix G, AI-00039 and AI-00371.
13.1.

Representation Clauses

13-2

The interpretation of some of the expressions that appear in representation
clauses is implementation-dependent, for example, expressions specifying

addresses. An implementation may limit its acceptance of representation

clauses to those that can be handled simply by the underlying hardware.

If a representation clause is accepted by an implementation, the compiler
must guarantee that the net effect of the program is not changed by the
presence of the clause, except for address clauses and for parts of the
program that interrogate representation attributes. If a program contains a
representation clause that is not accepted, the program is illegal. For each
implementation, the allowed representation clauses, and the conventions
used for implementation-dependent expressions, must be documented in
Appendix F of the reference manual.
The allowed representation clauses and the conventions used for
implementation-dependent expressions are documented in this chapter,
and are summarized in Appendix F.
Whereasa representation clause is used to impose certain characteristics
of the mapping of an entity onto the underlying machine, pragmas can be
used to provide an implementation with criteria for its selection of such a

mapping. The pragma PACK specifies that storage minimization should be
the main criterion whenselecting the representation of a record or array
type. Its form is as follows:
pragma PACK(typesimplename);

Packing means that gaps between the storage areas allocated to consecutive
components should be minimized. It need not, however, affect the mapping
of each component onto storage. This mapping can itself be influenced by
a pragma(or controlled by a representation clause) for the component or

component type. The position of a PACK pragma, andtherestrictions on the
named type, are governed by the samerules as for a representation clause;

in particular, the pragma must appear before any use of a representation

attribute of the packed entity.

The pragma PACKis the only language-defined representation pragma.
Additional representation pragmas may be provided by an implementation;
these must be documented in Appendix F. (In contrast to representation

clauses, a pragmathat is not accepted by the implementation is ignored.)
In VAX Ada,all array and record componentsare aligned on byte boundaries
by default; the effect of the pragma PACK ona recordorarrayis to cause
those components that are packable to be allocated in adjacent bits without
regard to byte boundaries. Whether any particular component is packable
dependson the rulesfor its type; the VAX Ada Run-Time Reference Manual

gives information on which types can be packed as components of composite
types, as well as information on how these types are packed.
13-3

Representation Clauses

13.1

VAX Ada provides no additional representation pragmas.
Note:

14.

No representation clause is allowed for a generic formaltype.
In addition, VAX Ada does not allow a representation clause for a type that
depends on a generic formal type. A type depends on a generic formal type
if it has a subcomponentof a generic formal type or a subcomponent that
depends on a generic formal type,or if it is derived from a generic formal

type or a type that depends on a generic formal type.
15

References: address clause 13.5, allow 1.6, body 3.9, component 3.3, declaration
3.1, declarative part 3.9, default expression 3.2.1, deferred constant declaration

7.4, derivable subprogram 3.4, derived type 3.4, entity 3.1, entry 9.5, enumeration
representation clause 13.3, expression 4.4, generic formal type 12.1.2, illegal 1.6,
length clause 13.2, must 1.6, name 4.1, object 3.2, occur immediately within

8.1, package 7, package specification 7.1, parent type 3.4, pragma 2.8, record
representation clause 13.4, representation attribute 13.7.2 13.7.3, subcomponent 3.3,
subprogram 6, subtype 3.8, subtype declaration 3.3.2, task specification 9.1, task
unit 9, type 3.3, type declaration 3.3.1
array 3.6, constant 3.2.1, record 3.7, variable 3.2.1, variant 3.7.3

13.2 Length Clauses
1

A length clause specifies an amount of storage associated with a type.

lengthclause ::= for attribute use simpleexpression; 4

The expression must be of some numeric type andis evaluated during the

elaboration of the length clause (unless it is a static expression). The prefix
of the attribute must denote either a type or a first named subtype. The
prefix is called T in what follows. The only allowed attribute designators in
a length clause are SIZE, STORAGE_SIZE, and SMALL. Theeffect of the

length clause depends on the attribute designator:
4
5

(a)

Size specification: T’ SIZE
The expression must be a static expression of some integer type. The

value of the expression specifies an upper bound for the numberof bits

to be allocated to objects of the type or first named subtype T. The size

specification must allow for enough storage space to accommodate every

allowable value of these objects. A size specification for a composite
type may affect the size of the gaps between the storage areas allocated
4 See also Appendix G, AI-00300.

13.2

Length Clauses

13-4

to consecutive components. On the other hand, it need not affect the

size of the storage area allocated to each component.

The size specification is only allowed if the constraints on T and on
its subcomponents (if any) are static. In the case of an unconstrained
array type, the index subtypes must alsobestatic.

In VAX Ada, for a discrete type, the given size must not exceed 32
(bits). The given size becomesthe default allocation for all objects and
components(in arrays and records) of that type.
For integer and enumeration types, the given size affects the internal
representation as follows: for integer types, high order bits are signextended; for enumeration types, the high order bits may be either
zero- or sign-extended depending upon the base representation that is
selected. For fixed point types, the given size affects the range (but
not the precision) of the underlying model numbers of the type; thatis,

the given size determines the value of B, which is described in section

3.5.9 (note that the given size may not equal the value of B because the
given size includes any sign bit and B does not).
Forall other types, the given size must equal the size that would apply
in the absence of a size specification.

(b)

Specification of collection size: T’ STORAGE_SIZE
The prefix T must denote an access type. The expression must be

of some integer type (but need not be static); its value specifiesthe
numberof storage units to be reserved for the collection, that is, the

storage space neededto contain all objects designated by values of the
access type and by values of other types derived from the accesstype,
directly or indirectly. This form of length clause is not allowed for a

type derived from an access type.

In VAX Ada, the specification of a collection size is interpreted as
follows. If the value of the expression is greater than zero, the specified
size (representing the numberofbytesin the collection) is rounded up
to the next integral number of pages (where one page is 512 bytes),
and is then usedastheinitial size for the collection; the collection is
not extended should that initial allocation be exhausted. If the valueis
equal to zero, no storageis initially allocated for the collection; storage
is allocated as needed, until all virtual memoryis depleted. (This is the
default behavior in the absence of a length clause.) If the value is less

than zero, the exception CONSTRAINT_ERRORisraised.

(c)

13-5

Specification of storage for a task activation: T’ STORAGE_SIZE

Length Clauses

13.2

The prefix T must denote a task type. The expression must be of some
integer type (but need not bestatic); its value specifies the number of

storage units to be reserved for an activation (not the code) of a task of
the type.

In VAX Ada, the specification of storage for a task activation is
interpreted as follows. If the value of the expression is greater than
zero, the specified storage (in bytes) is rounded up to the next integral
number of pages (where one page is 512 bytes), and then is used as the
amountof storage to be allocated for an activation of a task of the given
type. If the value is equal to zero, a default allocation is used (this is
the default behavior in the absence of a length clause). In both cases,
the task activation storage is fixed and is not extendedif theinitial
allocation is exhausted. If the valueis less than zero, the exception
CONSTRAINT_ERRORisraised.
The storage allocation for a task may also be affected by the pragmas
TASK_STORAGE(see 13.2a) and MAIN_STORAGE(see 13.2b); see

also the VAX Ada Run-Time Reference Manual.

11
12.

(d)

Specification of small for a fixed point type: T’7 SMALL
The prefix T must denote the first named subtype of a fixed point
type. The expression must be a static expression of somereal type; its
value must not be greater than the delta of the first named subtype.

The effect of the length clause is to use this value of small for the
representation of values of the fixed point base type. (The length clause
thereby also affects the amountof storage for objects that havethis
type.)
In VAX Ada, the value of small in a fixed point representation clause
must be 2.0" such that -62 <= n <= 31. For example:
type MYFIXED is delta 0.1 range 0.0
for MYFIXED’ SMALL use 0.03125;

1.0;

This exampleis a legal specification for the declaration of MY_FIXED
because the value specified for small (0.03125) is a powerof two (2.0~°)
that is less than the delta (0.1) and that also satisfies the specified
range (0.0..1.0).

5 See also Appendix G, AI-00099.
13.2

Length Clauses

13-6

Notes:
A size specification is allowed for an access, task, or fixed point type,

whether or not another form of length clause is also given for the type.

Whatis considered to be part of the storage reserved for a collection orfor
an activation of a task is implementation-dependent. The control afforded by
length clauses is therefore relative to the implementation conventions. For

example, the language does not define whether the storage reserved for an

activation of a task includes any storage neededfor the collection associated

with an access type declared within the task body. Neither does it define

the methodof allocation for objects denoted by values of an access type. For
example, the space allocated could be on a stack; alternatively, a general
dynamic allocation schemeor fixed storage could be used.

The VAX Ada Run-Time Reference Manual discusses task and access type
storage and storage allocation in more detail.
The objects allocated in a collection need not have the samesize if the

designated type is an unconstrained array type or an unconstrained type

with discriminants. Note also that the allocator itself may require some

space for internal tables and links. Hence a length clause for the collection

of an access type does not always give precise control over the maximum

numberof allocated objects.

Examples:
--

assumed declarations:

type MEDIUM is range 0 .. 65000;
type SHORT is delta 0.01 range -100.0
type DEGREE is delta 0.1
range -360.0
BYTE
PAGE

:
:

constant
constant

..
..

100.0;
360.0;

:= 8;
2000;

length clauses:

for

COLOR’SIZE

use

1*BYTE;

see

3.5.1

for MEDIUM’ SIZE use 2*BYTE;
for SHORT’SIZE
use 15;

for CARNAME’ STORAGESIZE use

approximately 2000 cars

2000* ((CAR’ SIZE/SYSTEM.STORAGEUNIT)

+ 1);

for KEYBOARDDRIVER’ STORAGESIZE use 1*PAGE;
for DEGREE’ SMALL use 360.0/2** (SYSTEM.STORAGEUNIT - 1);

13-7

Length Clauses

13.2

17.

Notes on the examples:
In the length clause for SHORT, fifteen bits is the minimum neces-

sary, since the type definition requires SHORT’ SMALL = 2.0~" and
SHORT’ MANTISSA = 14. The length clause for DEGREE forces the model
numbers to exactly span the rangeof the type.
18

References: access type 3.8, allocator 4.8, allow 1.6, array type 3.6, attribute
4.1.4, collection 3.8, composite type 3.3, constraint 3.3, delta of a fixed point type
3.5.9, derived type 3.4, designate 3.8, elaboration 3.9, entity 3.1, evaluation 4.5,
expression 4.4, first named subtype 13.1, fixed point type 3.5.9, index subtype 3.6,
integer type 3.5.4, must 1.6, numeric type 3.5, object 3.2, real type 3.5.6, record type
3.7, small of a fixed point type 3.5.10, static constraint 4.9, static expression 4.9,
static subtype 4.9, storage unit 13.7, subcomponent 3.3, system package 13.7, task
9, task activation 9.3, task specification 9.1, task type 9.2, type 3.3, unconstrained

array type 3.6

component 3.6 3.7, constraint_error exception 11.1, discrete type 3.5, enumeration
type 3.5.1, fixed point type declaration 3.5.9, length clause 13.2, object 3.2, pragma
task_storage 13.2a, range of a fixed point type 3.5.9, representation clause 13.1

13.2a Pragma TASK_STORAGE
VAX Ada provides the pragma TASK_STORAGEto allow the specification
of additional storage, called guard pages, for each task activation. (Guard
pages provide protection against storage overflow during task execution
of non-Ada code; see the VAX Ada Run-Time Reference Manual for more
information.) The form of this pragmais as follows:

pragma TASKSTORAGE ([TASKTYPE =>] simplename,
[TOPGUARD =>] staticsimpleexpression) ;

The simple expression must be a static expression of some integer type; its
value specifies the additional numberof storage units (bytes) to be allocated
as guard pages. The value is rounded up to an integral number of pages
(one page is 512 bytes). If the value is zero, no guard storage is provided;
if the value is less than zero, the pragma is ignored and a default guard
storage size is used (see the VAX Ada Run-Time Reference Manual).
A pragma TASK_STORAGEis allowed anywhere that a task storage size
specification is allowed for the named task type. In other words, the pragma
and the declaration of the task type to which the pragmaapplies must both
occur immediately within the same declarative part or package specification;
the type declaration must occur before the pragma. However, a pragma
TASK_STORAGE mayprecedeor follow any existing task storage size
specification.

13.2a

Pragma TASK_STORAGE

13-8

Example:
-- guard size will be 3 pages; activation size
--

(storage size)

will be the default

task type EVENGUARD is

end EVENGUARD;
pragma TASKSTORAGE (TASKTYPE => EVENGUARD,
TOPGUARD => 3*512);
-- guard size will be 2 pages (rounded up);
-- activation size (storage size) will be 10 pages

task type ROUNDIT is

end ROUND_IT;
pragma TASKSTORAGE (TASK_TYPE => ROUND_IT,
TOPGUARD => 1000);
for ROUNDIT’ STORAGESIZE use 10*512;
References: allow 1.6, declarative part 3.9, integer type 3.5.4, package specification 7.1, pragma 2.8, simple expression 4.9, simple name 4.1, static expression 4.9,
storage unit 13.7, task activation 9.3, task storage size specification 13.2, task type
9.2, task type declaration 9.1

13.26 Pragma MAINSTORAGE
VAX Ada provides the pragma MAIN_STORAGEto allow a fixed-size stack
and stack storage areas to be specified for the environment, or main, task
(the task associated with a main program). The storage areas that can be
specified are the working storage for the task activation and additional
storage, or guard pages, to provide protection against storage overflow

during task execution of non-Ada code. The form of this pragmais as
follows:
pragma MAINSTORAGE(

mainstorageoption [, main_storageoption]));

mainstorageoption :=
[WORKINGSTORAGE => ] staticsimpleexpression
| ([TOP_GUARD => ] static_simple_expression

The simple expression given for a main storage option must be a nonnegative
static expression of some integer type; its value specifies either the number
of storage units (bytes) to be allocated for the main task stack working
storage area or the numberof storage units to be allocated as guard pages.
If positional association is used, the first or only option is the working
storage option; the second option is the top guard option.

13-9

Pragma MAIN_STORAGE

13.2b

For both WORKING_STORAGE and TOP_GUARD,the value specified is
rounded up to an integral number of pages (where one page is 512 bytes).
If the value is zero for WORKING_STORAGE,a default size is assumed;
if the value is zero for TOP_GUARD,no guard pagesare provided. If the

value is less than zero for either WORKING_STORAGE or TOP_GUARD,

the pragmais ignored.

A pragma MAIN_STORAGEis only allowed in the outermost declarative
part of a library subprogram; at most one such pragmais allowed for a
subprogram. This pragmahasan effect only when the subprogram to which
it applies is used as a main program.
On the VMSoperating system, use of this pragma causes the main stack to
be allocated in PO space (rather than in the default P1 space); see the VAX
Ada Run-Time Reference Manual for more information.
Example:
procedure MAINPROGRAM is
pragma MAINSTORAGE

begin

(WORKINGSTORAGE => 10*512,
TOPGUARD
=> 1000);

end MAINPROGRAM;

In this example, the working storage for procedure MAIN_PROGRAM will
be 10 pages; the guard storage will be 2 pages (1000 bytes rounds up to
2*512 bytes). The stack for the environment task associated with procedure

MAIN_PROGRAM will be fixed, and, if the procedure is run on a VMS

system, the stack will be allocated in PO space.

References: allow 1.6, declarative part 3.9, environment task 10.1, integer
type 3.5.4, library unit 10.1, main program 10.1, positional parameter association
6.4, pragma 2.8, simple expression 4.4, static expression 4.9, storage unit 13.7,
subprogram 6

13.3

Enumeration Representation Clauses
1
2

An enumeration representation clause specifies the internal codes for the
literals of the enumeration type that is namedin theclause.
enumerationrepresentationclause ::=
for typesimplename use aggregate; ©

6 See also Appendix G, AI-00422.

13.3.

Enumeration Representation Clauses

13-10

The aggregate used to specify this mapping is written as a one-dimensional

aggregate, for which the index subtype is the enumeration type and the

component type is wniversal_integer.

All literals of the enumeration type must be provided with distinct integer

codes, and all choices and component values given in the aggregate must be

static. The integer codes specified for the enumeration type mustsatisfy the

predefined ordering relation of the type.

In VAX Ada, each component value for an integer code must have a value
in the range MIN_INT..MAX_INT (that is, each component value must be
able to be represented as a 32-bit signed longword). Signed representation is
used if any value given in an enumeration representation clause is negative.
5

Example:
type MIXCODE is (ADD, SUB, MUL, LDA, STA, STZ);
for MIXCODE use
(ADD => 1, SUB => 2,
LDA => 8, STA => 24,

MUL => 3,
STZ => 33);

Notes:
6

The attributes SUCC, PRED, and POS are defined even for enumeration

types with a noncontiguous representation; their definition corresponds
to the (logical) type declaration and is not affected by the enumeration
representation clause. In the example, because of the need to avoid the
omitted values, these functionsarelikely to be less efficiently implemented
than they could be in the absence of a representation clause. Similar
considerations apply when such types are used for indexing.

References: aggregate 4.3, array aggregate 4.3.2, array type 3.6, attribute of
an enumeration type 3.5.5, choice 3.7.3, component 3.3, enumeration literal 3.5.1,

enumeration type 3.5.1, function 6.5, index 3.6, index subtype 3.6, literal 4.2,

ordering relation of an enumeration type 3.5.1, representation clause 13.1, simple
name 4.1, static expression 4.9, type 3.3, type declaration 3.3.1, universal_integer
type 3.5.4
system.max_int 13.7, system.min_int 13.7

13.4

Record Representation Clauses
1

A record representation clause specifies the storage representation of

records, that is, the order, position, and size of record components (including

discriminants, if any).

13-11

Record Representation Clauses

13.4

recordrepresentationclause ::=
for typesimplename use
record [alignment_clause]

{componentclause}

end record;

alignmentclause ::= at mod static simpleexpression;
componentclause ::=
componentname at static_simpleexpression
range staticrange; /

The simple expression given after the reserved words at mod in an

alignmentclause, or after the reserved word at in a component clause, must

be a static expression of some integer type. If the boundsof the range of a
component clause are defined by simple expressions, then each boundof the
range must be defined by a static expression of some integer type, but the
two bounds need not have the same integer type.
4

An alignment clause forces each record of the given type to be allocated at a
starting address that is a multiple of the value of the given expression (that
is, the address modulo the expression must be zero). An implementation
may place restrictions on the allowable alignments.
VAX Adaallows the simple expression in an alignment clause to have a
value of 2", where 0 <= n <= 9. In other words, the simple expression must
be an integer in the range 1..512 that is also a powerof 2; the alignment
then occurs at a location that is a number of bytes times the value of
the simple expression (a value of 2 would cause word alignment, a value
of 4 would cause longword alignment, and so on). The following further
restrictions on the resulting alignment depend on how the objects of the
given record type are allocated:
e
¢

For statically allocated record objects, there are no otherrestrictions; the
specified alignment is observed.
For stack-allocated record objects, the alignment is restricted to a

maximum of 2", where n <= 2. In other words, stack-allocated records

can only be byte-, word-, or longword-aligned.

For dynamically allocated record objects, there are no other restrictions;
the specified alignment is observed. (Dynamically allocated objects are
always at least longword-aligned; n = 2.)

See the VAX Ada Run-Time Reference Manualfor information on how objects
are allocated.

7 See also Appendix G, AI-00422.
13.4

Record Representation Clauses

13-12

A component clause specifies the storage place of a component, relative

to the start of the record. The integer defined by the static expression
of a component clause is a relative address expressed in storage units.
The range defines the bit positions of the storage place, relative to the
storage unit. The first storage unit of a record is numbered zero. The

first bit of a storage unit is numbered zero. The ordering of bits in a

storage unit is machine-dependent and may extend to adjacent storage
units. (For a specific machine, the size in bits of a storage unit is given by
the configuration-dependent named number SYSTEM.STORAGE_UNIT.)
Whether a componentis allowed to overlap a storage boundary, andif so,

how, is implementation-defined.

In VAX Ada, the size of a storage unit (SYSTEM.STORAGE_UNIT)is eight
bits (one byte). If the numberof bits specified by the range is sufficient
for the component subtype, the requested size and placementof the field
is observed (and overlaps storage boundaries if necessary); otherwise, the
specification is illegal. For a component of a discrete type, the number
of bits must be between 1 and 32; for a component of any other type, the
size must not exceed the actual size of the component. See the VAX Ada
Run-Time Reference Manual for information about determining the number
of bits that are sufficient for any given subtype.
In VAX Ada, component values may be biased when a componentclause
requires a very small component storage space; each value stored is the
unsigned quantity formed by subtracting COMPONENT_SUBTYPE’ FIRST
from the original value. Biasing is not applied to components of fixed point
types. See the VAX Ada Run-Time Reference Manual for more information.
Component clauses in VAX Adaarerestricted as follows. Any component
that is not packable must be allocated on a byte boundary. Components
that are packable can be allocated without restriction. See the VAX Ada
Run-Time Reference Manual for a definition and description of packable
components.

At most one componentclause is allowed for each component of the record
type, including for each discriminant (component clauses may be given for

some, all, or none of the components). If no component clauseis given for a
component, then the choice of the storage place for the componentis left to
the compiler. If component clauses are given for all components, the record
representation clause completely specifies the representation of the record

type and must be obeyed exactly by the compiler.

In VAX Ada, components named in a componentclause areallocatedfirst;
then, unnamed componentsareallocated in the order in which they are
written in the record type declaration. Variants can be overlapped. If the

13-13

Record Representation Clauses

13.4

pragma PACKisspecified, packed allocation rules (see 13.1) are used;
otherwise, unpacked allocation is used.
Storage places within a record variant must not overlap, but overlap of

the storage for distinct variants is allowed. Each component clause must
allow for enough storage space to accommodate every allowable value of

the component. A componentclause is only allowed for a componentif any
constraint on this componentor on anyof its subcomponentsis static.®

An implementation may generate names that denote implementationdependent components (for example, one containing the offset of another
component). Such implementation-dependent names can be used in record
representation clauses (these names need not be simple names; for example,
they could be implementation-dependentattributes).
VAX Ada generates no implementation-dependent components or names.
Example:
WORD

constant

type STATE
type MODE

:= 4;
is
is

-~-

storage unit is byte,
4 bytes per word

(A, M, W, P);
(FIX, DEC, EXP,

SIGNIF);

type BYTEMASK is array (0 .. 7)
type STATEMASK is array (STATE)

o£ BOOLEAN;
of BOOLEAN;

type MODEMASK

of BOOLEAN;

is array

(MODE)

pragma PACK (BYTEMASK);
-- in VAX Ada these must be packed
pragma PACK (STATEMASK); -- for the alignment to work
pragma PACK

(MODEMASK);

type PROGRAMSTATUSWORD is
record
SYSTEMMASK

BYTEMASK;

MACHINESTATE
INTERRUPTCAUSE

>;
:

STATEMASK;
INTERRUPTIONCODE;

PROTECTIONKEY

INTEGER range 0

ILC
CC

:
:

INSTADDRESS

: ADDRESS;

PROGRAMMASK
end record;

INTEGER range 0
INTEGER range 0

MODEMASK;

.. 3;
.. 3;

8 See also Appendix G, AI-00132.
13.4

Record Representation Clauses

13-14

for PROGRAMSTATUSWORD use

record at mod 8;
SYSTEMMASK

PROTECTIONKEY

at O*WORD range 0...

at O*WORD range 10

MACHINESTATE
at O*WORD range 12 ..
INTERRUPTCAUSE at O*WORD range 16 ..
ILC
at 1*WORD range 0...

CC
PROGRAMMASK
INSTADDRESS

at 1*WORD range 2
at 1*WORD range 4
at 1*WORD range 8

-- bits 8,9

15;
31;
1;

-- second word

11;

3;
7;
31;

-- unused

end record;
for PROGRAMSTATUSWORD’SIZE use 8*SYSTEM.STORAGEUNIT;

Note on the example:
The record representation clause defines the record layout. The length
clause guarantees that exactly eight storage units are used.
The example assumes that type ADDRESSis represented in 24 bits; in VAX
Ada, type ADDRESSis represented in 32 bits.
ComponentSpecification Example:
subtype S is INTEGER range 10

13;

type REC is
record
X : S;
Y : S;
424: S;
end record;
for REC use

record
X at 0 range 0

-- legal: 4 bits are sufficient for
-- an unsigned representation

Y at 0 range 5...

-- legal: 2 bits are sufficient for
-- a biased representation

.. 7;

=-- illegal: 1 bit is not enough to
-- represent an integer of subtype S

Z at 0 range 7
end record;

Notes on the example:
The subtype declaration in this example implies an integer with a minimum
size of 4 bits. The component clause for X is legal because it requires at
least the minimum numberof bits required for the integer subtype. The
componentclause for Y is legal because it requires at least the minimum
numberof bits required for a biased representation of the subtype. The

13-15

Record Representation Clauses

13.4

componentclause for Z is illegal because it does not allow enough bits to
represent the integer subtype.
1

References: allow 1.6, attribute 4.1.4, constant 3.2.1, constraint 3.3, discriminant
3.7.1, integer type 3.5.4, must 1.6, named number3.2, range 3.5, record component

3.7, record type 3.7, simple expression 4.4, simple name4.1, static constraint 4.9,

static expression 4.9, storage unit 13.7, subcomponent 3.3, system package 13.7,

variant 3.7.3

component clause 13.4, component subtype 3.7, object 3.2, packable 13.1, pragma
pack 13.1

13.5

Address Clauses
An address clause specifies a required address in storage for an entity.
addressclause ::= for simplename use at simpleexpression;

1
3

The expression given after the reserved word at must be of the type
ADDRESSdefined in the package SYSTEM (see 13.7); this package must
be named by a with clause that applies to the compilation unit in which

the address clause occurs. The conventions that define the interpretation
of a value of the type ADDRESS as an address, as an interrupt level, or
whatever it may be, are implementation-dependent. The allowed nature
of the simple name and the meaning of the corresponding address are as

follows:
4

(a)

Nameof an object: the address is that required for the object (variable

(b)

Nameof a subprogram, package, or task unit: the address is that
required for the machine code associated with the body of the program

or constant).

unit.
6

(c)

Nameof a single entry: the address specifies a hardware interrupt to

If the simple nameis that of a single task, the address clause is understood
to refer to the task unit and not to the task object. In all cases, the address
clause is only legal if exactly one declaration with this identifier occurs
earlier, immediately within the same declarative part, package specification,
or task specification. A name declared by a renaming declaration is not
allowed as the simple name.

which the single entry is to be linked.

9 See also Appendix G, AI-00263.
10 See also Appendix G, AI-00336.
13.5

Address Clauses

13-16

In VAX Ada, the simple name must be the nameof an object. A related
capability for entries is provided for handling VMS asynchronous system
traps (ASTs). See the discussion of the pragma AST_ENTRY and the
AST_ENTRYattribute in section 9.12a.
Address clauses are not allowed in combination with any of the VAX Ada

pragmasfor importing or exporting objects. If used in such cases, the
pragmainvolvedis ignored.

Address clauses should not be used to achieve overlays of objects or overlays
of program units. Nor should a given interrupt be linked to more than
one entry. Any program using address clauses to achieve such effects is
erroneous.!1

Example:
for CONTROL use at 16#0020#;

---

assuming that SYSTEM.ADDRESS
is an integer type

Notes:

The above rules imply that if two subprograms overload each other and are
visible at a given point, an address clause for any of them is not legal at
this point. Similarly if a task specification declares entries that overload
each other, they cannot be interrupt entries. The syntax does not allow an
addressclause for a library unit. An implementation may provide pragmas

for the specification of program overlays.

Note that the usual implicit initialization associated with a type is performed, even when an object of the type is declared with an addressclause.
For example, access valuesare initialized to null, and record components

may also receive initial values. See the VAX Ada Run-Time Reference
Manualfor more information.

If an address clause is specified for an object whose type has been declared
with an alignmentclause, the alignment required for the address is checked
against the alignment given for the record type. If the two are incompatible,
the exception PROGRAM_ERRORisraised.

The same check applies to a type that contains a component whose type has
been declared with an alignment clause (the alignment of the component
forces the alignmentof the containing type).

11 See also Appendix G, AI-00292 and AI-00379.
13-17

Address Clauses

13.5

References: address predefined type 13.7, apply 10.1.1, compilation unit 10.1,

constant 3.2.1, entity 3.1, entry 9.5, erroneous 1.6, expression 4.4, library unit 10.1,
name 4.1, object 3.2, package 7, pragma 2.8, program unit 6, reserved word 2.9,

simple expression 4.4, simple name 4.1, subprogram 6, subprogram body 6.3, system —

package 13.7, task body 9.1, task object 9.2, task unit 9, type 3.3, variable 3.2.1,
with clause 10.1.1

declarative part 3.9, forcing occurrence 13.1, package specification 7.1

13.5.1.

Interrupts
VAX Ada does not support interrupts as defined in this section. VAX Ada
does provide the pragma AST_ENTRY and the AST_ENTRYattribute as
alternative mechanismsfor handling asynchronousinterrupts from the VMS
operating system. See section 9.12a for more information on this pragma
and attribute.
1

An addressclause given for an entry associates the entry with some device
that may cause an interrupt; such an entry is referred to in this section as

an interrupt entry. If control information is supplied upon an interrupt, it is
passed to an associated interrupt entry as one or more parameters of mode
in; only parameters of this mode are allowed.

An interrupt acts as an entry call issued by a hardware task whosepriority

is higher than the priority of the main program, andalso higher than the
priority of any user-defined task (that is, any task whose type is declared
by a task unit in the program). The entry call may be an ordinary entry

call, a timed entry call, or a conditional entry call, depending on the kind of
interrupt and on the implementation.
3

If a select statement contains both a terminate alternative and an accept

alternative for an interrupt entry, then an implementation may impose
further requirements for the selection of the terminate alternative in
addition to those given in section 9.4.
Example:
task INTERRUPTHANDLER is
entry DONE;

for DONE use at 16#40#;

-- assuming that SYSTEM.ADDRESS
-- is an integer type

end INTERRUPTHANDLER;

13.5.1.

Interrupts

13-18

Notes:
5

Interrupt entry calls need only have the semantics described above; they

may be implemented by having the hardware directly execute the appropriate accept statements.

Queued interrupts correspond to ordinary entry calls. Interrupts that are

lost if not immediately processed correspond to conditional entry calls. It

is a consequence of the priority rules that an accept statement executed in

response to an interrupt takes precedence over ordinary, user-defined tasks,

and can be executed withoutfirst invoking a scheduling action.

Oneof the possible effects of an address clause for an interrupt entry is to

specify the priority of the interrupt (directly or indirectly). Direct calls to an
interrupt entry are allowed.
References: accept alternative 9.7.1, accept statement 9.5, address predefined
type 13.7, allow 1.6, conditional entry call 9.7.2, entry 9.5, entry call 9.5, mode 6.1,
parameter of a subprogram 6.2, priority of a task 9.8, select alternative 9.7.1, select
statement 9.7, system package 13.7, task 9, terminate alternative 9.7.1, timed entry
call 9.7.3

13.6 Change of Representation
1

At most one representation clause is allowed for a given type and a given
aspect of its representation. Hence, if an alternative representation is

needed, it is necessary to declare a second type, derived from the first, and
to specify a different representation for the second type:

Example:
-~---

PACKEDDESCRIPTOR and DESCRIPTOR are two different
types with identical characteristics, apart from
their representation

type DESCRIPTOR is
record
-components of a descriptor
end record;
type PACKEDDESCRIPTOR is new DESCRIPTOR;
for PACKEDDESCRIPTOR use

record
--

component clauses

end record;

for some or for all components

12 See also Appendix G, AI-00040 and AI-00138.
13-19

Change of Representation

13.6

Change of representation can now be accomplished by assignment with
explicit type conversions:
D
P
P
D

;

DESCRIPTOR;
PACKEDDESCRIPTOR;

PACKEDDESCRIPTOR(D);
\|

DESCRIPTOR (P) ;

-- pack D

unpack P

References: assignment 5.2, derived type 3.4, type 3.3, type conversion 4.6, type
declaration 3.1, representation clause 13.1

13.7 The Package System
1

For each implementation there is a predefined library package called
SYSTEM which includes the definitions of certain configurationdependent characteristics. The specification of the package SYSTEM is
implementation-dependent and must be given in Appendix F. The visible
part of this package must contain at least the following declarations.
VAX Ada additions to the package SYSTEM are described in section 13.7a
and are included in the complete specification of the package SYSTEM in
Appendix F.

package SYSTEM is
|
type ADDRESS is implementationdefined;
type NAME
is implementationdefined_enumerationtype;

SYSTEMNAME

: constant NAME := implementationdefined;

STORAGEUNIT : constant := implementationdefined;

MEMORYSIZE
--

: constant

:= implementation_defined;

System-Dependent Named Numbers:

MIN_INT

MAXINT
MAXDIGITS

: constant := implementation_defined;

: constant := implementationdefined;
: constant := implementation_defined;

MAXMANTISSA : constant := implementation_defined;
FINEDELTA

TICK
--

: constant := implementationdefined;

: constant := implementation_defined;

Other System-Dependent Declarations

subtype PRIORITY is INTEGER range implementation_defined;
end SYSTEM; 13

13 See also Appendix G, AI-00045 and AI-00355.
13.7

The Package System

13-20

The type ADDRESSis the type of the addresses provided in addressclauses;
it is also the type of the result delivered by the attribute ADDRESS. Values
of the enumeration type NAMEare the namesof alternative machine
configurations handled by the implementation; one of these is the constant
SYSTEMNAME. The named number STORAGE_UNITis the numberof

bits per storage unit; the named number MEMORY_SIZE is the number of
available storage units in the configuration; these named numbersare of the
type universal_integer.

In VAX Ada, values of the type ADDRESSrefer to addresses in VAX address
space.
An alternative form of the package SYSTEM,with given values for any of
SYSTEM_NAME, STORAGE_UNIT, and MEMORY_SIZE,can be obtained
by meansof the corresponding pragmas. These pragmasare only allowed

at the start of a compilation, before the first compilation unit (if any) of the

compilation.

pragma SYSTEMNAME (enumerationliteral);

The effect of the above pragmais to use the enumeration literal with the

specified identifier for the definition of the constant SYSTEM_NAME. This

pragmais only allowed if the specified identifier corresponds to one of the
literals of the type NAME.
In VAX Ada, the enumeration literal for SYSTEM_NAME maybeeither
VAX_VMSor VAXELN.
pragma STORAGEUNIT(numericliteral);

The effect of the above pragmais to use the value of the specified numeric
literal for the definition of the named number STORAGE_UNIT.

In VAX Ada, the value given for STORAGE_UNIT mustbe 8 (bits).
pragma MEMORYSIZE(numericliteral);

The effect of the above pragmais to use the value of the specified numeric
literal for the definition of the named number MEMORY_SIZE.
In VAX Ada, the number given for MEMORY_SIZE mustbein the range
0..MAX_INT; it replaces the default value (MAX_INT). VAX Ada does not
provide support for checking or ensuring that the given size is not exceeded.
11

13-21

The compilation of any of these pragmas causes an implicit recompilation
of the package SYSTEM. Consequently any compilation unit that names
SYSTEM in its context clause becomesobsolete after this implicit recompilation. An implementation may impose further limitations on the use of these
pragmas. For example, an implementation may allow them only at the start
of the first compilation, when creating a new program library.
The Package System

13.7

VAX Ada imposes nofurther limitations on these pragmas. To reduce the
amount of recompilation required, VAX Ada identifies those units that
have a real dependence on the values affected by these pragmas; only such
units must be recompiled. In particular, predefined VAX Ada packages do
not depend on the values affected by these pragmas, and none requires
recompilation if these pragmasare used.
Note:
12

It is a consequence of the visibility rules that a declaration given in the

package SYSTEM is not visible in a compilation unit unless this package

is mentioned by a with clause that applies (directly or indirectly) to the

compilation unit.

References: address clause 13.5, apply 10.1.1, attribute 4.1.4, compilation unit
10.1, declaration 3.1, enumeration literal 3.5.1, enumeration type 3.5.1, identifier

2.3, library unit 10.1, must 1.6, named number 3.2, number declaration 3.2.2,
numeric literal 2.4, package 7, package specification 7.1, pragma 2.8, program
library 10.1, type 3.3, visibility 8.3, visible part 7.2, with clause 10.1.1

dependence between compilation units 10.3, erroneous 1.6, exception 11, expression
4.4, integer type 3.5.4, range 3.5, system.max_int 13.7

13.7.1

System-Dependent Named Numbers
1

Within the package SYSTEM,the following named numbersare declared.
The numbers FINE_DELTA and TICKare of the type uwniversal_real; the
others are of the type universal_integer.

MIN_INT

The smallest (most negative) value of all predefined
integer types.

In VAX Ada, the value for MIN_INT is —22!.
MAX_INT

The largest (most positive) value of all predefined
integer types.

In VAX Ada, the value for MAX_INT is 231 — 1.
MAX_DIGITS

The largest value allowed for the numberof significant
decimal digits in a floating point constraint.

In VAX Ada, the value for MAX_DIGITSis 33.

MAXMANTISSA

The largest possible number of binary digits in the
mantissa of model numbersof a fixed point subtype.
In VAX Ada, the value for MAXMANTISSAis 31.

13.7.1

system-Dependent Named Numbers

13-22

FINE_DELTA

The smallest delta allowed in a fixed point constraint
that has the range constraint —1.0.. 1.0.

In VAX Ada,the value for FINE_DELTAis 2.0—3!,
7

TICK

The basic clock period, in seconds. !4

In VAX Ada, the value for TICK is 10.072 (or 10
milliseconds). This value corresponds to the clock
interval provided by the time-related VMS system
services.
8

References: allow 1.6, delta of a fixed point constraint 3.5.9, fixed point constraint

3.5.9, floating point constraint 3.5.7, integer type 3.5.4, model number3.5.6,

named number 3.2, package 7, range constraint 3.5, system package 13.7, type 3.3,
universal_integer type 3.5.4, universal_real type 3.5.6

13.7.2

Representation Attributes
1

The values of certain implementation-dependent characteristics can be
obtained by interrogating appropriate representation attributes. These

attributes are described below.

For any object, program unit, label, or entry X:

X’ ADDRESS

Yields the address of the first of the storage units
allocated to X. For a subprogram, package, task unit or
label, this value refers to the machine code associated

with the corresponding body or statement. For an entry
for which an address clause has been given, the value
refers to the corresponding hardware interrupt. The

value of this attribute is of the type ADDRESSdefined

in the package SYSTEM. !°

For an object that is a variable in VAX Ada, the value
is the actual address of the variable (which may be
statically or dynamically allocated). This attribute
forces a variable to be allocated in memory rather than
in a register, and causes the variable to be marked
as volatile for the duration of the block statement or
body containing the useof the attribute. If the location
of the variable is not byte-aligned, the valueis the
address of the lowest byte that holds part orall of the
variable. For an object that is a constant, the valueis
14 See also Appendix G, AI-00201 and AI-00366.
15 See also Appendix G, AI-00305.
13-23

Representation Attributes

13.7.2

the address of the constant value in memory; however,
two occurrences of C’- ADDRESS, where C denotes a

constant, may or may not yield the same addressvalue.
For an object that is a named number, the value is zero
(ADDRESS_ZERO).

For an access object, X.all’ ADDRESSis the address
of the designated object; X.all’ ADDRESSis subject

to an ACCESS_CHECKfor the designated object. For

a record component, X.C’ ADDRESSis subject to a
DISCRIMINANT_CHECKfor an object in a variant
part. For an array componentorslice, X(I)’ ADDRESS
or X(I1..I2); ADDRESSis subject to an INDEX_CHECK
for the denoted componentorslice.
For program units that are generic units, task units,
or package units, the value is zero (ADDRESS_ZERO).
For program units that are imported or exported
subprograms, the value is the sameas the address
that is imported or exported. (See section 13.9a.1.1
for information on the pragmas IMPORT_FUNCTION,
IMPORT_PROCEDURE, and IMPORT_VALUED_
PROCEDURE; see section 13.9a.1.4 for information
on the pragmas EXPORT_FUNCTION, EXPORT_
PROCEDURE, and EXPORT_VALUED_PROCEDURE.)
The value is zero (ADDRESS_ZERO)for subprograms
that are not imported or exported.
For labels or entries, the value is zero (ADDRESS_
ZERO).
4

For any type or subtype X, or for any object X:

X’ SIZE

Applied to an object, yields the numberof bits allocated
to hold the object. Applied to a type or subtype, yields
the minimum numberof bits that is needed by the
implementation to hold any possible object of this type
or subtype. The value of this attribute is of the type
universal_integer.

For a type or a subtype in VAX Ada, the valueis limited
to values in the range 0..MAX_INT; the exception
CONSTRAINT_ERROR(see 11.1) is raised for values
outside this range. For an object that is a variable or
a constant in VAX Ada, the value is its size in bits.

For an object that is a named number, the value is
zero. For a record component, X.C’ SIZE is subject to
13.7.2

Representation Attributes

13-24

a DISCRIMINANT_CHECKfor an object in a variant
part. For an array componentorslice, X(I)’ SIZE or
X(I1..12)’ SIZE is subject to an INDEX_CHECKfor the
denoted componentorslice.
6

For the above two representation attributes, if the prefix is the name of a

function, the attribute is understood to be an attribute of the function (not

of the result of calling the function). Similarly, if the type of the prefix is an
access type, the attribute is understood to be an attribute of the prefix (not

of the designated object: attributes of the latter can be written with a prefix

ending with the reserved wordall). 1°
For any type or subtype X:

X’' MACHINE_SIZEYields the total number of machine bits to be allocated

for objects of the type or subtype. This value takes
into account any padding bits used by VAX Ada when
allocating storage for an object. The value of this
attribute is of the type universal_integer.

The value is always a multiple of eight (bits). The
value is limited to the range 0..MAX_INT; the exception
CONSTRAINT_ERRORis raised for values outside this
range.
See the VAX Ada Run-Time Reference Manual for
additional discussion of this attribute and for more

information on VAX Adastorage allocation.
For any object X:
X’ BIT

Yields the bit offset within the storage unit (byte)
that contains thefirst bit of the storage allocated for
the object. The value of this attribute is of the type
universal_integer, and is alwaysin the range 0..7.
For an object that is a variable or a constant allocated
in a register, the value is zero. (The useofthis attribute does not force the allocation of a variable to
memory.) For an object that is a formal parameter,
this attribute applies to either the matching actual
parameter or to a copy of the matching actual parameter. For an access object, the value is zero (in
the absence of CONSTRAINT_ERROR); X.all’ BIT

is subject to an ACCESS_CHECKfor the designated
object. For a record component, X.C’ BIT is subject to a
16 See also Appendix G, AI-00015.
13-25

Representation Attributes

13.7.2

DISCRIMINANT_CHECKfor a component in a variant

part. For an array componentorslice, X(I)’ BIT or
X(11..12)' BIT is subject to an INDEX_CHECKfor the
denoted componentorslice.
For any component C of a record object R:!’

R.C’ POSITION

Yields the offset, from the start of the first storage unit
occupied by the record, of the first of the storage units
occupied by C. This offset is measured in storage units.
The value of this attribute is of the type universal_
integer. 18

R.C’ FIRST_BIT

Yields the offset, from the start of the first of the storage

units occupied by C,of thefirst bit occupied by C. This

offset is measuredin bits. The value of this attribute is
of the type wniversal_integer.

R.C’ LAST_BIT

Yields the offset, from the start of the first of the storage
units occupied by C, of the last bit occupied by C. This
offset is measured in bits. The value of this attribute is
of the type universal_integer.

For any access type or subtypeT:

T’ STORAGE_SIZE Yields the total number of storage units reserved for the

collection associated with the base type of T. The valuc
of this attribute is of the type wniversal_integer.

For any task type or task object T:

T’ STORAGE_SIZE Yields the number of storage units reserved for each

activation of a task of the type T or for the activation
of the task object T. The value of this attribute is of the
type universal_integer.

Notes:

For a task object X, the attribute X’ SIZE gives the numberof bits used to
hold the object X, whereas X’ STORAGE_SIZE gives the numberof storage
units allocated for the activation of the task designated by X. For a formal
parameter X, if parameter passing is achieved by copy, then the attribute

X’ ADDRESSyields the address of the local copy; if parameter passing is by
reference, then the address is that of the actual parameter.

17 See also Appendix G, AI-00258.
18 See also Appendix G, AI-00362.
13.7.2

Representation Attributes

13-26

The attribute X’ MACHINE_SIZEgives the size that would be used for a
variable of the type or subtype; it does not give the size that may be used for
a componentof that type or subtype.
The machinesize of a type or subtype can be influenced by representation
clauses, unlike the size of a type or subtype, which is independentof representation clauses. The machinesize of a base type can be less than, equal to,
or greater than the size of that same base type. See the VAX Ada Run-Time
Reference Manual for examples and additional discussion.
The machine size of a type or subtype determines the numberof bits that
are read or written to externalfiles in input-output operations for elements
of that type or subtype (see chapter 14 for information on input-output
operations).

References: access subtype 3.8, access type 3.8, activation 9.3, actual parameter

6.2, address clause 13.5, address predefined type 13.7, attribute 4.1.4, base type
3.3, collection 3.8, component 3.3, entry 9.5, formal parameter 6.1 6.2, label 5.1,
object 3.2, package 7, package body 7.1, parameter passing 6.2, program unit 6,
record object 3.7, statement 5, storage unit 13.7, subprogram 6, subprogram body
6.3, subtype 3.3, system predefined package 13.7, task 9, task body 9.1, task object
9.2, task type 9.2, task unit 9, type 3.3, universal_integer type 3.5.4
access object 3.8, array component 3.6, block statement 5.6, body 3.9, constant
3.2.1, constraint_error exception 11.1, designated object 3.8, exported subprogram
13.9a.1.4, generic unit 12 12.1, integer type 3.5.4, named number 3.2, package
7, range 3.5, record component3.7, slice 4.1.2, subtype 3.3, system.address_zero
13.7a.1, system.max_int 13.7, type 3.3, variable 3.2.1, variant part 3.7.3

13.7.3

Representation Attributes of Real Types
1

For every real type or subtype T, the following machine-dependent attributes
are defined, which are not related to the model numbers. Programs using
these attributes may thereby exploit properties that go beyond the minimal
properties associated with the numeric type (see section 4.5.7 for the rules

defining the accuracy of operations with real operands). Precautions must
therefore be taken when using these machine-dependent attributesif
portability is to be ensured.
For both floating point and fixed point types:
T’ MACHINE_ROUNDS

13-27

Yields the value TRUE if every predefined
arithmetic operation on values of the base
type of T either returns an exact result or
performs rounding; yields the value FALSE

Representation Attributes of Real Types

13.7.3

otherwise. The value of this attribute is of
the predefined type BOOLEAN. !”

In VAX Ada,this value is TRUE forfloating
point types and FALSE for fixed point types.
4

T’ MACHINE_OVERFLOWS Yields the value TRUE if every predefined
operation on values of the base type of T
either provides a correct result, or raises the
exception NUMERIC_ERRORin overflow

situations (see 4.5.7); yields the value FALSE

otherwise. The value of this attribute is of
the predefined type BOOLEAN.
In VAX Ada, this value is TRUE.
5

For floating point types, the following attributes provide characteristics

T’ MACHINE_RADIX

of the underlying machine representation, in terms of the canonical form
defined in section 3.5.7:2°
Yields the value of the radix used by the

machine representation of the base type of

T. The value of this attribute is of the type
universal_integer.

In VAX Ada,this value is 2.
7

T’ MACHINE_MANTISSA

Yields the numberof digits in the mantissa
for the machine representation of the base
type of T (the digits are extended digits in
the range 0 to T7 MACHINE_RADIX — 1).
The value of this attribute is of the type
universal_integer.
In VAX Ada,this value can be 24 (F_floating),
53 (G_floating), 56 (D_floating), or 113

(H_floating).
8

T’ MACHINE_EMAX

Yields the largest value of exponent for the
machine representation of the base type of
T. The value of this attribute is of the type
universal_integer.
In VAX Ada, this value can be 127 (F_floating

or D_floating), 1023 (G_floating), or 16383
(H_floating).

19 See also Appendix G, AI-00263.
20 See also Appendix G, AI-00263.
13.7.3

Representation Attributes of Real Types

13-28

T’ MACHINE_EMIN

Yields the smallest (most negative) value of
exponent for the machine representation of
the base type of T. The value of this attribute
is of the type universal_integer.
In VAX Ada, this value can be —127

(F_floating or D_floating), -1023 (G_floating),

or —16383 (H_floating).

The VAX Ada values of the representation attributes for floating point
numbersare listed in Appendix F. Definitions of the four floating point
representations (F_floating, D_floating, G_floating, and H_floating) are given
in section 3.5.7.
Note:

For many machines the largest machine representable numberof type F is
almost

(F’ MACHINERADIX) ** (F’MACHINEEMAX),
1

and the smallest positive representable numberis
F/MACHINERADIX ** (F’MACHINEEMIN - 1)

References: arithmetic operator 4.5, attribute 4.1.4, base type 3.3, boolean
predefined type 3.5.3, false boolean value 3.5.3, fixed point type 3.5.9, floating point
type 3.5.7, model number 3.5.6, numeric type 3.5, numeric_error exception 11.1,
predefined operation 3.3.3, radix 3.5.7, real type 3.5.6, subtype 3.3, true boolean
value 3.5.3, type 3.3, universal_integer type 3.5.4
d_floating representation 3.5.7 3.5.7a, f_floating representation 3.5.7, gfloating
representation 3.5.7 3.5.7a, h_floating representation 3.5.7

13.7a VAX Ada Additions to the Package System
In addition to the language-required declarations in the package SYSTEM,

VAX Ada declares the operations, constants, types, and subtypes described

in the following sections.

13-29

VAX Ada Additions to the Package System

13.7a

13.7a.1

Properties of the Type ADDRESS
In VAX Ada, ADDRESSis a private type for which the following operations
are declared:
type ADDRESS is private;

ADDRESSZERO : constant ADDRESS;
function "+"

function "+"
function "-"
function "-"

(LEFT
RIGHT

:
:

RIGHT
(LEFT
RIGHT
(LEFT
RIGHT

: ADDRESS)
: ADDRESS;
: ADDRESS)
: ADDRESS;
: INTEGER)

(LEFT

ADDRESS;
INTEGER)

: INTEGER;

return ADDRESS;
return ADDRESS;
return INTEGER;
return ADDRESS;

function "="

(LEFT, RIGHT : ADDRESS)

return BOOLEAN;

function
function
function
function
function

(LEFT,
(LEFT,
(LEFT,
(LEFT,
(LEFT,

return
return
return
return
return

----

Note that because ADDRESS is a private type,
the functions "=" and "/=" are already available and
do not have to be explicitly defined

"/="
"<"
"<="
">"
">="

RIGHT
RIGHT
RIGHT
RIGHT
RIGHT

: ADDRESS)
: ADDRESS)
: ADDRESS)
: ADDRESS)
: ADDRESS)

BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;

generic
type TARGET is private;

function FETCHFROMADDRESS (A : ADDRESS) return TARGET;

generic
type TARGET is private;
procedure ASSIGNTOADDRESS

(A : ADDRESS; T : TARGET);

The addition, subtraction, and relational functions provide arithmetic and

comparative operations for addresses. The generic subprograms FETCH_
FROM_ADDRESSand ASSIGN_TO_ADDRESSprovide operations for
reading from or writing to a given address interpreted as having any desired
type. ADDRESS_ZEROis a deferred constant whose value correspondsto
the first (machine) address.
In an instantiation of FETCH_FROM_ADDRESSor ASSIGN_TO_

ADDRESS,the actual subtype corresponding to the formal type TARGET
must be neither an unconstrained array type nor an unconstrained type
with discriminants. If the actual subtype is a type with discriminants,
the value fetched by a call of a function resulting from an instantiation

of FETCH_FROM_ADDRESSis checked to ensure that the discriminants

satisfy the constraints of the actual subtype. In any other case, no checkis
made.
Properties of the Type ADDRESS

13-30

Functions for converting values of other types to the type ADDRESSare
listed in section 13.7a.6.
Example:
X

INTEGER;

A : SYSTEM.ADDRESS := X’ ADDRESS;
function FETCH

-- legal

is new FETCHFROMADDRESS (INTEGER) ;

procedure ASSIGN is new ASSIGN_TOADDRESS (INTEGER) ;

X := FETCH(A);
ASSIGN (A,X) ;

-- like "X := A.all;"
-- like "A.all := x;"

References: actual parameter 6.4 6.4.1, boolean predefined type 3.5.3, deferred

constant 7.4, discriminant 3.3 3.7.1, erroneous 1.6, formal parameter 6.4, function
6.5, generic subprogram 12.1 12.1.3, instantiation 12.3, integer type 3.5.4, operation
3.3.3, private type 7.4 7.4.1, range 3.5, subtype 3.3, system.max_int 13.7, type 3.3,
unconstrained array type 3.6

13.7a.2

Enumeration Type for Identifying Type Classes
VAX Ada declares the following enumeration type for identifying the various
Ada typeclasses:

type TYPECLASS is (TYPECLASSENUMERATION,
TYPECLASSINTEGER,
TYPECLASSFIXEDPOINT,
TYPECLASSFLOATINGPOINT,
TYPECLASSARRAY,
TYPECLASSRECORD,
TYPECLASSACCESS,
TYPECLASSTASK,
TYPECLASSADDRESS) ;
In addition to the usual operations for discrete types (see 3.5.5), VAX Ada
provides the attribute TYPE_CLASS.

For every type or subtype T:
T’ TYPE_CLASS Yields the value of the type class for the full type of T. If T
is a generic formal type, then the valueis the value for the
corresponding actual subtype. The value of this attribute
is of the type TYPE_CLASS.
This attribute is only allowed within a unit to which the predefined package
SYSTEM applies.

13-31

Enumeration Type for Identifying Type Classes

13.7a.2

Examples:
Given
type MYINT is range 1..10;
type NEWINT is new STRING;

package PACK is
type PRIV is private;
private
type PRIV is new FLOAT;
end PACK;

then

-- MYINT’ TYPECLASS
-- NEW_INT’TYPECLASS
-- PRIV’ TYPECLASS

equals
equals
equals

TYPECLASSINTEGER
TYPECLASSARRAY
TYPECLASSFLOATINGPOINT

References: access type 3.8, address type 13.7 13.7a.1, array type 3.6, discrete
type 3.5, enumeration type 3.5.1, fixed point type 3.5.9, floating point type 3.5.7,
generic formal type 12.1 12.1.2, integer type 3.5.4, record type 3.9, subtype 3.3 3.3.2,
task type 9.1

13.7a.3

Floating Point Type Declarations
In the package SYSTEM, VAX Ada declares four floating point types that
correspond to the four VAX hardwarefloating point data representations:
D_floating, F_floating, G_floating, and H_floating.
type FFLOAT is implementation_defined;
type D_FLOAT is implementation_defined;
type GFLOAT is implementationdefined;
type H_FLOAT is implementation_defined;

These types haveall of the properties of floating types in general (operators,
attributes, implicit conversion of real literals, and so on); see section 3.5.7

and the VAX Ada Run-Time Reference Manual for explanations of the VAX

floating point types and type representations.

13.7a.4

Asynchronous-System-Trap-Related Declarations
To support a means of handling VMS asynchronous system traps (ASTs), and
to allow the explicit specification of imported VMS system service routines
that involve ASTs, VAX Ada declares the following type and its auxiliary
constant:

13.7a.4

Asynchronous-System-Trap-Related Declarations

13-32

type ASTHANDLER is limited private;

NOASTHANDLER : constant ASTHANDLER;
The type AST_HANDLERis used in the specification of the AST_ENTRY

attribute, which is the only operation defined for this type. A value of the
type AST_HANDLERis the address of a specially created routine that
implements the delivery of an AST as a call to a particular entry in a
particular task. See section 9.12a.
The constant NO_AST_HANDLER, when usedas an actual parameter to an

imported VMSsystem service routine, allows explicit specification that no
AST handler is provided.
A function for converting values of the type ASTHANDLER to the type

SYSTEM.UNSIGNED_LONGWORDislisted in section 13.7a.6.
Note:

When using the type AST_HANDLERto pass a parameter to an imported
subprogram, it is generally necessary to specify the VALUE mechanism
option. See section 13.9a.1.2 and the VAX Ada Run-Time Reference Manual.
Example:
The type AST_HANDLERand constant NO_AST_HANDLERare useful in
writing interfaces to VMS system routines. The following specification from
the package STARLET showsthe use of the type AST_HANDLERto declare
an AST address parameter, and showsthe use of the constant NO_AST_
HANDLERto give that parameter a default value:
-- interface for the Get Job/Process

procedure GETJPI

Information system service

(

STATUS
EFN
PIDADR
PRCNAM
ITMLST

:
>:
:
:
:

out
in
in
in
in

CONDVALUETYPE;
EF_NUMBER_TYPE
ADDRESS
PROCESS_NAME_TYPE:
ITEMLISTTYPE;

EF_NUMBER_ZERO;
ADDRESSZERO;
PROCESSNAMETYPE’ NULLPARAMETER;

ASTADR
ASTPRM

:
:

in
in

ASTHANDLER
USER_ARGTYPE

NOASTHANDLER;
USER_ARGZERO) ;

IOSB

: out IOSBTYPE;

pragma INTERFACE

(EXTERNAL,

GETJPTI) ;

pragma IMPORTVALUEDPROCEDURE (GETUPI, "SYSSGETJPI",
(CONDVALUETYPE, EFNUMBERTYPE, ADDRESS,
PROCESS_NAME_TYPE, ITEM_LISTTYPE, IOSBTYPE,
AST_HANDLER, USER_.ARG_TYPE),
(VALUE, VALUE, VALUE, DESCRIPTOR(S), REFERENCE, REFERENCE,
VALUE, VALUE) );

13-33

Asynchronous-System-Trap-Related Declarations

13.7a.4

References: actual parameter 6.4 6.4.1, asynchronous system trap 9.12a, attribute
4.1.4, constant 3.2.1, entry 9.5, exception 11, exception declaration 11.1, importing
subprograms 13.9a.1.1, limited private type 7.4.4, operation 3.3.3, task 9, type 3.3

13.7a.5

Non-Ada Exception
VAX Ada declares the following exception, which, when used as a choice

in an Ada exception part, matchesitself or any VMS(that is, non-Ada)
exception. It allows the treatment of non-Ada conditions as a special
subclass of Ada exceptions.
NON_ADA_ERROR : exception;

Example:
-- Ada specification for an imported function that will raise
-- a condition to be caught by SYSTEM.NON_ADAERROR
function DIVIDE (X,Y: INTEGER) return INTEGER;
pragma INTERFACE (PASCAL, DIVIDE) ;
pragma IMPORTFUNCTION (INTERNAL => DIVIDE,
PARAMETERTYPES => (INTEGER, INTEGER) ,
RESULT_TYPE => INTEGER) ;

(* Pascal body for the Ada function DIVIDE *)
MODULE PascalOps;
[GLOBAL] FUNCTION Divide
BEGIN
Divide := X DIV Y;
END;
END.

(X,Y:

INTEGER): INTEGER;

-- Ada procedure that calls DIVIDE, and catches a
-- divide-by-zero with SYSTEM.NONADAERROR
with SYSTEM;
with DIVIDE;

with TEXT_I0O; use TEXTIO;
procedure CATCHNONADA is
I,J: INTEGER;

begin
I := 0;
J:= 1;
I := DIVIDE(J,1);

exception
when SYSTEM.NON_ADAERROR =>
PUTLINE("Non-Ada Error");
end;

References: exception 11, exception declaration 11.1
13.7a.5

Non-Ada Exception

13-34

13.7a.6

VAX Hardware-Oriented Types and Functions
VAX Ada declares the following types, subtypes, and functions for convenience in working with VAX hardware-oriented storage:
type
pragma

BITARRAY is array (INTEGER range <>) of BOOLEAN;
PACK(BITARRAY) ;

subtype BITARRAY8 is BITARRAY
subtype BITARRAY16 is BITARRAY
subtype BITARRAY32 is BITARRAY
subtype BITARRAY64 is BITARRAY
type UNSIGNEDBYTE
for

(0
(0
(0
(0

.. 7);
.. 15);
.. 31);
.. 63);

is range 0 .. 255;

UNSIGNEDBYTE’SIZE

use 8;

function "not" (LEFT
return UNSIGNEDBYTE;
function "and" (LEFT, RIGHT
return UNSIGNEDBYTE;
function "or"
(LEFT, RIGHT
return UNSIGNEDBYTE;
function "xor" (LEFT, RIGHT
return UNSIGNEDBYTE;

: UNSIGNEDBYTE)
: UNSIGNEDBYTE)
: UNSIGNEDBYTE)
: UNSIGNEDBYTE)

function TOUNSIGNEDBYTE (X : BIT_ARRAY8)

return UNSIGNEDBYTE;
function TOBITARRAY8

(X : UNSIGNEDBYTE)

return BITARRAY8;

type UNSIGNEDBYTEARRAY is

array (INTEGER range <>) of UNSIGNEDBYTE;

type UNSIGNEDWORD
is range 0 .. 65535;
for UNSIGNED_WORD’SIZE use 16;
function "not" (LEFT
: UNSIGNEDWORD)
return UNSIGNEDWORD;
function "and" (LEFT, RIGHT : UNSIGNEDWORD)
return UNSIGNEDWORD;

function "or"
(LEFT, RIGHT : UNSIGNED_WORD)
return UNSIGNEDWORD;
function "xor" (LEFT, RIGHT : UNSIGNEDWORD)
return UNSIGNEDWORD;
function TOUNSIGNEDWORD
return UNSIGNEDWORD;
function TOBITARRAY16

return BITARRAY16;

(X : BITARRAY16)
(X : UNSIGNEDWORD)

type UNSIGNEDWORDARRAY is
array (INTEGER range <>) of UNSIGNEDWORD;
type UNSIGNEDLONGWORD is range MININT .. MAXINT;
for UNSIGNED_LONGWORD’ SIZE use 32;

13-35

VAX Hardware-Oriented Types and Functions

13.7a.6

function "not" (LEFT
:
return UNSIGNEDLONGWORD;
function "and" (LEFT, RIGHT :
return UNSIGNEDLONGWORD;
function "or"
(LEFT, RIGHT :
return UNSIGNEDLONGWORD;
function "xor" (LEFT, RIGHT :
return UNSIGNEDLONGWORD;

UNSIGNEDLONGWORD)
UNSIGNED_LONGWORD)
UNSIGNEDLONGWORD)
UNSIGNEDLONGWORD)

function TOUNSIGNEDLONGWORD (X : BIT_ARRAY_32)
return UNSIGNEDLONGWORD;

function TOBITARRAY32

(X : UNSIGNEDLONGWORD)

return BITARRAY32;

type UNSIGNEDLONGWORDARRAY is
array

(INTEGER range <>)

of UNSIGNEDLONGWORD;

type UNSIGNEDQUADWORD is record

LO : UNSIGNEDLONGWORD;
Ll : UNSIGNED_LONGWORD;
end record;
for UNSIGNEDQUADWORD’ SIZE use 64;

function "not" (LEFT
:
return UNSIGNEDQUADWORD;
function "and" (LEFT, RIGHT :
return UNSIGNEDQUADWORD;
function "or"
(LEFT, RIGHT :
return UNSIGNEDQUADWORD;
function "xor" (LEFT, RIGHT :
return UNSIGNEDQUADWORD;

UNSIGNEDQUADWORD)
UNSIGNEDQUADWORD)
UNSIGNED_QUADWORD)
UNSIGNEDQUADWORD)

function TOUNSIGNEDQUADWORD (X : BITARRAY64)
return UNSIGNED_QUADWORD;
function TOBITARRAY64
(X : UNSIGNEDQUADWORD)
return BITARRAY64;
type UNSIGNEDQUADWORDARRAY is
array (INTEGER range <>) of UNSIGNEDQUADWORD;
function TOADDRESS
return ADDRESS;
function TOADDRESS
return ADDRESS;

function TOADDRESS
return ADDRESS;

INTEGER)

UNSIGNEDLONGWORD)

(X : universal_integer)

function TOINTEGER
(X : ADDRESS)
return INTEGER;
function TOUNSIGNEDLONGWORD (X : ADDRESS)
return UNSIGNEDLONGWORD;
function TOUNSIGNEDLONGWORD
return UNSIGNEDLONGWORD;

13.7a.6

VAX Hardware-Oriented Types and Functions

ASTHANDLER)

13-36

References: address predefined type 3.7 array 3.6, boolean predefined type 3.5.3,
function 6.5, integer type 3.5.4 overloading 8.7, subtype 3.3 3.3.2, system.ast_
handler type 13.7a.4, system.max_int 13.7, system.min_int 13.7, type 3.38, universal_
integer type 3.5.4

13.7a.7

Conventional Names for Unsigned Longwords

Q*x*
Q*x
Qk
Qe
Q*x*
Dkk
Qk
Q*x
Q*x
a
2**10-1;
2**11-1;
2**12-1;
2**13-1;
2**14-1;

“ue

“e

~ e

“oe
=e

“se

PRPEPPPERPHE

subtype

ODMDAIKHDOBWNE

UNSIGNED_1 is UNSIGNED_LONGWORD range
UNSIGNED2 is UNSIGNED_LONGWORD range
subtype UNSIGNED3 is UNSIGNEDLONGWORD range
is UNSIGNED_LONGWORD range
subtype UNSIGNED4
subtype UNSIGNED5 is UNSIGNEDLONGWORD range
subtype UNSIGNED6 is UNSIGNED_LONGWORD range
is UNSIGNEDLONGWORD range
subtype UNSIGNED7
subtype UNSIGNED8 is UNSIGNEDLONGWORD range
subtype UNSIGNED9 is UNSIGNED_LONGWORD range
subtype UNSIGNED10 is UNSIGNEDLONGWORD range
subtype UNSIGNED11 is UNSIGNEDLONGWORD range
subtype UNSIGNED12 is UNSIGNEDLONGWORD range
subtype UNSIGNED13 is UNSIGNEDLONGWORD range
subtype UNSIGNED14 is UNSIGNED_LONGWORD range
subtype UNSIGNED15 is UNSIGNEDLONGWORD range
subtype UNSIGNED16 is UNSIGNEDLONGWORD range
subtype UNSIGNED17 is UNSIGNED_LONGWORD range
subtype UNSIGNED18 is UNSIGNEDLONGWORD range
subtype UNSIGNED19 is UNSIGNED_LONGWORD range
subtype UNSIGNED20 is UNSIGNEDLONGWORD range
subtype UNSIGNED21 is UNSIGNEDLONGWORD range
subtype UNSIGNED22 is UNSIGNED_LONGWORD range
subtype UNSIGNED23 is UNSIGNEDLONGWORD range
subtype UNSIGNED24 is UNSIGNEDLONGWORD range
subtype UNSIGNED25 is UNSIGNEDLONGWORD range
subtype UNSIGNED26 is UNSIGNEDLONGWORD range
subtype UNSIGNED27 is UNSIGNEDLONGWORD range
subtype UNSIGNED28 is UNSIGNEDLONGWORD range
subtype UNSIGNED29 is UNSIGNEDLONGWORD range
subtype UNSIGNED30 is UNSIGNED_LONGWORD range
subtype UNSIGNED31 is UNSIGNEDLONGWORD range
subtype

ooooooocoo°oo°ceon°0o°0o°0o C000 0 0 00 Cocoa CcaCco oO

The following VAX Ada declarations provide conventional (and convenient)
namesfor static subtypes of the predefined type UNSIGNED_LONGWORD:

2**15-1;

2**16-1;
2**17-1;
2**18-1;
2**19-1;
2**20-1;
2**21-1;
2**22-1;
2**23-1;
2**24-1;
2**25-1;
2**26-1;
2**27-1;

2**28-1;
2**29-1;
2**30-1;
2**31-1;

References: range 3.5, static subtype 4.9, subtype 3.3 3.3.2, system.unsigned_
longword 13.7a.6, type 3.3

13-37

Conventional Names for Unsigned Longwords

13.7a.7

13.7a.8

Global Symbol Values
The following VAX Ada function allows the value of a link-time global
symbol (sometimescalled a global literal) to be obtained:
function IMPORTVALUE (SYMBOL
return UNSIGNEDLONGWORD;

STRING)

If SYMBOLis stringliteral of 31 or fewer characters, then the value of the
function is the value of the global symbol in the external environment. If
the symbolis not defined at link time, then the result is zero (the linker also
gives a diagnostic message). If the parameteris not a stringliteral, then the
result is undefined (currently zero).
Example:

CMSCREATED : constant CONDITION_HANDLING.COND_VALUE_TYPE
:= IMPORTVALUE ("CMS$CREATED") ;
This constant declaration would be used in a VAX Ada program that calls
VAX DEC/Code Management System (CMS) routines. The IMPORT_VALUE
function is used to assign the value of the global symbol CMS$_CREATE
to the condition value constant (an unsigned longword) CMS_CREATED,
so that the success or failure of a CMS creation routine can be monitored.
(The specification of the VAX Ada package CONDITION_HANDLINGis
presented in the VAX Ada Run-Time Reference Manual.)
References: constant declaration 3.2, function 6.1, function result 6.5, parameter
6.2, string literal 2.6, string type 3.6.3

13.7a.9

VAX Processor and Device Register Operations
The following VAX Ada operations allow access to processor and device
registers:
function
return
function
return
function
return

READREGISTER (SOURCE : UNSIGNEDBYTE)
UNSIGNEDBYTE;
READREGISTER (SOURCE : UNSIGNED_WORD)
UNSIGNEDWORD;
READREGISTER (SOURCE : UNSIGNEDLONGWORD)
UNSIGNEDLONGWORD;

procedure WRITEREGISTER(SOURCE
TARGET
procedure WRITEREGISTER(SOURCE
TARGET
procedure WRITEREGISTER(SOURCE
TARGET

13.7a.9

: UNSIGNEDBYTE;
: out UNSIGNEDBYTE) ;
: UNSIGNEDWORD;
: out UNSIGNEDWORD) ;
: UNSIGNED_LONGWORD;
: out UNSIGNEDLONGWORD) ;

VAX Processor and Device Register Operations

13-38

The READ_REGISTER functions return the value of a variable reference
(byte, word, or longword). The WRITE_REGISTERprocedures load a
specified value or group of values into a specified target variable reference
(byte, word, or longword).
Each READ_REGISTER and WRITE_REGISTERoperation is performed
by a single machineinstruction andis not affected by any compiler optimizations. Use of these operations is the only safe method for reading or
writing a device register. These operations can also be used to read or write
a variable in shared memory, although useof the pragma SHAREDis the
preferred method of doing so.
function MFPR (REGNUMBER : INTEGER)
return UNSIGNEDLONGWORD;
procedure MTPR (REGNUMBER : INTEGER,
SOURCE
: UNSIGNEDLONGWORD) ;

The function MFPRis equivalent to the VAX Move From Process Register
instruction, and returns the current contents of the specified VAX internal
processor register. The procedure MTPRis equivalent to the VAX Move To
Process Register instruction, and movesa specified value into a specified
VAX internal processor register. In both cases, the calling program must be
running in kernel mode.
Note that these two operations are generally useful only on systems
running VAXELN Ada; nonuser-mode execution is not supported on VMS
systems. Also note that processor registers are a privileged system resource.
Changing the contents of a processor register while a system is running may
cause an unhandled exception.
For more information on the use of these operations, see the VAX Ada
Run-Time Reference Manual and the VAXELN Ada User’s Manual.
References: exception 11, exception handling 11.4, function 6.1, integer type

3.5.4, procedure 6.1, system.unsigned_byte type 13.7a.6, system.unsigned_word type
13.7a.6, system.unsigned_longword type 13.7a.6, variable 3.2.1 3.7.3

13.7a.10

VAX Interlocked-Instruction Procedures
The following procedures provide equivalents for VAX interlocked and
interlocked queue instructions:

13-39

VAX Interlocked-Instruction Procedures

13.7a.10

procedure CLEAR_INTERLOCKED

(BIT
OLDVALUE
(BIT
OLDVALUE

procedure SETINTERLOCKED

;:
:
:
:

in out BOOLEAN;
out BOOLEAN) ;
in out BOOLEAN;
out BOOLEAN) ;

type ALIGNEDWORD is
record
VALUE : SHORTINTEGER;
end record;

for ALIGNEDWORD use
record
at mod 2;
end record;

procedure ADD_INTERLOCKED

(ADDEND

AUGEND

in out ALIGNEDWORD;

SHORT_INTEGER;

SIGN

out

INTEGER) ;

The procedure CLEAR_INTERLOCKEDis equivalent to the VAX Branch
on Bit Clear and Clear Interlocked (BBCC]I) instruction; the procedure
SET_INTERLOCKEDis equivalent to the VAX Branch on Bit Set and Set
Interlocked (BBSSI) instruction; and the procedure ADD_INTERLOCKEDis
equivalent to the VAX Add Aligned Word Interlocked (ADAWI)instruction.
These instructions interlock memory accesses, and thus provide a meansfor
synchronizing access to shared memory across processors.
The CLEAR_INTERLOCKED and SET_INTERLOCKEDproceduresclear or
set a single bit and return the previous valueof the bit.
The ADD_INTERLOCKED procedure adds two signed-word integers
(ADDEND and AUGEND). SIGNis assigned the integer result —1 if the
new value of AUGENDis negative; 0 if AUGENDis zero; +1 if AUGENDis
positive.

The type ALIGNED_WORD,used in the ADD_INTERLOCKEDprocedure, specifies a word-sized integer that is word-aligned (the type
STANDARD.SHORT_INTEGERis a word-sized integer that is byte-aligned).

type INSQSTATUS is (OK_NOTFIRST, FAILNOLOCK, OKFIRST);
type REMQSTATUS is (OK_NOTEMPTY, FAILNOLOCK,
_ OK_EMPTY,
FAILWASEMPTY) ;
procedure INSQHI (fTEM
: in ADDRESS;
HEADER : in ADDRESS;
STATUS : out INSQSTATUS);
procedure REMOQHI

(HEADER

ADDRESS;

procedure INSQTI

(ITEM

: in

ADDRESS;

HEADER

ADDRESS;

ITEM
> out ADDRESS;
STATUS : out REMQSTATUS);
in

STATUS : out INSQSTATUS) ;

13.7a.10

VAX Interlocked-Instruction Procedures

13—40

procedure REMQTI

(HEADER :
ITEM
:
STATUS :

in
ADDRESS;
out ADDRESS;
out REMQSTATUS);

The procedure INSQHIis equivalent to the VAX Insert Entry into Queue
at Head, Interlocked instruction; the procedure INSQTI is equivalent to the

VAX Insert Entry into Queue at Tail, Interlocked instruction; the procedure

REMQHIis equivalent to the VAX Remove Entry from Queue at Head,
Interlocked instruction; and the procedure REMQTIis equivalent to the
Remove Entry from Queueat Tail, Interlocked instruction. The types INSQ_
STATUS and REMQ_STATUSare defined to represent the status results
of the procedures for manipulating self-relative queues (queues where the
forward and backward links are defined as offsets from one link to the next,

rather than as virtual addresses).

The INSQHI, REMQHI, INSQTI, and REMQTI procedures perform queue

insertion and removal operations at the head andtail of a self-relative
queue. The address values of HEADER and ITEM must be quadwordaligned. The enumeration value assigned to STATUSgives the state of the
queue after the operation has been executed.

Note that the VAX INSQHI, REMQHI, INSQTI, and REMQTIinstructions
all have a parameter named "entry". Because "entry" is a reserved word in
Ada, the "entry" parameter in each analogous VAX Ada procedure has been
changed to ITEM.
For more information on the use of these operations, see the VAX Ada

Run-Time Reference Manual.

References: address predefined type 13.7, boolean predefined type 3.5.3, integer

type 3.5.4, parameter 6.2, procedure 6.1, record representation clause 13.4, record
type 3.7, type 3.3, short_integer predefined type 3.5.4

13.8

Machine Code Insertions
A machine code insertion can be achieved by a call to a procedure whose
sequence of statements contains code statements.
codestatement

::= typemark’ record_aggregate;

A code statement is only allowed in the sequence of statements of a
procedure body. If a procedure body contains code statements, then within
this procedure body the only allowed form of statement is a code statement
(labeled or not), the only allowed declarative items are use clauses, and no
exception handler is allowed (comments and pragmas are allowed as usual).

13-41

Machine Code Insertions

13.8

Each machine instruction appears as a record aggregate of a record type
that defines the corresponding instruction. The base type of the type mark
of a code statement must be declared within the predefined library package
called MACHINE_CODE; this package must be namedby a with clause
that applies to the compilation unit in which the code statement occurs. An
implementation is not required to provide such a package.

VAX Ada does not provide the package MACHINE_CODE. Further, a userprovided package named MACHINE_CODEcannot be used for machine code
insertions.
5

An implementation is allowed to impose further restrictions on the record

An implementation may provide machine-dependent pragmas specifying
register conventions and calling conventions. Such pragmas must be
documented in Appendix F-.

ageregates allowed in code statements. For example, it may require that
expressions contained in such aggregates be static expressions.

‘VAX Ada does not provide machine-dependent pragmasspecifying register
conventions; calling conventions are specified by the interface and importexport pragmas(see 13.9 and 13.9a).
7

Example:
M

MASK;

procedure SETMASK; pragma INLINE (SETMASK) ;
procedure SETMASK is
use MACHINECODE;
begin
SI FORMAT’ (CODE => SSM,

-end;

B => M’ BASEREG,

D => M’DISP);

M’BASEREG and M’DISP are implementation-specific
predefined attributes

References: allow 1.6, apply 10.1.1, comment 2.7, compilation unit 10.1, declarative item 3.9, exception handler 11.2, inline pragma 6.3.2, labeled statement 5.1,
library unit 10.1, package 7, pragma 2.8, procedure 6 6.1, procedure body 6.3, record
aggregate 4.3.1, record type 3.7, sequence of statements 5.1, statement 5, static

expression 4.9, use clause 8.4, with clause 10.1.1

13.8

Machine Code Insertions

13-—42

13.9 Interface to Other Languages
1

A subprogram written in another language can be called from an Ada
program provided that all communication is achieved via parameters and
function results. A pragma of the form

pragma INTERFACE

(languagename,

subprogramname);

must be given for each such subprogram; a subprogram nameis allowed to
stand for several overloaded subprograms. This pragmais allowed at the
place of a declarative item, and must apply in this case to a subprogram

declared by an earlier declarative item of the same declarative part or

package specification. The pragmais also allowed for a library unit; in this

case the pragma must appear after the subprogram declaration, and before
any subsequent compilation unit. The pragma specifies the other language

(and thereby the calling conventions) and informs the compiler that an
object module will be supplied for the corresponding subprogram. A body
is not allowed for such a subprogram (not even in the form of a body stub)
since the instructions of the subprogram are written in another language.?!
4

This capability need not be provided by all implementations. An implementation may place restrictions on the allowable forms and places of

parameters andcalls.

Use of this pragma in VAX Adais interpreted as being equivalent to
supplying the body of the named subprogram or subprograms. Therefore,
the following rules apply:
e

Ifa subprogram bodyis given later for a subprogram named with a
pragma INTERFACE,the bodyisillegal.

Ifa pragma INTERFACE names a subprogram body, the pragmais
illegal.

Ifa duplicate pragma INTERFACEis given, the latter pragmaisillegal.

In VAX Ada, if a name specified by a pragma INTERFACEis declared
by a renaming declaration, the pragma INTERFACEapplies to the
subprogram only if the subprogram that has been renamed, the renaming
declaration, and the pragmaall occur in the same declarative part or
package specification. The pragmais ignored if these conditions are not
satisfied.

21 See also Appendix G, AI-00180 and AI-00298.
13-43

Interface to Other Languages

13.9

In addition, VAX Ada interprets the effect of a pragma INTERFACE such
that implicit declarations of subprograms(such as predefined operators,
derived subprograms, attribute functions, and so on) are accepted and
ignored.
Depending upon its use in a VAX Ada program, a pragma INTERFACE
is interpreted in combination with one of the three VAX Ada import
subprogram pragmas: IMPORT_FUNCTION, IMPORT_PROCEDURE,or
IMPORT_VALUED_PROCEDURE. These pragmasare described in
section 13.9a.1.1.
If a pragma INTERFACEis used without one of these import pragmas, a
default interpretation is used, as follows:
1.

The language nameis ignored, so it may be any identifier that suggests
the language, source, or nature of the imported subprogram.

Ifthe subprogram nameapplies to a single subprogram, then a default
import pragmais assumedasfollows:
For a function, the default is
pragma IMPORTFUNCTION (function_designator) ;

For a procedure, the default is
pragma IMPORTPROCEDURE (procedureidentifier);

Ifthe subprogram name applies to two or more subprograms, the
pragma applies to all of them. However, a warningis given if the
appropriate VAX Ada import pragmasare not given forall of the
subprograms.

Whetheror not the pragma INTERFACEis used with an import pragma,
the subprogram name must be either an identifier or a string literal that
denotes an operator symbol.
5

Example:
package FORTLIB is
function SORT(X
function EXP (X

:
:

FLOAT)
FLOAT)

private
pragma INTERFACE (FORTRAN,
pragma

INTERFACE (FORTRAN,

return FLOAT;
return FLOAT;

SQRT) ;
EXP);

end FORTLIB;

13.9

Interface to Other Languages

13-44

In VAX Ada, this example is interpreted as follows: the pragma
INTERFACEspecifies that the indicated routines SQRT and EXP areto
be imported and used as bodies for the Ada functions SQRT and EXP in the
package FORT_LIB.
package CHOOSER
procedure P(X
procedure P(X
private
procedure R(X

is
: INTEGER);
: FLOAT);
: FLOAT)

pragma INTERFACE (PLI,

end CHOOSER;

renames P;
R);

In this example, the pragma INTERFACEindicates that the body for the
second procedureP is to be imported as routine R.
Notes:

The conventions used by other language processors that call Ada programs
are not part of the Ada language definition. Such conventions must be
defined by these other language processors.

The pragma INTERFACEis not defined for generic subprograms.
The meaning of the subprogram nameis determined as for any name(see
8.3), except that the name can denote more than one subprogram. Thus,
in the following declaration, the pragma INTERFACEappliesto the first
two procedures; it does not apply to the third because the declaration is not
visible at the place of the pragma. This sameinterpretation is made for
pragmas used to import and export subprograms(see 13.9a.1).
procedure P
procedure P

(B: BOOLEAN) ;
(I: INTEGER);

procedure P

(F: FLOAT);

pragma INTERFACE (NONADA, P);

If a pragma INTERFACE and a pragma INLINEare used together, the
pragma INLINEis ignored regardless of the order in which the two pragmas
appear.
:
References: allow 1.6, body stub 10.2, compilation unit 10.1, declaration 3.1,
declarative item 3.9, declarative part 3.9, function result 6.5, library unit 10.1, must
1.6, name 4.1, overloaded subprogram 6.6, package specification 7.1, parameter of a
subprogram 6.2, pragma 2.8, subprogram 6, subprogram body 6.3, subprogram call
6.4, subprogram declaration 6.1
attribute 4.1.4, declarative part 3.9, derived subprogram 3.4, function 6.5, identifier
2.3, operator 4.5, operator symbol 6.1, procedure 6.1, renaming declaration 8.5,
string literal 2.6

13-45

Interface to Other Languages

13.9

13.9a VAX Ada Import and Export Pragmas
VAX Ada provides import and export pragmas designed specifically for

constructing programs composed of both Ada and non-Adaentities. The
import pragmas allow an Ada program to refer to entities written in another
language; the export pragmas make Adaentities available to programs
written in other languages. The namesof the pragmasindicate the kind of
entity involved:
e

The pragmas IMPORT_FUNCTION and EXPORT_FUNCTIONapply to
(nongeneric) functions.

The pragmas IMPORT_PROCEDURE, IMPORT_VALUED_
PROCEDURE, EXPORT_PROCEDURE, and EXPORT_VALUED_
PROCEDUREapply to (nongeneric) procedures.

The pragmas IMPORT_OBJECT, EXPORT_OBJECT, and PSECT_
OBJECT apply to objects.

The pragmas IMPORT_EXCEPTION and EXPORT_EXCEPTIONapply
to exceptions.

These pragmasare described in this section, summarized in Annex B, and
listed in Appendix F.
The form of all of the VAX Ada import and export pragmasis as follows:
pragma importexportpragma_name
(internalname [, externaldesignator]
[, pragma_specificoptions]);

import_export_pragma_name ::=

|
|
|
|
|

internal_name

::=

[INTERNAL =>]

simplename

operatorsymbol -- Can be used only for
-- IMPORTFUNCTION

externaldesignator ::=

[EXTERNAL =>]

externalsymbol

external_symbol ::= identifier | stringliteral

The internal name maybe an Ada simple name,or, if the declared entity
is a function, the internal name maybea string literal that denotes an
operator symbol. A subprogram to be imported or exported must be uniquely
identified by its internal name and parameter types; and, in the case of a
function, the result type (see 13.9a.1.1).
13.9a

VAX Ada Import and Export Pragmas

13—46

The external designator determines a symbol that is referenced or declared
in the linker object module. If an identifier is given, the identifier is. used. If
a string literal is given, the value of the string is used. The value of a string
literal must be a symbol that is acceptable to the VMS Linker;it need not
be valid as an Ada identifier. (For example, the dollar sign ($) character can
be used.) If no external designator is given, the internal nameis used as the
external designator. If the external designator (explicit or default) is longer
than 31 characters, the import or export pragmais ignored.
Pragma-specific options are described in the individual pragmasections that
follow.
The VAX Ada import and export pragmasare only allowed at the place
of a declarative item, and must apply to an entity declared by an earlier
declarative item of the same declarative part or package specification. At
most one import or export pragmais allowed for any given entity (in the case
of multiple overloaded subprograms,this rule applies to each subprogram
independently).
Additional placement and usagerules that apply to particular pragmas are
described in the individual pragmasections that follow.
Note:

External designator string literals containing dollar signs are reserved for
identifiers of Digital-supplied software components.
Parameter associations for VAX Ada import and export pragmas may be
either positional or named. With positional association, the parameters are
interpreted in the same order as they appearin the syntax definition. The
rules for the mixing of positional and namedassociation are the same as
those that apply to subprograms(see 6.4).
A pragma for an entity declared in a package specification must not be given
in the package body. (A pragmafor an entity given in the visible part of a
package specification can, however, be given in either the visible or private
part of the specification.)
No checkingis provided to assure that exported symbols donot conflict with
each other or with other global symbols; such checking is performed by the
VMSLinker.
References: allow 1.6, declaration 3.1, declarative item 3.9, declarative part 3.9,
entity 3.1, exception 11, function 6.5, generic subprogram 12.1, identifier 2.3, named
parameter association 6.4, object 3.2, operator symbol 4.5 6.1, overloading 6.6,
package body 7.1, package specification 7.1, parameter 6.2, positional parameter
association 6.4, pragma 2.8, private part 7.2, procedure 6.1, program 10.1, renaming
declaration 8.5, result type 5.8, simple name 3.1 4.1, string literal 2.6, string type
3.6.3, subprogram 6,visibility 8.3
13-47

VAX Ada Import and Export Pragmas

13.9a

13.9a.1

Importing and Exporting Subprograms
VAX Ada provides a series of pragmas that makeit possible to call (non-

generic) subprograms in a mixed-language programming environment. The
pragmas IMPORT_FUNCTION, IMPORT_PROCEDURE, and IMPORT_
VALUED_PROCEDUREspecify that the body of the subprogram associated with an Ada subprogram specification is to be provided from
another VAX language. The pragma INTERFACE must precede one of
these import pragmas(see 13.9). The pragmas EXPORT_FUNCTION,
EXPORT_PROCEDURE, and EXPORT_VALUED_PROCEDUREallow an
Ada procedure or function to be called from another VAX language.
References: function 6.5, generic subprogram 12.1, pragma 2.8, procedure6.1,
subprogram 6, subprogram body 6.3, subprogram specification 6.1

13.9a.1.1

Importing Subprograms
VAX Ada provides three pragmas for importing subprograms: IMPORT_
FUNCTION, IMPORT_PROCEDURE, and IMPORT_VALUED_PROCEDURE.
The pragmas IMPORT_FUNCTION and IMPORT_PROCEDUREallow
an Ada program to call external (non-Ada) functions and procedures. The
pragma IMPORT_VALUED_PROCEDUREallows an Ada program tocall an
external routine that, like a function, returns a result value, but that, like

a procedure, can also cause side effects on its parameters (a function with
in out or out parametersis not legal in Ada). In other words, the pragma
IMPORT_VALUED_PROCEDUREallowsa routine to be interpreted as a

procedure in the environment of an Ada program andas a function in the
external environment; the function result is returnedin the first parameter.
This pragmais especially useful for calling VMS system services, which
return a status value but may also update their parameters. The pragma

IMPORT_VALUED_PROCEDUREisalso useful for calling routines written
in other programming languages that permit such constructs.
The form of the pragmas for importing subprogramsis as follows:
pragma IMPORTFUNCTION
| IMPORTPROCEDURE | IMPORTVALUEDPROCEDURE
(internalname [, externaldesignator]
[,
[,

[PARAMETERTYPES
(RESULTTYPE

=>]
=>]

(parametertypes) ]
typemark]

[MECHANISM

=>]

mechanism]

[,
[,

-- for IMPORTFUNCTION only

[RESULTMECHANISM =>] mechanism_name]
-- for IMPORTFUNCTION only
[FIRSTOPTIONALPARAMETER =>] identifier]);

parametertypes

13.9a.1.1.

Importing Subprograms

::= null

type_mark

typemark}

13—48

mechanism ::=
mechanismname

(mechanism_name

mechanism_name

})

mechanism_name ::= VALUE | REFERENCE
|

DESCRIPTOR

[( [CLASS =>]

classname ::= UBS

| UBSB

class-name) ]

| UBA |

SB | A | NCA

Functions must be uniquely identified by their internal names and parameter and result types. The parameter and result types can be omitted only
if there is exactly one function of that namein the samedeclarative part or
package specification. Otherwise, both the parameter and result types must
be specified.
Procedures must be uniquely identified by their internal names and parameter types. The parameter types can be omitted only if there is exactly one
procedure of that name in the samedeclarative part or package specification.
Otherwise, the parameter types must be specified.
While the internal name can denote a subprogram renaming declaration,
the import pragmaactually applies to the base subprogram declaration.
The base subprogram is obtained by following any sequence of renaming
declarations back to the first nonrenaming subprogram declaration. Except
for the rules related to the internal nameitself, the rules and requirements
for the use of these pragmasare given in termsof the base subprogram.
The external designator denotes a VMSLinker global symbol that is associated with the external subprogram. If no external designator is given,
the internal nameis used as the global symbol. If a null string is given, no
global symbol is defined.
The parameter types option specifies a series of one or more type marks

(type or subtype names), not parameter names. Each type markis positionally associated with a formal parameter in the subprogram’s declaration.
The absence of parameters must be indicated by the reserved word null.
The result type option is used only for functions; it specifies the type or
subtype of the function result.
The mechanism option specifies how the imported subprogram expects
its parameters to be passed (for example, by value, by reference, or by
descriptor). The calling program (namely, the Ada program)is responsible
for ensuring that parameters are passed in the form required by the external
routine. Mechanism options and possible values for mechanism names and
class namesare described in section 13.9a.1.2.

13-49

Importing Subprograms

13.9a.1.1

If the first form of mechanism is given (a single mechanism name without
parentheses), all parameters are passed using that mechanism. If the
second form of mechanism is given (a series of mechanism namesgiven in
parentheses and separated by commas), each mechanism name determines
how the parameter in the sameposition in the subprogram specification
will be passed. With the second form, each parameter name must have an
associated mechanism name.

The result mechanism option specifies how the imported function expects its
result to be returned (for example, by value, by reference, or by descriptor).
The calling program (namely, the Ada program)is responsible for ensuring
that the function result is passed in the form required by the external routine. Possible values for mechanism namesand class namesare described in
section 13.9a.1.2.

Thefirst optional parameter option specifies the nameof the first parameter
that can be omitted from the parameterlist in a call to the imported subprogram. This option is designed to be used with subprogramsthat allow
parameters to be omitted with a truncated argumentlist. It optimizes the
code generated for calls to those subprograms.
The first optional parameter option must specify the name of a formal
parameter of the base subprogram. That formal parameter andall following
formal parameters, if any, of the base subprogram must be of mode in and
must have been specified with default expressions.
Whenthis option is specified, the parameterlist generated for the call to the
imported subprogram is truncated as follows:
¢

13.9a.1.1

Beginning at the end of the parameter list and working back toward
the beginningof the list, actual parameters are omitted—or truncated—
provided that the evaluation of each actual parameter has nosideeffects
(assignments to variables or input-output actions) and provided that one
of the following conditionsis true:
—

The actual parameteris implicit; that is, it has been omitted in the
call to the subprogram,allowing the default expression to takeeffect.

—

The value of the actual parameter is equal to the value of the
corresponding default expression. (This condition is only considered
if the values of both the actual parameter andits default expression
are known at compilation time.)

Truncation stops when either an actual parameter cannot be omitted
or when the actual parameter associated with the formal parameter
specified as the first optional parameter has been omitted.

Importing Subprograms

13-50

If either the actual parameter or the default expression is or contains a
function call, then a determination of equality or of side effects cannot be
made. In other cases, the determination of equality or the absence of side
effects may depend on the specifics of the situation.
In addition to the rules given in section 13.9a, the rules for importing
subprogramsareas follows:
e

If an import pragmais given for a subprogram specification, the pragma
INTERFACE(see 13.9) must also be given for the subprogram earlier
in the same declarative part or package specification. The use of the
pragma INTERFACEimplies that a corresponding bodyis not given.

Ifa subprogram has been declared as a compilation unit, the pragma
is only allowed after the subprogram declaration and before any subsequent compilation unit.

The procedure specification that corresponds to a pragma IMPORT_

VALUED_PROCEDUREmust haveat least one parameter, andthefirst

(or only) parameter must be of mode out.

These pragmas can be used for subprograms declared with a renaming
declaration. The internal name must be a simple name. The given
pragma applies to the named subprogram only if the subprogram that
has been renamed, the renaming declaration, and the pragmaall occur
in that same declarative part or package specification. The pragmais
ignored if these conditions are notsatisfied.

Noneof these pragmas can be used for a generic subprogram or a
generic subprogram instantiation. In particular, they cannot be used for
a subprogram that is declared by a generic instantiation of a predefined
subprogram (such as UNCHECKED_CONVERSION).

Examples:
function SORT

FLOAT)

return FLOAT;

pragma INTERFACE (VAXRTL, SQRT);
pragma

IMPORTFUNCTION

(SORT,

"MTHSSQRT",

(FLOAT),

FLOAT);

In this example, the pragma INTERFACE identifies SQRT as an external
subprogram; the language name argument VAXRTL hasnoeffect. The
pragma IMPORT_FUNCTIONusespositional notation to specify arguments
for importing the declared function SQRT. The pragma form indicates that
the internal name is SQRT, and the external designator is "MTH$SQRT".
The parameter type is FLOAT,and theresult is of the type FLOAT. Because
no parameter or result passing mechanismis specified, default mechanisms
will be used.

13-51

Importing Subprograms

13.9a.1.1

function SQRT (X : LONG_FLOAT) return LONGFLOAT;
pragma INTERFACE (VAXRTL, SQRT) ;

pragma IMPORTFUNCTION

(INTERNAL
=> SQRT,
,
PARAMETERTYPES => (LONGFLOAT),
RESULTTYPE
=> LONGFLOAT,
EXTERNAL
=> "MTHSDSORT") ;

This example shows an alternative way of importing the declared function
SQRT using namednotation and different parameter and result types. If
this example is combined with the code in the first example (that is, with
only one occurrence of the pragma INTERFACE), then the result is an
overloading of SQRT, as follows:
function SORT
function SORT

(X
(X

:
:

FLOAT) return FLOAT;
LONGFLOAT) return LONGFLOAT;

pragma

INTERFACE

pragma

IMPORTFUNCTION

(VAXRTL,

(SQRT,

SQRT);

pragma

IMPORTFUNCTION

(INTERNAL

"MTHSSORT",

PARAMETERTYPES

(FLOAT),

SQRT,

FLOAT);

RESULTTYPE

=> LONGFLOAT,

(LONGFLOAT),

EXTERNAL

"MTHSDSORT") ;

Again, the parameter and result passing mechanismsare not specified,
forcing the use of default mechanisms.
procedure CHANGE

(X,Y :

INTEGER) ;

procedure EXCHANGE (X,Y : INTEGER) renames CHANGE;
pragma INTERFACE (PASCAL, EXCHANGE) ;
pragma IMPORTPROCEDURE (INTERNAL => EXCHANGE,
PARAMETERTYPES => (INTEGER, INTEGER) ) ;

This example shows the use of renaming with an imported procedure(it
is assumed that these declarations occur in a declarative part or package
specification). Note that the renaming causes the imported Pascal procedure
to be used in calls to both of the procedures CHANGE and EXCHANGE;
also note that because no external designator is specified, the linker will
expect the name (global symbol) associated with the Pascal procedure to be
"EXCHANGE".
References: actual parameter 6.2 6.4 6.4.1, allow 1.6, compilation unit 10.1,

declarative part 3.9, external designator 13.9a.1, formal parameter 6.1 6.2, function
6.5, function call 6.4, function result 6.5, generic instantiation 12.3, generic subprogram 12.1, internal name 13.9a.1, name 4.1, null reserved word 2.9, overloading
6.6, package specification 7.1, parameter mode 6.2, positional parameter association
6.4, pragma 2.8, procedure 6.1, procedure specification 6.1, program 10.1, renaming declaration 8.5, reserved word 2.9, result type 5.8, simple identifier 4.1, static
expression 4.9, subprogram 6, subprogram body 6.3, subprogram declaration 6.1,
subprogram specification 6.1, subtype 3.3.2, type 3.3.1, type mark 3.3.2

13.9a.1.1.

Importing Subprograms

13-52

13.9a.1.2

Controlling the Passing Mechanismsfor Parameters and Function Results
The import pragmasallow the option of specifying the passing mechanisms
for parameters and function results of imported subprograms. The three

available mechanism names are VALUE, REFERENCE, and DESCRIPTOR.

These namesforce the use of mechanisms defined in the VAX Procedure
Calling Standard, and they can be used to guarantee that the specified
mechanismsare used.
As shown in 13.9a.1.1, mechanism nameshavethefollowing form:
mechanismname ::=

VALUE | REFERENCE

| DESCRIPTOR [([CLASS =>]

class-name) ]

The namesare briefly defined as follows. Within these definitions, the
term bit string means any one-dimensional array of a discrete type whose
components occupy successive single bits. The term simple record type
meansa record type that does not have a variant part and in which any
constraint for each component and subcomponentis static. A simple record
subtype is a simple record type or a static constrained subtype of a record
type (with discriminants) in which any constraint for each component and
subcomponentof the record typeis static.
VALUE

Specifies that the immediate value of the actual parameteris
passed. Parameters of any type with a compile-time size of
up to 32 bits can be passed by VALUE; theassociated formal
parameters must be of mode in. Note that these rules are
different for the first parameter of a procedure declared with
the pragma IMPORT_VALUED_PROCEDURE(see below).
Whenapplied to a function result, specifies that the result is

returned in registers. Function results of scalar, access, task,

and address types can be returned by VALUE; simple records
and constrained bit strings with a compile-time size of up to

64 bits can also be returned by VALUE.

Whenapplied to the first parameter of a procedure declared
with the pragma IMPORT_VALUED_PROCEDURE,specifies
that the immediate value of the actual parameter is returned
in registers. IMPORT_VALUED_PROCEDUREfirst parameters of scalar, access, task, and address types can be returned

by VALUE; simple records and constrained bit strings with
a compile-time size of up to 64 bits can also be returned by
VALUE. Theassociated formal parameter must be of mode
out.

13-53

Controlling the Passing Mechanisms for Parameters and Function Results

13.9a.1.2

REFERENCE Specifies that the address of the value of the actual parameter or function result is passed or returned. This mechanism
can be used for parameters of any type; it can be used for
function results of any type except an unconstrained type.
DESCRIPTORSpecifies that the address of a VAX descriptor is passed
or returned. Values of any type except a task type or a
record type can be passed or returned by DESCRIPTOR. The
descriptor contains the address of the value of the actual
parameter or function result, plus additional information
about the parameter or function result. The descriptor may
include a class, specified with the following form:
DESCRIPTOR[ ([CLASS =>]

class_name) ]

If the class name is omitted, VAX Ada supplies defaults
based on thetype.
The possible class names and their meaningsfollow.
Ada descriptor

Corresponding VMSclass

class name

code

Used for

UBS

DSC$K_CLASS_UBS

an unaligned bit string whose
lower boundis equal to1

UBSB

DSC$K_CLASS_UBSB

an unaligned bit string with
arbitrary bounds

UBA

DSC$K_CLASS_UBA

an unaligned bit array

DSC$K_CLASS_S

a scalar, access, or address
type, or a string whose lower
boundis equal to 1

DSC$K_CLASS_SB

a string with arbitrary
bounds

DSC$K_CLASS_A

a contiguous array

NCA

DSC$K_CLASS_NCA

a noncontiguous array

For detailed information on which VAX Adatypes can be passed by each
mechanism, see the VAX Ada Run-Time Reference Manual. For information
on the VAX Procedure Calling Standard, see the Introduction to VMS
System Services. For information on how to determine the automatic default
mechanisms used by VAX Ada,see the descriptions of the compilation
command /WARNINGS=COMPILATION_NOTESqualifiers in Developing
Ada Programs on VMSSystems.

13.9a.1.2

Controlling the Passing Mechanisms for Parameters and Function Results

13-54

Examples:
procedure P (X : STRING);
pragma INTERFACE (PASCAL, P);
pragma IMPORTPROCEDURE

(P,

MECHANISM => DESCRIPTOR

(A));

In this example, the arguments given for the pragma IMPORT_PROCEDURE
indicate that the DESCRIPTOR mechanism and the A descriptor class are
to be used to pass the formal parameter X. In other words, this pragma instructs the compiler to pass the address of a VMS descriptor using descriptor

class DSC$K_CLASS_A.

type BITSTRING is array (1..32) of BOOLEAN;

pragma PACK (BITSTRING) ;
function F (Y : BITSTRING) return INTEGER;
pragma INTERFACE (C, F);
pragma IMPORTFUNCTION (INTERNAL => F,
MECHANISM => VALUE,
RESULTMECHANISM => VALUE) ;

In this example, the arguments given for the pragma IMPORT_FUNCTION
indicate that the VALUE mechanism is to be used to pass the formal parameter Y and the function result. In other words, this pragma instructs the
compiler to pass the immediate value of the actual parameter for Y in the
argumentlist and to return the immediate value of the function result in a
register.
procedure TRNLNM (
STATUS:
ATTR
:
TABNAM:

out INTEGER;
in
SYSTEM.UNSIGNEDLONGWORD;
in
LOGICALNAMETYPE;

ACMODE:
ITMLST:

in
in

LOGNAM: in

LOGICALNAMETYPE;

ACCESSMODETYPE;
ITEM_LIST_TYPE);

pragma INTERFACE (SYSSERV, TRNLNM) ;

pragma IMPORTVALUEDPROCEDURE (
INTERNAL => TRNLNM,
EXTERNAL => "SYSSTRNLNM",
PARAMETERTYPES =>
(INTEGER, SYSTEM.UNSIGNEDLONGWORD,
LOGICALNAMETYPE, LOGICALNAMETYPE,
ACCESSMODETYPE, ITEMLISTTYPE),
MECHANISM =>
(VALUE, REFERENCE,
DESCRIPTOR(S), DESCRIPTOR(S),
REFERENCE, REFERENCE) ) ;

13-55

Controlling the Passing Mechanisms for Parameters and Function Results

13.9a.1.2

This example shows an Adainterface for the VMS system service routine
SYS$TRNLNM.Like most system services, SYS$TRNLNM returnsa status
result by value, in a register. In the Ada interface procedure, TRNLNM,

the first parameter, STATUS, is intended to receive the SYS$TRNLNM
status result. The IMPORT_VALUED_PROCEDUREpragmacausesthe
STATUS parameter to be treated as both an out parameter(it has an actual
parameter) and a function result (if the VALUE mechanism isspecified, the
result is returned in registers). Because the VALUE mechanism isspecified
for this parameter, it is guaranteed to be passed correctly (by value), and the
result is returned in a register.
If the VALUE mechanism had not been specified, the default mechanism for the STATUS parameter would have been REFERENCE,because REFERENCEis the default mechanism for parameters of the type
INTEGER. Use of the REFERENCE mechanism would have causedthecall
to TRNLNM to return an unexpected result (an address instead of an actual
value).
References: access type 3.8, actual parameter 6.4, address type 13.7 13.7a.1,
argument 2.8, discrete type 3.5, formal parameter mode 6.2, full type 7.4.1, private
type 7.4 7.4.1, record type 3.7, scalar type 3.5, static 4.9, type declaration 3.3.1

13.9a.1.3

Attribute for Optional Parameters in Imported VMS Routines
The VAX Procedure Calling Standard provides conventions for optional
arguments in VMSroutines (any non-Ada routines) that differ substantially
from the conventions for default parameters in Ada subprograms. In an
Ada subprogram with default parameters, the values of the parameters (if
specified or absent) are evaluated during the call to the subprogram. In a
non-Ada routine, the absence of a parameteris indicated by a “shortened”
argumentlist and/or by an argumentlist entry containing the address zero
(for arguments that are passed by reference or by descriptor). In these cases,
depending on the kind of routine involved, default actions may be taken by

the routine. The VAX Ada attribute NULL_PARAMETERallows the VMS

conventions for optional arguments in non-Ada routines to be usedin calls
to imported subprograms.
For any type or subtypeT:

T’ NULL_PARAMETER Denotes an (imaginary) object of type or subtype T
allocated at (machine) address zero. The attribute
is allowed only as the default expression of a
formal parameter or as an actual expression of a
subprogram call; in either case, the subprogram
must be imported.

13.9a.1.3

Attribute for Optional Parameters in Imported VMS Routines

13-56

The identity of the object is represented by the
address zero in the argumentlist, independent of
the passing mechanism (explicit or default).
Example:
procedure CRMPSC

(

STATUS: out CONDVALUETYPE;
INADR:

ADDRESSRANGETYPE

>= ADDRESSRANGETYPE’NULLPARAMETER;
RETADR: in
ADDRESS
>= ADDRESSZERO;
ACMODE: in
ACCESSMODETYPE
>= ACCESSMODEZERO;
FLAGS:
in
UNSIGNEDLONGWORD
>= 0;
GSDNAM: in
SECTIONNAMETYPE
>= SECTIONNAMETYPE’ NULLPARAMETER;
IDENT:
in
SECTIONIDTYPE
:= SECTIONIDTYPE’ NULLPARAMETER;
RELPAG: in
UNSIGNEDLONGWORD
:= 0;
CHAN:
in
CHANNELTYPE
>= CHANNELZERO;
PAGCNT: in
UNSIGNEDLONGWORD
= 0;
VBN:
in
UNSIGNEDLONGWORD
= 0;
PROT:
in
FILEPROTECTIONTYPE
:= FILEPROTECTIONZERO;

PFC:
in UNSIGNED_LONGWORD
>= 0);
pragma INTERFACE (EXTERNAL, CRMPSC) ;
pragma IMPORTVALUEDPROCEDURE (—
INTERNAL => CRMPSC,
EXTERNAL => "SYSSCRMPSC",
PARAMETERTYPES => (CONDVALUETYPE, ADDRESSRANGETYPE, ADDRESS,
ACCESSMODETYPE, UNSIGNEDLONGWORD, SECTIONNAMETYPE,

SECTIONIDTYPE, UNSIGNEDLONGWORD, CHANNELTYPE,

UNSIGNEDLONGWORD, UNSIGNEDLONGWORD, FILEPROTECTIONTYPE,
UNSIGNEDLONGWORD) ,
MECHANISM => (VALUE, REFERENCE, VALUE, VALUE, VALUE,
DESCRIPTOR(S), REFERENCE, VALUE, VALUE, VALUE, VALUE,
VALUE, VALUE) );

This example is one of the interfaces declared in the VAX Ada package
STARLET for the VMS system service SYS$CRMPSC.Default values
are specified for all of the parameters except for the STATUS parameter
becauseall of the parameters to SYS$CRMPSCare optional. Note the use
of the VAX Ada attribute NULL_PARAMETERto give default values to the
INADR, GSDNAM, and IDENT parameters. These parameters are passed
by reference, descriptor, and reference, respectively. Because of their passing
mechanisms, they cannot be given the zero default values (0, ADDRESS_
ZERO, and so on) that can otherwise be given to parameters that are passed
by value.
References: attribute 4.1.4, formal parameter 6.2, object 3.2 3.2.1, parameter

6.2, parameter passing 13.9a.1.2, subprogram 6, subprogram call 6.4, subtype 3.3,
system.address_zero 13.7a.1, type 3.3

13-57

Attribute for Optional Parameters in Imported VMS Routines

13.9a.1.3

13.9a.1.4

Exporting Subprograms
VAX Ada provides three pragmas for exporting subprograms: EXPORT_
FUNCTION, EXPORT_PROCEDURE, and EXPORT_VALUED_PROCEDURE.
All three export pragmas establish an external namefor a subprogram and
make the nameavailable to the VMS Linker as a global symbol, so that the
subprogram can be called by a non-Ada routine.
The pragmas EXPORT_FUNCTION and EXPORT_PROCEDUREallow
the export of the kind of subprograms indicated. The pragma EXPORT_
VALUED_PROCEDUREallows an external (non-Ada) routine to call an

Ada procedure that, like a function, returns a result value, but that, like

a procedure, can cause side effects on its parameters (a function with in
out or out parameters is not legal in Ada). In other words, the pragma
EXPORT_VALUED_PROCEDUREallowsa procedure written in Ada to be
interpreted as a function in the external environment; the function result
is returned in the first parameter. The pragmais especially useful for
writing Ada subprogramsthat are called by external routines, where the
Ada subprogram involved is expected to return a status value and may
update its parameters.
The form of the pragmas for exporting subprogramsis asfollows:
pragma EXPORTFUNCTION
| EXPORTPROCEDURE | EXPORTVALUEDPROCEDURE
(internalname [, externaldesignator]

[,
(,

[PARAMETER_TYPES =>] (parametertypes) ]
[RESULTTYPE
=>] type_mark]); -- for EXPORTFUNCTION
-- only

parametertypes

::= null

typemark

typemark}

13.9a.1.4

Exporting Subprograms

13-58

The parameter types option specifies a series of one or more type marks
(type or subtype names), not parameter names. Each type markispositionally associated with a formal parameter in the subprogram’s declaration.
The absence of parameters must be indicated by the reserved word null.
The result type option is used only for functions; it specifies the type or
subtype of the function result.
In addition to the rules given in section 13.9a, the rules for exporting
subprogramsare as follows:
An exported subprogram must be a library unit or must be declared in
the outermost declarative part of a library package. Thus, pragmasfor
exporting subprogramsare allowed only in the following cases:
—

For a subprogram specification or a subprogram body that is a
library unit.

—

For a subprogram specification that is declared in the outermost
declarations of a package specification or a package body that is a
library unit.

—

For a subprogram body thatis declared in the outermost declarations
of a package body that is a library unit.

Consequently, an export pragma for a subprogram bodyis allowed only
if either the body does not have a correspondingspecification, or if the
specification and body occur in the samedeclarative part.
This set of rules implies that a pragma EXPORT_FUNCTION,
EXPORT_PROCEDURE, or EXPORT_VALUED_PROCEDUREcannot be given for a generic library subprogram, nor can one be givenfor a
subprogram declared in a generic library package. However, any of these
pragmas maybe given for a subprogram resulting from the instantiation of a generic subprogram, provided that the instantiation otherwise
satisfies this set of rules.

In the case of a subprogram declared as a compilation unit, the pragma
is only allowed after the subprogram declaration and before any subsequent compilation unit.
The procedure specification that corresponds to a pragma EXPORT_
VALUED_PROCEDUREmust have at least one parameter, andthefirst
(or only) parameter must be of mode out.
None of these pragmas can be used for a subprogram thatis declared
with a renaming declaration.
None of these pragmas can be used for a subprogram that is declared
by a generic instantiation of a built-in library subprogram (such as
UNCHECKED_CONVERSION).
13-59

Exporting Subprograms

13.9a.1.4

Examples:
procedure PROC (X : INTEGER);
pragma EXPORTPROCEDURE (PROC) ;

This example shows an export pragma that causes the Ada procedure
PROCto be exported for use in a non-Ada routine. The name PROC will be
declared as a VMSLinker global symbol.
procedure MULTIPLY

(X : out INTEGER;
Y : in out INTEGER)

is
begin
X := 10*Y;
end;
pragma EXPORTVALUEDPROCEDURE (
INTERNAL => MULTIPLY,
PARAMETERTYPES => (INTEGER, INTEGER) ) ;
PROGRAM CallAda
VAR
A

OUTPUT) ;

INTEGER;

FUNCTION Multiply
BEGIN
A

(INPUT,

(VAR T

INTEGER)

INTEGER;

EXTERN;

Multiply (A) ;

END.

This example shows an Ada procedure being used as a function in a Pascal
program. Becauseof the use of pragma EXPORT_VALUED_PROCEDURE,
the first parameter of the Ada procedure MULTIPLYis recognized as a function result in the Pascal program Call_Ada; the value of the Ada parameter
X is assigned to the Pascal variable A.
References: allow 1.6, compilation unit 10.1, declarative part 3.9, external
designator 13.9a.1, formal parameter 6.1, function result 6.5, generic package 12,
generic subprogram 12, instantiation 12.3, internal name 13.9a.1, library unit 10.1,
package body 7.3, package specification 7.1, parameter 6.2, parameter name6.1,
pragma 2.8, procedure 6 6.1, renaming declaration 8.5, reserved word 2.9, result
type 5.8, simple identifier 4.1, subprogram 6, subprogram body 6.3, subprogram
declaration 6.1, subprogram specification 6.1, subtype name 3.3.2, type mark 3.3.2,
type name 3.3.1
,

13.9a.1.4

Exporting Subprograms

13-60

13.9a.2

Importing and Exporting Objects
VAX Ada provides three pragmas for importing and exporting objects:
IMPORT_OBJECT, EXPORT_OBJECT, and PSECT_OBJECT. The pragma
IMPORT_OBJECTreferences storage declared in an external (non-Ada)
routine. The pragma EXPORT_OBJECTallows an external routineto refer
to the storage allocated for an Ada object. The pragma PSECT_OBJECT
allows both Ada and non-Ada programsto share storage declared in linker
program sections; thus, the pragma PSECT_OBJECT functions as both an
import and an export pragma.
In addition to the rules given in section 13.9a, the rules for importing and
exporting objects are as follows:
e

The object to be imported or exported must be a variable declared
by an object declaration at the outermost level of a library package
specification or body.

The subtype indication of an object to be imported or exported must
denote one of the following:
—

Avscalar type or subtype.

—

An array subtype with static index constraints whose componentsize
is static.

—

A record type or subtype that does not have a variant part and in
which any constraint for each component and subcomponentis static
(a simple record type or subtype).

Import and export pragmasare not allowed for objects declared with a
renaming declaration.

Import and export pragmasfor objects are not allowed in a generic unit.

Notes:

Objects of private or limited private types may not be imported or exported
outside of the package that declares the (limited) private type. They may
be imported or exported inside the body of the package wherethetypeis
declared (that is, where the full type is known).
The VAX Ada pragmasfor importing or exporting objects can precede or
follow a pragma VOLATILEfor the sameobjects (see 9.11).
Address clauses are not allowed in combination with any of the VAX Ada
pragmasfor importing or exporting objects. If usedin such cases, the
pragmainvolvedis ignored (see 13.5).

13-61

Importing and Exporting Objects

13.9a.2

References: array subtype 3.6, component 3.3, discriminant 3.3, generic unit 12

12.1, index constraint 3.6, limited private type 7.4.4, object 3.2, object declaration
3.2.1, package body 7.3, package specification 7.1, pragma 2.8, private type 7.4
7.4.1, record type 3.7, renaming declaration 8.5, scalar type 3.5, simple record type
13.9a.1.2, static constraint 4.9, subcomponent 3.3, subtype 3.3 3.3.2, variable 3.2.1,
variant part 3.7.3

13.9a.2.1

Importing Objects
The VAX Ada pragma IMPORT_OBJECTspecifies that the storage allocated
for the object (when the external routine is compiled) be made known to the
calling Ada program by an externally defined VMSLinker global symbol.
The form of this pragmais asfollows:
pragma IMPORTOBJECT
(internalname [, externaldesignator]
(,

(SIZE =>]

external_symbol]);

The size option specifies a VMS Linker absolute global symbol that will

be defined in the object module. Because the value of the absolute global
symbol will equal the size in bytes of the imported object, the size option
may be used to achieve somelevel of link-time consistency checking. See the
VAX Ada Run-Time Reference Manual for more information.
Because it is not created by an Ada elaboration, an imported object cannot
have an initial value. Specifically, this restriction means that the object to
be imported:
e

Cannot be a constant (have an explicit initial value).

Cannot be an access type (which has a default initial value of null).

e¢

Cannot be a record type that has discriminants (which are always
initialized) or components with default initial expressions.

Cannot be an object of a task type.

Example:
PID: INTEGER;
pragma IMPORTOBJECT

(PID,

"PROCESSSID",

PSIZE);

In this example, the variable PID refers to the externally defined symbol
PROCESSS$ID. The symbol PSIZE represents the default size for the symbol
PROCESSS$ID.In this case, PSIZE is 4 because PID is declared to be of type
INTEGER,for which the Ada default is 4 bytes.
13.9a.2.1

Importing Objects

13-62

Alternatively, this example can be written in named notation, as follows:
PID : INTEGER;
pragma IMPORTOBJECT

(INTERNAL => PID,
EXTERNAL => "PROCESSSID",
SIZE
=> PSIZE);

References: access type 3.8, component 3.3 3.7, constant 3.2.1, default initial
value 3.8, discriminant 3.7.1, elaboration 3.1, expression 4.4, external designator
13.9a.1, external symbol 13.9a.1, identifier 2.3, implicit initial value 3.2.1, internal
name 13.9a.1, integer type 3.5.4, object 3.2, pragma 2.8, record type 3.7, string
literal 2.6 4.2, task type 9.2

13.9a.2.2

Exporting Objects
The VAX Ada pragma EXPORT_OBJECTspecifies that the storage allocated
for the object (when the Ada program is compiled) be made known to other
non-Ada programs by a VMSLinkerglobal symbol.
The form of this pragmais as follows:
pragma EXPORTOBJECT

(internalname [, externaldesignator]
[,

[SIZE =>] externalsymbol]);

The internal nameis the object identifier. The external designator denotes a
VMSLinker global symbol that is associated with the external object. If no
external designator is given, the internal nameis usedasthe global symbol.
The size option specifies a VMSLinker absolute global symbol that will
be defined in the object module. Because the value of the absolute global
symbol will equal the size in bytes of the imported object, the size option
may be used to achieve somelevel of link-time consistency checking. See the
VAX Ada Run-Time Reference Manual for more information.
Example:
PID: INTEGER;
pragma EXPORTOBJECT

(PID,

"PROCESSSID") ;

Alternatively, this example can be written in named notation, as follows:
PID: INTEGER;
pragma EXPORTOBJECT (INTERNAL => PID,
EXTERNAL => "PROCESSSID") ;
References: external designator 13.9a.1, external symbol 13.9a.1, identifier 2.3,
internal name 13.9a.1, object 3.2, pragma 2.8,

13-63

Exporting Objects

13.9a.2.2

13.9a.2.3

Importing and Exporting Objects with the Pragma PSECT_OBJECT
The pragma PSECT_OBJECT enables shared use of variables that are
stored in overlaid linker program sections (which are also known aspsects).
Thus, the pragma PSECT_OBJECTis useful for referring to FORTRAN or
BASIC commonblocks, external variables in PL/I, extern variables in C, or

a Pascal variable with the COMMONattribute.

The pragma PSECT_OBJECTallows only one object to beallocated in a
particular program section. As with imported objects, an object that is
specified with the pragma PSECT_OBJECT maynot havean initial value
(see 13.9a.2.1).
The form of this pragmaisas follows:
pragma PSECTOBJECT
(internal_name [, externaldesignator]
[, [SIZE =>] external_symbol]);

The internal name must be an Adaidentifier that denotes a variable. The
external designator names the program section, which can be either an
Adaidentifier or a string denoting a VMS name. When a pragma PSECT_
OBJECT is used for exporting an object, the external designator establishes
the name of the program section. When a pragma PSECT_OBJECTis used
for importing an object, the external designator refers to an existing (external) program section. If no external designator is provided, the internal
nameis used as the nameof the program section.
The size option specifies a VMS Linker absolute global symbol that will
be defined in the object module. Because the value of the absolute global
symbol will equal the size in bytes of the imported object, the size option
may be used to achieve somelevel of link-time consistency checking. See the
VAX Ada Run-Time Reference Manual for more information.
Note:

Unlike other VAX languages, VAX Ada allows only one object to be stored
in a program section. However, by using record objects, the effect of storing
multiple objects in one program section can be achieved. Each record
component then correspondsto one external variable.

13.9a.2.3

Importing and Exporting Objects with the Pragma PSECT_OBJECT

13-64

Example:
type BLOCK is
record
X1, X2, X3
end record;

XS : BLOCK;
pragma PSECTOBJECT

FLOAT;

(XS);

This example of the pragma PSECT_OBJECTshowstheallocation of the
record variable XS with three components (X1, X2, X3) of the type FLOAT in
the program section XS. The nameof the program section is assumed to be
the internal name XS because no external designatoris given.
The code in this example represents the same program section as the
following named FORTRAN commonblock:
COMMON /XS/ X1, X2, X3

References: component type 3.7, external designator 13.9a.1, external symbol
13.9a.1, identifier 2.3, internal name 13.9a.1, object 3.2, pragma 2.8, record type 3.7,
string 3.6.3, variable 3.2.1

13.9a.3

Importing and Exporting Exceptions
VAX Ada provides the pragmas IMPORT_EXCEPTION and EXPORT_
EXCEPTIONfor importing and exporting exceptions. The pragma IMPORT_
EXCEPTIONallows non-Ada (especially VMS) exceptions to be used in Ada
programs; the pragma EXPORT_EXCEPTIONallows Ada exceptions to
be used by external modules. For clarity in describing these pragmas, the
terms exception and Ada exception are used to refer to Ada exceptions as
described in chapter 11; the terms condition and VAX condition are used
to refer to VAX conditions as defined in the Introduction to VMS System
Services.
The rules for importing and exporting exceptions are given in section 13.9a;
any additional rules that apply are describedin the following sections. Note
that import and export pragmasare not allowed for exceptions declared with
a renaming declaration.
Note:

A pragmafor an exception that is declared in a package specification is not
allowed in the package body.
References: exception 11, exception declaration 11.1, package body 7.3, package
specification 7.1, pragma 2.8, renaming declaration 8.5

13-65

Importing and Exporting Exceptions

13.9a.3

13.9a.3.1

Importing Exceptions
The VAX Ada pragma IMPORT_EXCEPTIONallows VAX conditions (for
example, from VMSsystem services or other VAX languages) to be propagated to Ada programs as Ada exceptions. This pragmaspecifies that the
exception associated with an exception declaration in an Ada program be
defined externally (in non-Adacode).
The form of this pragmais as follows:
pragma IMPORTEXCEPTION

(internalname [, externaldesignator]
[,

[FORM =>] ADA | VMS]

[CODE =>] static_integer_expression]);

The internal name must be an Adaidentifier that denotes a declared exception. The external designator denotes a VMS Linker global symbolto be
used to refer to the exception. If no external designator is given, the internal
nameis used as the global symbol.
The form option indicates whether an Ada exception or a VAX condition is
being imported. Thus, ADA mustbe specified if an Ada exception is being
imported; VMS(the default) must be specified if a VAX condition is being
imported.
If the exception form ADAis specified, then the external designator refers
to the address of an Ada exception name(the address of a counted ASCII
string that namesthe exception). If the exception form VMSis specified,
then the external designator refers to the value of a 32-bit condition value,
which is determined according to VMS conventions.
If the exception code option is specified (it must be in the range

MIN_INT..MAX_INT), then it is interpreted as the 32-bit value of a standard

VAX condition value. This option is legal only if VMSis also specified for
the form option either explicitly or by default. Further, if an exception code
option is specified, then it is not legal to also specify an external designator
(to do so would imply two definitions of the exception code value).

VMScondition values are defined in the Introduction to VMS System
Services; the VAX Ada Run-Time Reference Manual explains the specification
of code options in more detail.
Example:
ACCVIO : exception;
pragma IMPORTEXCEPTION

13.9a.3.1

Importing Exceptions

(ACCVIO,

"SS$_ACCVIO");

13-66

In this example, the VAX condition SS$_ACCVIOis imported as the global

symbol SS$_ACCVIO.It is referred to within the Ada program by the

internal name ACCVIO, andthe value of the form option is the

default (VMS).

References: exception 11, exception declaration 11.1, exception propagation 11.4.1
11.4.2, expression 4.4, external designator 13.9a.1, identifier 2.3, internal name
13.9a.1, pragma 2.8, system.max_int 13.7, system.min_int 13.7

13.9a.3.2

Exporting Exceptions
The VAX Ada pragma EXPORT_EXCEPTION allows Ada exceptions to be
propagated outside of the Ada program, so that they can be handled by
programs written in other VAX languages. This pragma establishes an
external name for an Ada exception and makes the nameavailable to the
VMSLinkeras a global symbol.
The form of this pragmais as follows:
pragma EXPORTEXCEPTION
(internalname [, externaldesignator]

[,
[,

[FORM =>] ADA | VMS]
[CODE =>] static_integer_expression]);

The internal name must be an Adaidentifier that denotes a declared exception. The external designator denotes a VMSLinker global symbol to be
used to refer to the exception.
The form option indicates whether an Ada exception or a VAX condition is
being exported. Thus, ADA must be specified if an Ada exception is being
exported; VMS (the default) must be specified if a VAX condition is being
exported.
If the form ADAis specified, then the external designator refers to the
address of an Ada exception name(the address of a counted ASCII string
that namesthe exception).
If the form VMSisspecified, the code option must be specified. The value for

the code option must be in the range MIN_INT..MAX_INT,andis interpreted

as a standard VAX condition value. The external designator denotes a VMS
Linker global symbol for the condition value. If no external designatoris
specified, the internal nameis used as the global symbol.

VAX condition values are defined in the Introduction to VMS System
Services; the VAX Ada Run-Time Reference Manual explainsthespecification
of code options in more detail.

13-67

Exporting Exceptions

13.9a.3.2

In addition to the rules given in section 13.9a, the rules for exporting
exceptions include the following:
e

The EXPORT_EXCEPTIONpragmais not allowed for exceptions that
are declared in a generic unit.

Example:
ACCVIO : exception;
pragma EXPORTEXCEPTION

(ACCVIO,

"MYPACKAGESACCVIO",

ADA);

In this example, an Ada exception is exported as a global symbol.
References: exception 11, exception declaration 11.1, identifier 2.3, pragma
2.8, propagation of an exception 11.4.1 11.4.2, string 3.6.3, system.max_int 13.7,
system.min_int 13.7

13.10 Unchecked Programming
1

The predefined generic library subprograms UNCHECKED_DEALLOCATION
and UNCHECKED_CONVERSIONare used for unchecked storage dealloca-

tion and for unchecked type conversions.

generic
type OBJECT is limited private;
type NAME
is access OBJECT;
procedure UNCHECKEDDEALLOCATION(X : in out NAME) ;
generic
type SOURCE is limited private;
type TARGET is. limited private;
function UNCHECKEDCONVERSION(S

SOURCE)

return TARGET;

References: generic subprogram 12.1, library unit 10.1, type 3.3

13.10.1

Unchecked Storage Deallocation
Unchecked storage deallocation of an object designated by a value of
an access type is achieved by call of a procedure that is obtained by
instantiation of the generic procedure UNCHECKED_DEALLOCATION.
For example:22
procedure FREE is new UNCHECKEDDEALLOCATION (object_typename,
accesstypename) ;

22 See also Appendix G, AI-00355.

13.10.1

Unchecked Storage Deallocation

13-68

Such a FREEprocedure hasthe followingeffect:

(a)

after executing FREE(X), the value of X is null;

(b)

FREE(X), when X is already equal to null, has noeffect;

(c)

FREE(CX), when X is not equal to null, is an indication that the object
designated by X is no longer required, and that the storage it occupies
is to be reclaimed.

If X and Y designate the same object, then accessing this object through Y is
erroneous if this access is performed (or attempted) after the call FREE(X);
the effect of each such access is not defined by the language.
Notes:

It is a consequenceof the visibility rules that the generic procedure.

UNCHECKED_DEALLOCATIONis not visible in a compilation unit unless this generic procedure is mentioned by a with clause that applies to the

compilation unit.2%

If X designates a task object, the call FREE(X) has noeffect on the task
designated by the value of this task object. The same holds for any subcomponent of the object designated by X, if this subcomponentis a task
object.
Because UNCHECKED_DEALLOCATIONis a predefined generic procedure,
VAX Ada does not allow the use of theIMPORT_PROCEDUREpragmato
substitute an alternative procedure body.

References: access type 3.8, apply 10.1.1, compilation unit 10.1, designate 3.8 9.1,

erroneous 1.6, generic instantiation 12.3, generic procedure 12.1, generic unit 12,

library unit 10.1, null access value 3.8, object 3.2, procedure 6, procedurecall 6.4,
subcomponent 3.3, task 9, task object 9.2, visibility 8.3, with clause 10.1.1
pragma import_procedure 13.9a.1.1, procedure body 6.3

13.10.2
1

Unchecked Type Conversions
An unchecked type conversion can be achieved bya call of a function
that is obtained by instantiation of the generic function UNCHECKED_
CONVERSION.?4

23 See also Appendix G, AI-00356.

24 See also Appendix G, AI-00355.
13-69

Unchecked Type Conversions

13.10.2

The effect of an unchecked conversion is to return the (uninterpreted)
parameter value as a value of the target type, that is, the bit pattern
defining the source value is returned unchangedas the bit pattern defining
a value of the target type. An implementation mayplace restrictions on
unchecked conversions, for example, restrictions depending on the respective
sizes of objects of the source and target type. Such restrictions must be
documented in Appendix F.
VAX Ada supports the generic function UNCHECKED_CONVERSIONwith
the following restrictions on the class of types involved:
e

The actual subtype corresponding to the formal type TARGET must not
be an unconstrained array type.

The actual subtype corresponding to the formal type TARGET must not
be an unconstrained type with discriminants.

Further, when the target type is a type with discriminants, the valueresulting from a call of the conversion function resulting from an instantiation of
UNCHECKED_CONVERSIONis checked to ensure that the discriminants
satisfy the constraints of the actual subtype.
If the size of the source value is greater than the size of the target subtype,
then the high orderbits of the value are ignored (truncated); if the size of
the source value is less than the size of the target subtype, then the valueis
extended with zero bits to form the result value.
3

Whenever unchecked conversions are used, it is the programmer’s responsibility to ensure that these conversions maintain the properties that are

guaranteed by the languagefor objects of the target type. Programs that
violate these properties by means of unchecked conversions are erroneous.
Note:

It is a consequence of the visibility rules that the generic function
UNCHECKED_CONVERSIONis not visible in a compilation unit unless
this generic function is mentioned by a with clause that applies to the
compilation unit.

References: apply 10.1.1, compilation unit 10.1, erroneous 1.6, generic function
12.1, instantiation 12.8, parameter of a subprogram 6.2, type 3.3, with clause 10.1.1
actual subtype 12.3, discriminant 3.3 3.7.1, formal type 12.1, unconstrained array
type 3.6, unconstrained type 3.3

13.10.2

Unchecked Type Conversions

13-70

Chapter 14

Input-Output
Input-output is provided in the language by meansof predefined packages.
The generic packages SEQUENTIAL_IO and DIRECT_IO define inputoutput operations applicable to files containing elements of a given type.
Additional operations for text input-output are supplied in the package
TEXT_IO. The package IO_EXCEPTIONSdefines the exceptions needed by
the above three packages. Finally, a package LOW_LEVEL_IO is provided
for direct control of peripheral devices.
In addition to SEQUENTIAL_IO, DIRECT_IO, and TEXT_IO, VAX Ada
provides packages for relative and indexed accessto files, as well as
packages for handlingfiles containing elements of mixed types. Thus, VAX
Ada provides a total of nine predefined input-output packages:
e

SEQUENTIAL_IO

DIRECT_IO

TEXT_IO

RELATIVE_IO

INDEXED_IO

SEQUENTIAL_MIXED_IO

DIRECT_MIXED_IO

RELATIVE_MIXED_IO

INDEXED_MIXED_IO

In addition to the package IO_EXCEPTIONS, VAX Ada provides the package
AUX_IO_EXCEPTIONS,which defines the exceptions needed by therelative
and indexed input-output packages.

VAX Ada does not provide the package LOW_LEVEL_IO.Instead, the
library packages STARLET and TASKING_SERVICESare provided. See
the VAX Ada Run-Time Reference Manual for more information.

Complete descriptions and specifications for the VAX Ada predefined
input-output and exceptions packages appearin the sections that follow.
Detailed information on VAX Ada input-output processing can be found in
the VAX Ada Run-Time Reference Manual.
2

References : direct_io package 14.2 14.2.4, io_exceptions package 14.5,
low_level_io package 14.6, sequential_io package 14.2 14.2.2, text_io package 14.3
aux_io_exceptions package 14.4 14.5a, direct access 14.2, direct_mixed_io package
14.2 14.2b 14.2b.5, element 14.1a, indexed access 14.2a, indexed_io package 14.2a
14.2a.4, indexed_mixed_io package 14.2a 14.2b 14.2b.9, library package 10.1,
mixed-type file 14.2b, relative access 14.2a, relative_io package 14.2a 14.2a.2,
relative_mixed_io package 14.2a 14.2b 14.2b.7, sequential access 14.2, sequential_
mixed_io package 14.2 14.2b 14.2b.3

14.1.

External Files and File Objects
1

Values input from the external environment of the program, or output to the
environment, are considered to occupy external files. An external file can

be anything external to the program that can produce a value to be read
or receive a value to be written. An externalfile is identified by a string
(the name). A second string (the form) gives further system-dependent
characteristics that may be associated with the file, such as the physical
organization or access rights. The conventionsgoverning the interpretation
of such strings must be documented in Appendix F.!
The VAX Ada interpretation of form strings is also described in
section 14.1b.

Input and output operations are expressed as operations on objects of some

file type, rather than directly in terms of the external files. In the remainder
of this chapter, the term file is always usedto refer to a file object; the term
external file is used otherwise. The values transferred for a given file must
all be of one type.
VAX Ada uses VMS Record Management Services (RMS) to perform
operations on externalfiles. The attributes of the external file, the storage
medium, and the input-output package determine which operations can be
used to manipulate data. VAX Adaalso supportsfiles that contain values of
mixed types; see section 14.2b.

1 See also Appendix G, AI-00355.
14.1.

External Files and File Objects

14-2

Input-output for sequential files of values of a single element type is defined
by means of the generic package SEQUENTIAL_IO. The skeleton of this
package is given below.
with IOEXCEPTIONS;

generic
type ELEMENTTYPE is private;
package SEQUENTIALIO is

type FILETYPE is limited private;
type FILEMODE is

(INFILE,

OUTFILE);

procedure OPEN

(FILE : in out FILETYPE;

procedure READ

(FILE : in FILETYPE;

ITEM
procedure WRITE(FILE
ITEM

:
:
:

...);

out ELEMENTTYPE) ;
in FILETYPE;
in ELEMENTTYPE);

end SEQUENTIALI0;

In order to define sequential input-output for a given element type, an

instantiation of this generic unit, with the given type as actual parameter,

must be declared. The resulting package contains the declarationofa file

type (called FILE_TYPE)for files of such elements, as well as the operations

applicable to thesefiles, such as the OPEN, READ, and WRITEprocedures.

Input-output for direct accessfiles is likewise defined by a generic package

called DIRECT_IO. Input-output in human-readable form is defined by the
(nongeneric) package TEXT_IO.
In VAX Ada, input-output for sequential accessfiles is also defined by the
(nongeneric) package SEQUENTIAL_MIXED_IO. Similarly, input-output for
direct access files is defined by the (nongeneric) package DIRECT_
MIXED_IO.
Input-output for relative and indexedaccesstofiles is available in VAX Ada.
Relative access to files is defined by the generic package RELATIVE_IO and
the (nongeneric) package RELATIVE_MIXED_IO. Indexed accessto files is
defined by the generic package INDEXED_IO andthe (nongeneric) package
INDEXED_MIXED_IO.

Before input or output operations can be performed on file, the file must

first be associated with an external file. While such an association is in
effect, the file is said to be open, and otherwisethefile is said to be closed.

External Files and File Objects

14.1

The language does not define what happens to external files after the
completion of the main program (in particular, if correspondingfiles
have not been closed). The effect of input-output for access types is
implementation-dependent.”
In VAX Ada, input-output for access types is erroneous.
An openfile has a current mode, which is a value of one of the enumeration
types
type FILEMODE is

(INFILE, INOUTFILE, OUTFILE);

type FILEMODE is

(INFILE, OUTFILE);

----

for DIRECTIO
for SEQUENTIALIO

and TEXTIO

These values correspond respectively to the cases where only reading, both
reading and writing, or only writing are to be performed. The modeofa file
can be changed.
For the six additional VAX Ada input-output packages, an openfile’s current
mode maybeoneofthe following values:

type FILEMODE is
(INFILE, INOUTFILE, OUTFILE); -- for RELATIVE_IO,
-- DIRECTMIXEDI0,
-- RELATIVEMIXEDIO,
-- INDEXEDIO, and
-- INDEXEDMIXEDIO
type FILEMODE is

(INFILE, OUTFILE) ;

-- for SEQUENTIALMIXEDIO

Several file management operations are commonto the three input-output
packages. These operations are described in section 14.2.1 for sequential
and direct files. Any additional effects concerning text input-output are

described in section 14.3.1.

The file management operations for the six additional VAX Ada input-output
packages are essentially the same as those described in section 14.2.1 for
sequential and direct files. Differences and additional effects are described
in section 14.2a.1 for relative and indexed input-output and in section
14.2b.1 for mixed input-output.

2 See also Appendix G, AI-00466.
External Files and File Objects

14—4

+The exceptions that can be raised by a call of an input-output subprogram

are all defined in the package IO_EXCEPTIONS; the situations in which

they can be raised are described, either following the description of the

subprogram (and in section 14.4), or in Appendix F in the case of error
situations that are implementation-dependent.®

All of the VAX Ada input-output packages use the package IO_EXCEPTIONS;
the VAX Ada packages RELATIVE_IO, INDEXED_JO, RELATIVE_MIXED_
IO, and INDEXED_MIXED_IO also use the additional package AUX_

IO_EXCEPTIONS.See section 14.5a for information on these auxiliary
exceptions.
Notes:

Each instantiation of the generic packages SEQUENTIAL_IO and DIRECT_

IO declares a different type FILE_TYPE; in the case of TEXT_IO, the type
FILE_TYPE is unique.
:

Similarly, each instantiation of the generic packages RELATIVE_IO
and INDEXED_IO declares a different type FILE_TYPE; in the case of
SEQUENTIALMIXED_IO, DIRECT_MIXED_IO, RELATIVE_MIXED_

IO, and INDEXED_MIXED_IO, the type FILE_TYPEis declared by the

(nongeneric) package.
13

A bidirectional device can often be modeled as two sequential files associated
with the device, one of mode IN_FILE, and one of mode OUT_FILE. An
implementation mayrestrict the numberof files that may be associated with
a given externalfile. The effect of sharing an externalfile in this way by
severalfile objects is implementation-dependent.*

VAX Ada permits the sharing of external files, and, in addition, uses the
VMS RMSautomatic locking facility to provide record-locking capabilities.
In other words, when an external file is opened in more than oneplace, the
operations are automatically coordinated. Record locking ensures that one
task cannot add, delete, or modify a record of an external file that is concurrently being accessed by another task. (Record locking also coordinates

accesses between programsthat are executing as separate VMSprocesses,
including Ada and non-Ada programs, and applies to processes on different nodes of a VAXcluster system or DECnet network.) See the VAX Ada
Run-Time Reference Manual for more information on file sharing and record
locking.

3 See also Appendix G, AI-00279.
4 See also Appendix G, AI-00320.
14-5

External Files and File Objects

14.1

14.

References : create procedure 14.2.1, current index 14.2, current size 14.2, delete
procedure 14.2.1, direct access 14.2, direct file procedure 14.2, direct_io package 14.1
14.2, enumeration type 3.5.1, exception 11, file mode 14.2.3, generic instantiation
12.3, index 14.2, input file 14.2.2, io_exceptions package 14.5, open file 14.1, open
procedure 14.2.1, output file 14.2.2, read procedure 14.2.4, sequential access 14.2,

sequential file 14.2, sequential input-output 14.2.2, sequential_io package 14.2
14.2.2, string 3.6.3, text_io package 14.8, write procedure 14.2.4

access type 3.8, direct_mixed_io package 14.2 14.2b 14.2b.5, erroneous 1.6, external
file 14.1, file sharing 14.2a, generic package 12.1, indexed access 14.2a, indexed_io
package 14.2a 14.2a.4, indexed_mixed_io package 14.2a 14.2b 14.2b.9, mixed-type
file 14.la 14.2b, operation 3.3.3, record locking 14.2a 14.2b, relative access 14.2a,
relative_io package 14.2a 14.2a.2, relative_mixed_io package 14.2a 14.2b 14.2b.7,
sequential_mixed_io package 14.2 14.2b 14.2b.3, task 9

14.1a

Elements and Records
Input-output operations for all nontext files are defined in terms offile
elements and external file records. Values retrieved for an element of the
file are read from a record of the external file. Conversely, values transferred
to an elementof the file are written to a record of the external file. In VAX
Ada, each externalfile record corresponds to a VMS RMSrecord.
Forfiles containing values of mixed types, an element may represent a
single value (just as an elementin file of uniform-type values represents
a single value), or it may represent a set of values, or items. A mixed-type
file, then, may be a file of elements of different types, or it may be file of
elements whose items have different types. VAX Ada provides an additional
set of input-output operations, defined in terms of items, for mixed-typefiles.
Section 14.2b explains these operations in more detail.
Input-output operations for text files are not defined in terms of elements.

Rather, they are defined in termsof lines and in termsof values, or items,

of various types. For nonterminal devices, a line in a text file constitutes
a single external file record; for terminal devices, an item in a text file

constitutes a single external file record. Section 14.3 explains text files and
their operations in moredetail.

14.1a

Elements and Records

14-6

14.1b Specification of the FORM Parameter in VAX Ada
All of the VAX Ada input-output packages provide CREATE and OPEN
procedures, andall of these procedures, in turn, have a FORM parameter,
which corresponds to the language-required form string (see 14.1). The
FORM parameter determines the system-dependent characteristics or
attributes associated with an external file when it is opened or created. The
value of this parameter may bea string of statements of the VMS Record
Management Services (RMS)File Definition Language (FDL), or it may be a
string referring to a text file of FDL statements (called an FDL file).
FDLis a special-purpose VMS languagefor writing file specifications. These
specifications are then used by VAX Ada run-time routines to create or open
files. See the VAX Ada Run-Time Reference Manual for the rules governing
the FORM parameter and for a general description of FDL. See the Guide
to VMS File Applications and the VMS File Definition Language Facility
Manual for complete information on FDL.
Each input-output package has a default string of FDL statements that
is used to open or create a file. Thus, in general, specification of a FORM
parameteris not necessary: it is never necessary in an OPEN procedure; it
may be necessary in a CREATEprocedure. The packages for which a value
for the FORM parameter must be specified in a CREATE procedure are as
follows:
e

The packages DIRECT_IO and RELATIVE_IO require that a maximum
record size be specified in the FORM parameterif the item with which
the packageis instantiated is unconstrained.

The packages DIRECT_MIXED_IO and RELATIVE_MIXED_IO require
that a maximum record size be specified in the FORM parameter.

The packages INDEXED_IO and INDEXED_MIXED_IO require that
information about keys be specified in the FORM parameter.

Any explicit FORM specification supersedes the default attributes of the
governing input-output package. The VAX Ada Run-Time Reference Manual
describes the default external file attributes of each input-output package.
References: create procedure 14.2.1, direct_io package 14.2 14.2.4, direct_mixed_io

package 14.2 14.2b 14.2b.5, external file 14.1, indexed_io package 14.2a 14.2a.4,
indexed_mixed_io package 14.2a 14.2b 14.2b.9, instantiation 12.3, item 14.2b, key
14.2a, open file 14.1, open procedure 14.2.1, relative_io package 14.2a 14.2a.2,
relative_mixed_io package 14.2a 14.2b 14.2b.7, string 2.6 3.6.3 4.2, text file 14.3,
unconstrained type 3.3 3.3.2

Specification of the FORM Parameter in VAX Ada

14.1b

14.2 Sequential and Direct Files
{

Two kinds of access to external files are defined: sequential access and

direct access. The correspondingfile types and the associated operations are

provided by the generic packages SEQUENTIAL_IO and DIRECT_IO. file
object to be used for sequential access is called a sequential file, and one to

be used for direct accessis called a directfile.

In VAX Ada, sequential and direct access are also provided in the predefined
(nongeneric) packages SEQUENTIAL_MIXED_IO and DIRECT_MIXED_IO,
which allow valuesof different types to be mixed in a file. The operations
provided by these packages are describedin section 14.2b.
2

For sequential access, the file is viewed as a sequence of values that are
transferred in the order of their appearance (as produced by the program
or by the environment). Whenthefile is opened, transfer starts from the
beginning of thefile.

For direct access, the file is viewed as a set of elements occupying consecutive positions in linear order; a value can be transferred to or from an
element of the file at any selected position. The position of an element
is specified by its index, which is a number, greater than zero, of the
implementation-defined integer type COUNT.Thefirst element, if any, has

index one; the index of the last element, if any, is called the current size; the
current size is zero if there are no elements. The current size is a property

of the externalfile.

In VAX Ada, the integer type COUNT is range 0..INTEGER’ LAST.
4

An open direct file has a current index, which is the index that will be used
by the next read or write operation. Whena direct file is opened, the current
index is set to one. The current index of a direct file is a property of a file
object, not of an externalfile.

All three file modes are allowed for direct files. The only allowed modesfor

References : count type 14.3, file mode 14.1, in_file 14.1, out_file 14.1

sequential files are the modes IN_FILE and OUT_FILE.

direct_io package 14.2 14.2.4, direct_mixed_io package 14.2 14.2b 14.2b.5, generic
package 12.1, integer type 3.5.4, mixed_type file 14.la, sequential_io package 14.2
14.2.2, sequential_mixed_io package 14.2 14.2b 14.2b.3

14.2

Sequential and Direct Files

14-8

14.2.1

File Management
1

The procedures and functions described in this section provide for the
control of external files; their declarations are repeated in each of the three
packages for sequential, direct, and text input-output. For text input-

output, the procedures CREATE, OPEN, and RESET haveadditionaleffects
described in section 14.3.1.

procedure CREATE(FILE

in out FILETYPE;

MODE : in FILEMODE := defaultmode;
NAME : in STRING := "";
FORM : in STRING := "");

Establishes a new externalfile, with the given name and form,

and associates this external file with the given file. The given file
is left open. The current modeof the given file is set to the given
access mode. The default access mode is the mode OUT_FILEfor
sequential and text input-output; it is the mode INOUT_FILE for

direct input-output. For direct access, the size of the createdfile
is implementation-dependent. A null string for NAMEspecifies an
external file that is not accessible after the completion of the main
program (a temporaryfile). A null string for FORM specifies the use
of the default options of the implementation for the external file.5
In VAX Ada, NAMEoverrides the name given in FORM.If NAMEis
null, a temporary file is created that is not accessible after thefile is
closed.© Any namespecified in FORM is ignored.
For direct files, the size of a file that has just been created is zero.
4

The exception STATUS_ERRORis raised if the givenfile is already
open. The exception NAME_ERRORisraised if the string given
as NAME does not allow the identification of an external file. The

exception USE_ERRORis raised if, for the specified mode, the
environment does not support creation of an external file with the

given name(in the absence of NAME_ERROR) and form.7

In VAX Ada, the exception USE_ERRORisraised if the modeis

IN_FILE. The exception USE_ERRORisalso raised if any file
attributes specified in FORM are not supported by the package.

5 See also Appendix G, AI-00046 and AI-00247.
6 See also Appendix G, AI-00046.

7 See also Appendix G, AI-00332.

14-9

File Management

14.2.1

procedure OPEN(FILE : in out FILETYPE;
MODE

in FILEMODE;

FORM

in STRING

NAME : in STRING;

:= "");

Associates the given file with an existing external file having the

given name and form, and sets the current mode of the given file to
the given mode. The givenfile is left open.

The exception STATUS_ERRORis raised if the givenfile is already
open. The exception NAME_ERRORisraised if the string given

as NAMEdoesnot allow the identification of an external file;
in particular, this exception is raised if no external file with the

given name exists. The exception USE_ERRORisraised if, for the
specified mode, the environment does not support opening for an
external file with the given name(in the absence of NAME_ERROR)

and form3

procedure CLOSE(FILE : in out FILETYPE);

Severs the association between the given file and its associated
external file. The givenfile is left closed?
10
11
12

The exception STATUS_ERRORisraised if the given file is not open.
procedure DELETE(FILE

in out FILETYPE);

Deletes the external file associated with the given file. The givenfile

is closed, and the externalfile ceases to exist.
13

The exception STATUS_ERRORisraised if the given file is not open.
The exception USE_ERRORisraised if (as fully defined in Appendix
F) deletion of the external file is not supported by the environment.

procedure

RESET(FILE

in out

procedure RESET(FILE

in out FILETYPE);

FILETYPE;

MODE

in FILEMODE);

Resets the given file so that reading from or writing to its elements
can be restarted from the beginningofthefile; in particular, for
direct access this means that the current indexis set to one. Ifa
MODEparameteris supplied, the current mode of the given file is

set to the given mode.!°

8 See also Appendix G, AI-00332.
9 See also Appendix G, AI-00357.
10 See also Appendix G, AI-00357.
14.2.1

File Management

14-10

The exception STATUS_ERRORisraised if the file is not open. The
exception USE_ERRORisraised if the environment does not support
resetting for the external file and, also, if the environment does not

support resetting to the specified mode for the external file.

function MODE(FILE

in FILETYPE)

return FILEMODE;

Returns the current mode of the givenfile.
The exceptionSTATUS_ERRORisraised if the file is not open.
function NAME(FILE : in FILETYPE)

return STRING;

Returns a string which uniquely identifies the external file currently
associated with the given file (and may thus be used in an OPEN
operation). If an environment allows alternative specifications of
the name (for example, abbreviations), the string returned by the
function should correspondto a full specification of the name.
22

The exception STATUS_ERRORis raised if the given file is not
open.
In VAX Ada, the exception USE_ERRORisraisedif the file has no
name./2

23
24

function FORM(FILE : in FILETYPE) return STRING;

Returns the form string for the external file currently associated
with the given file. If an environment allows alternative specifications of the form (for example, abbreviations using default options),
the string returned by the function should correspondto a full specification (that is, it should indicate explicitly all options selected,
including default options).

In VAX Ada, a full FDL string is returned. See section 14.1b of
this manual and the VAX Ada Run-Time Reference Manual for an
explanation of FDL strings.
25
26
27

The exception STATUS_ERRORisraised if the given file is not open.
function ISOPEN(FILE : in FILETYPE)

return BOOLEAN;

Returns TRUEif thefile is open (that is, if it is associated with an
external file), otherwise returns FALSE.

11 See also Appendix G, AI-00046.
12 See also Appendix G, AI-00046.
14-11

File Management

14.2.1

References : current mode 14.1, current size 14.1, closed file 14.1, direct access

14.2, external file 14.1, file 14.1, file_mode type 14.1, file_type type 14.1, form string

14.1, inout_file 14.2.4, mode 14.1, name string 14.1, name_error exception 14.4, open

file 14.1, out_file 14.1, status_error exception 14.4, use_error exception 14.4
in_file 14.1

14.2.2

Sequential Input-Output
I

The operations available for sequential input and output are described in
this section.1° The exception STATUS_ERRORisraised if any of these

operations is attempted for a file that is not open.

See section 14.2.1 for descriptions of the file management operations that
are available for sequential input and output.
procedure READ(FILE : in FILETYPE;

ITEM : out ELEMENTTYPE) ;

Operates on a file of mode IN_FILE. Reads an element from the
given file, and returns the value of this element in the ITEM
parameter.
The exception MODE_ERRORisraised if the mode is not IN_FILE.
The exception END_ERRORis raised if no more elements can be

read from the given file. The exception DATA_ERRORis raised

if the element read cannot be interpreted as a value of the type
ELEMENT_TYPE; however, an implementation is allowed to omit

this check if performing the check is too complex.

In VAX Ada, this procedure does not perform the check that raises
the exception DATA_ERROR.
procedure WRITE(FILE

in FILETYPE;

ITEM

in ELEMENTTYPE);

Operates on a file of mode OUT_FILE. Writes the value of ITEM to

the given file.

The exception MODE_ERRORisraised if the mode is not OUT_
FILE. The exception USE_ERRORisraised if the capacity of the
externalfile is exceeded.
function ENDOFFILE(FILE : in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUE if no more

elements can be read from the given file; otherwise returns FALSE.
10

The exception MODE_ERRORisraised if the mode is not IN_FILE.

13 See also Appendix G, AI-00320.
14.2.2

Sequential Input-Output

14-12

14.2.3

References : data_error exception 14.4, element 14.1, element_type 14.1, end_error
exception 14.4, external file 14.1, file 14.1, file mode 14.1, file_type 14.1, in_file 14.1,
mode_error exception 14.4, out_file 14.1, status_error exception 14.4, use_error
exception 14.4

Specification of the Package Sequential_!O
1

with IOEXCEPTIONS;

generic
type ELEMENTTYPE is pri vate;
package SEQUENTIALIO is
type FILETYPE is limite d private;

type FILEMODE is (INFI LE,

OUTFILE);

-- File management
procedure CREATE (FILE
MODE
NAME
FORM
procedure OPEN

(FILE
MODE
NAME
FORM

procedure CLOSE (FILE
procedure DELETE (FILE
procedure RESET (FILE
MODE

in out

FILETYPE;

in FILEMODE := OUTFILE;

in STRING
in STRING

:= "";
:= "");

in out FILETYPE;

in FILEMODE;

in STRING;
in STRING := "");

in out FILETYPE);
in out FILETYPE);
in out FILETYPE;
in FILEMODE);
in out FILETYPE);

procedure RESET

(FILE

function MODE
function NAME
function FORM

(FILE
(FILE
(FILE

in FILETYPE)

function ISOPEN (FILE

return FILEMODE;

in FILETYPE)

return

in FILETYPE)

return STRING;

STRING;

in FILETYPE)

return BOOLEAN;

-- Input and output oper ations
procedure READ

procedure WRITE

(FILE

in FILETYPE;
in FILETYPE;

function ENDOFFILE(FIL E

ITEM :
ITEM :

: in FILETYPE)

out ELEMENTTYPE);
in ELEMENTTYPE);

return BOOLEAN;

-- Exceptions
STATUSERROR : exception renames IOEXCEPTIONS.STATUSERROR;
MODEERROR
> exception renames IOEXCEPTIONS.MODEERROR;

NAMEERROR
USE_ERROR

: exception renames
: exception renames

DEVICEERROR :
ENDERROR
:
DATAERROR
:

14-13

IOEXCEPTIONS.NAMEERROR;
IOEXCEPTIONS.USEERROR;
exception renames [10EXCEPTIONS.DEVICEERROR;
exception renames [0EXCEPTIONS.ENDERROR;
exception renames IOEXCEPTIONS.DATAERROR;

Specification of the Package Sequential_lO

14.2.3

private
-- implementation-dependent
end SEQUENTIALI0;

References : close procedure 14.2.1, create procedure 14.2.1, data_error exception

14.4, delete procedure 14.2.1, device_error exception 14.4, end_error exception 14.4,
end_of_file function 14.2.2, filemode 14.1, file_type 14.1, form function 14.2.1, in_file

14.1, io_exceptions 14.4, is_open function 14.2.1, mode function 14.2.1, mode_error

exception 14.4, name function 14.2.1, name_error exception 14.4, open procedure

14.2.1, out_file 14.1, read procedure 14.2.2, reset procedure 14.2.1, sequential_io
package 14.2 14.2.2, status_error exception 14.4, use_error exception 14.4, write
procedure 14.2.2,

14.2.4

Direct Input-Output
1

The operations available for direct input and output are described in

this section. The exception STATUS_ERRORis raised if any of these
operations is attempted for a file that is not open.

See section 14.2.1 for descriptions of the file management operations that
are available for direct input and output.
procedure READ(FILE
ITEM
FROM

:
:
:

in FILETYPE;
out ELEMENTTYPE;
in
POSITIVECOUNT);

procedure READ(FILE

in FILETYPE;

ITEM

out ELEMENTTYPE);

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, sets the current index of the given file to the index
value given by the parameter FROM. Then (for both forms) returns,
in the parameter ITEM, the value of the element whose position
in the given file is specified by the current index ofthefile; finally,
increases the current index by one.
The exception MODE_ERRORisraised if the mode of the given file

is OUT_FILE. The exception END_ERRORisraised if the index to
be used exceeds the size of the external file. The exception DATA_
ERRORis raised if the element read cannot be interpreted as a
value of the type ELEMENT_TYPE; however, an implementation is
allowed to omit this check if performing the check is too complex.
In VAX Ada, this procedure does not perform the check that raises
the exception DATA_ERROR.

14 See also Appendix G, AI-00320.
14.2.4

Direct Input-Output

14-14

procedure WRITE(FILE
ITEM
TO

:
:
:

in FILETYPE;
in ELEMENTTYPE;
in POSITIVECOUNT) ;

procedure WRITE(FILE

in FILETYPE;

ITEM :

in ELEMENTTYPE) ;

Operates on file of mode INOUT_FILE or OUT_FILE.In the case
of the first form, sets the index of the given file to the index value
given by the parameter TO. Then (for both forms) gives the value
of the parameter ITEM to the element whose position in the given
file is specified by the current index of thefile; finally, increases the
current index by one.
The exception MODE_ERRORisraised if the mode of the given file
is IN_FILE. The exception USE_ERRORisraised if the capacity of
the external file is exceeded.
procedure SETINDEX(FILE

in FILETYPE;

in POSITIVECOUNT) ;

Operates on a file of any mode. Sets the current index of the given
file to the given index value (which may exceed the currentsize of
the file).
function INDEX (FILE

in FILETYPE)

return POSITIVECOUNT;

Operates on a file of any mode. Returns the current index of the
given file.
function SIZE(FILE : in FILETYPE) return COUNT;

Operates on a file of any mode. Returns the current size of the
external file that is associated with the givenfile.
In VAX Ada, returns the numberof elements (VMS RMSrecords)

in the file. This value is obtained from the external file when an
existing file is opened. The value is updated wheneverthe index of a
WRITEoperation to the file exceeds the current size. Therefore, the
size of the file is always equal to the highest index numberthat has
been written to thefile.
14

function ENDOFFILE(FILE : in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE. Returns TRUE

if the current index exceedsthesize of the external file; otherwise
returns FALSE.
16

14-15

The exception MODE_ERRORisraised if the modeof the given file
is OUT_FILE.

Direct Input-Output

14.2.4

References : count type 14.2, current index 14.2, current size 14.2, data_error

exception 14.4, element 14.1, element_type 14.1, end_error exception 14.4, external

file 14.1, file 14.1, file mode 14.1, file_type 14.1, in_file 14.1, index 14.2, inout_file

14.1, mode_error exception 14.4, open file 14.1, positive_count 14.3, status_error
exception 14.4, use_error exception 14.4
update a value 6.2, VMS RMSrecord 14.1a

14.2.5

Specification of the Package Direct_lO
1

with IOEXCEPTIONS;

generic
type ELEMENTTYPE is private;
package DIRECTIO is

type FILETYPE is limited private;

type

FILEMODE is (INFILE, INOUTFILE, OUTFILE);

type
COUNT
is range 0 .. implementation_defined;
subtype POSITIVECOUNT is COUNT range 1 .. COUNT’ LAST;
-- File management
procedure CREATE (FILE
MODE
NAME
FORM

-- NOTE:

in
in
in
in

out FILETYPE;
FILEMODE := INOUTFILE;
STRING := "";
STRING := "");

If ELEMENTTYPE is an unconstrained type,

—- a Maximum record

(element)

size must be specified

-- in the FORM parameter of the CREATE procedure.

procedure OPEN

(FILE
MODE
NAME
FORM

procedure CLOSE (FILE
procedure DELETE (FILE
procedure RESET (FILE
MODE

in
in
in
in

out FILETYPE;
FILEMODE;
STRING;
STRING := "");

in
in
in
in
in

out FILETYPE);
out FILETYPE);
out FILETYPE;
FILEMODE) ;
out FILETYPE);

procedure RESET

(FILE

function MODE
function NAME

(FILE
in FILETYPE)
(FILE : in FILETYPE)
(FILE : in FILETYPE)

function FORM

function ISOPEN (FILE

in FILETYPE)

return FILEMODE;
return STRING;
return STRING;
return BOOLEAN;

-- Input and output operations

14.2.5

Specification of the Package Direct_lO

14-16

procedure READ

(FILE : in FILETYPE;

procedure READ

FROM : POSITIVECOUNT) ;
(FILE : in FILETYPE;

ITEM

out ELEMENTTYPE;

out ELEMENTTYPE);

ITEM

procedure WRITE(FILE

in FILETYPE;

ITEM

POSITIVECOUNT) ;

:
:

in FILETYPE;
in ELEMENTTYPE);

procedure WRITE(FILE
ITEM

ELEMENTTYPE;

procedure SETINDEX(FILE : in FILETYPE;
TO
: in POSITIVECOUNT);
function INDEX(FILE : in FILETYPE)

return POSITIVECOUNT;

function SIZE

return COUNT;

(FILE

in FILETYPE)

function ENDOFFILE(FILE

in FILETYPE)

return BOOLEAN;

-~- Exceptions
STATUSERROR
MODEERROR
NAMEERROR
USE_ERROR
DEVICEERROR
ENDERROR
DATAERROR

:
>
:
:
:
:
>

exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames

IOEXCEPTIONS.STATUSERROR;
IOEXCEPTIONS.MODEERROR;
IOEXCEPTIONS.NAMEERROR;
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICEERROR;
IOEXCEPTIONS.ENDERROR;
IOEXCEPTIONS.DATAERROR;

private
-- implementation-dependent

end DIRECT10;

Referencesclose procedure 14.2.1, count type 14.2, create procedure 14.2.1,
data_error exception 14.4, default_mode 14.2.5, delete procedure 14.2.1, device_error
exception 14.4, element_type 14.2.4, end_error exception 14.4, end_of_file function
14.2.4, filemode 14.2.5, file_type 14.2.4, form function 14.2.1, in_file 14.2.4, index
function 14.2.4, inout_file 14.2.4 14.2.1, io_exceptions package 14.4, is_open function
14.2.1, mode function 14.2.1, mode_error exception 14.4, name function 14.2.1,

name_error exception 14.4, open procedure 14.2.1, out_file 14.2.1, read procedure

14.2.4, set_index procedure 14.2.4, size function 14.2.4, status_error exception 14.4,

use_error exception 14.4, write procedure 14.2.4 14.2.1

14.2a

Relative and Indexed Files
In addition to sequential and direct access, VAX Ada definesrelative
access and indexed access. The correspondingfile types and the associated
operations are provided by the predefined generic packages RELATIVE_IO
and INDEXED_IO.A file object to be used for relative accessis called a
relative file; a file object to be used for indexed accessis called an indexed
file.

14-17

Relative and Indexed Files

14.2a

Relative and indexed access are also provided in the predefined (nongeneric)
packages RELATIVE_MIXED_IO and INDEXED_MIXED_IO, which allow
valuesof different types to be mixed in a file. The operations provided by
these packages are described in section 14.2b.
For relative access, the file is viewed as a set of fixed-length cells occupying
consecutive positions in linear order. Cells can either be empty or can
contain fixed- or variable-length elements: a cell is said to contain an
element if an element has been written to that position (and not deleted),
and is said to be empty if an element has not been written to that position
(or the last written element has been deleted).
The position of a cell is specified by its index, which is a numberof the type
COUNT(that is, it is in the range 0.INTEGER’ LAST). The first cell in a
relative file has an index of one. Like an open directfile, an open relative
file has a current index, which is the index that will be used by the next read
or write operation. Whena relative file is opened, the current indexis set
to one. The current index of a relative file is a property of a file object, not
of an externalfile. Also, the concept of size does not apply to relativefiles:
end-of-file is true if all remaining elements, starting at the current index,
are empty.

For indexed access, thefile is viewed as a set of elements that are ordered

by predefined keys. Each key has a number(a nonnegative integer) and a
value. Whenthefile is created, the keys of an element are defined in the
form string to correspondtofields of that element, and may not be changed
thereafter. Each element has at least one primary key (numbered 0), and
may have as many as 254 alternate keys (numbered 1 to 254).
The elements of the file can be accessed by any key. Whena file is read, the
elementfields are searched until the key characteristics are matched. The
read operation allows both exact and inexact matching of the key value; the
type of matching can be specified by one of the values of the enumeration
type RELATION_TYPE, which is defined as follows:
type RELATION_TYPE is

(EQUALNEXT,

EQUAL,

NEXT);

The value EQUAL_NEXTcorresponds to the case where a match will be
greater than or equal to the key value if ascending keys are involved; the
match will be less than or equal to the key value if descending keys are
involved. The value EQUAL correspondsto the case where a match will be
equal to the key value. The value NEXT corresponds to the case where a
match will be greater than the key value if ascending keys are involved; the
match will be less than the key value if descending keys are involved. If
there are duplicate keys in thefile, they are retrieved in the order in which
they are written to thefile.

14.2a

Relative and Indexed Files

14-18

An open indexedfile has a next element, whichis the first element of the
primary key whenthefile is first opened; the. next element is redefined after
each successful read operation, or it may be reset to the first sequential
element according to a specified key. As with relative files, the concept of
size does not apply to indexedfiles: end-of-file is true if no more elements,
starting at the next elementin thefile, exist.
An open relative or indexed file has a current element, which is the target
element for the UPDATE and DELETE_ELEMENT operations. The current
elementis said to be defined after a successful READ, READ_EXISTING,
READ_BY_KEY, or END_OF_FILE operation (if END_OF_FILE results in

the reading of the next elementof thefile). The current elementis said
to be undefined after a successful CREATE, OPEN, CLOSE, DELETE,
RESET, WRITE, UPDATE, UNLOCK, or DELETE_ELEMENT operation.
The current element is also said to be undefined after an unsuccessful
READ, READ_EXISTING, READ_BY_KEY, WRITE, UPDATE, UNLOCK,
DELETE_ELEMENT, RESET(except when the exception MODE_ERROR
is raised), or END_OF_FILE operation (if END_OF_FILE results in an
attempt to read past the end of the external file).
All three file modes are allowed for relative and indexedfiles.

Depending on the sharing and access attributes specified in their form
strings, relative and indexedfiles may be write shared. Thus, element (VMS
RMSrecord) locking is automatically provided for the packages RELATIVE_
IO and INDEXED_IO. In other words, when the current element in a

relative or indexed file is defined (a successful read operation is performed),
the element is locked until a subsequent read, write, update, delete, or
unlock operation is performed; until thefile is closed; or until a VMS RMS
operation on that file fails. The purpose of locking is to prevent two (or
more) tasks that share the same external file (by means of two different
internal files) from interfering with each other’s read and write operations.
See the VAX Ada Run-Time Reference Manual for more information on
sharing,file attributes, and record locking.
References: close procedure 14.2.1, count type 14.2, create procedure 14.2a.1

14.2b.1, delete procedure 14.2.1, delete_element procedure 14.2a.2 14.2a.4 14.2b.7
14.2b.9, element 14.la, end_of_file function 14.2a.2 14.2a.4 14.2b.7 14.2b.9,

enumeration type 3.5.1, external file 14.1, file object 14.1, form string 14.1 14.1b,
generic package 12.1, indexed_io package 14:2a 14.2a.4, indexed_mixed_io package
14.2a 14.2b 14.2b.9, integer type 3.5.4, mode_error exception 14.4, open file 14.1,
operation 3.3.3, package 7, range 3.5, read procedure 14.2a.2 14.2a.4 14.2b.7 14.2b.9,
read_by_key procedure 14.2a.4 14.2b.9, read_existing procedure 14.2a.2 14.2b.7,
relative_io package 14.2a 14.2a.2, relative_mixed_io package 14.2a 14.2b 14.2b.7,
reset procedure 14.2.1 14.2a.1, task 9, unlock procedure 14.2a.2 14.2a.4 14.2b.7
14.2b.9, update procedure 14.2a.2 14.2a.4 14.2b.7 14.2b.9, VMS RMS record 14.1a,
write procedure 14.2a.2 14.2a.4 14.2b.7 14.2b.9
14-19

Relative and Indexed Files

14.2a

14.2a.1

File Management
Except for the following differences, the procedures and functions for
controlling relative and indexed access to external files containing values of
the same type are the sameasthosefor controlling sequential and direct
access (see 14.2.1). The default mode for the CREATE procedures of both
packages is INOUT_FILE.
For the package RELATIVE_IO, a maximum external record size must be
specified in the FORM parameter of the CREATEprocedureif the package
is instantiated with an unconstrained element type.
procedure CREATE(FILE : in out FILETYPE;
MODE

in FILEMODE

NAME

in STRING

:= "";

FORM

STRING

INOUTFILE;

"");

-- Example:

-- procedure CREATE (FILE => MYFILE;
--

FORM => "RECORD; "

"SIZE

128" );

For the package INDEXED_IO, the FORM parameter of the CREATE
procedure must be specified; there is no default. In particular, the FORM
parameter must specify all information about the keys in the file to be
created. If the packageis instantiated with an unconstrained element type,
a maximum external record size mustbe specified.
procedure CREATE(FILE : in out FILETYPE;

MODE : in FILEMODE := INOUTFILE;
NAME : in STRING := "";
FORM

in STRING);

-- Example:

-—
--—

FORM => "KEY 0;"

—

-- procedure CREATE(FILE => MYFILE;

"LENGTH
5;"
&
"POSITION O;"
&
"TYPE
STRING;");

_ Also for the package INDEXED_IO, the RESET procedures have a parameter for specifying the key numberat whichthefile is to be reset. The default
value for KEY_NUMBERis 0, which designates the primary key.

14.2a.1

File Management

14—20

procedure RESET

(FILE

: in FILETYPE;

MODE
KEYNUMBER

: in FILEMODE;
:

in INTEGER

(FILE

:
:

in FILETYPE;
in INTEGER := 0);

KEYNUMBER

:= 0);

References: create procedure 14.2.1, direct access 14.2, external file 14.1, file
mode 14.1, form string 14.1 14.1b, function 6.5, indexed access 14.2a, inout_file
14.1, instantiation 12.3, key 14.2a, procedure 6.1, relative access 14.2a, relative_io
package 14.2a 14.2a.2, reset procedure 14.2.1, sequential access 14.2, unconstrained
type 3.3 3.3.2

14.2a.2

Relative Input-Output
The operations available for relative input and output are described in this
section. The exception STATUS_ERRORisraised if any of these operations
is attemptedfor a file that is not open.
See section 14.2a.1 for information on the file management operations that
are available for relative input and output.
procedure READ(FILE : in

FILETYPE;

ITEM : out ELEMENTTYPE;

FROM : in

procedure READ(FILE : in

POSITIVECOUNT);
FILETYPE;

ITEM : out ELEMENTTYPE) ;

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, sets the current index of the given file to the index
value given by the parameter FROM.Then (for both forms) returns,
in the parameter ITEM,the value of the element whose position is
specified by the current index of the given file. The element read
becomes the current element, and the current index is increased

by one.

The exception MODE_ERRORisraised if the current mode is OUT_
FILE. The exception LOCK_ERRORisraised if the element to be

read is locked; this error is possible only if the external file is being

shared. The exception EXISTENCE_ERRORisraised if the element

does not exist (that is, the given cell is empty or the current index is
beyondtheendofthefile).

14-21

Relative Input-Output

14.2a.2

procedure READEXISTING(FILE : in

FILE_TYPE;

ITEM : out ELEMENTTYPE;
FROM : in POSITIVECOUNT) ;

procedure READEXISTING(FILE : in FILE_TYPE;
ITEM : out ELEMENTTYPE) ;

Operates on a file of mode IN_FILE or INOUT_FILE.In the case of
the first form, sets the current index of the given file to the index
value given by the parameter FROM.Then (for both forms) starts at
the current index and scans forward, skipping empty cells, and sets
the current index to the first nonempty cell. Then returns, in the
parameter ITEM,the value of the element whose position is specified
by the current index of the given file. The element read becomes the
current element, and the current index is increased by one.
The exception MODE_ERRORis raised if the mode of the givenfile

is OUT_FILE. The exception LOCK_ERRORisraised if the element
found is locked; this error is possible only if the external file is being
shared. The exception EXISTENCE_ERRORisraised if the current
_ Index is beyond the endofthefile, or if the end of the file is reached
before an existing element (a nonemptycell) is found.
procedure WRITE(FILE : in FILETYPE;

ITEM : in ELEMENTTYPE;

: in POSITIVECOUNT) ;

procedure WRITE(FILE : in FILETYPE;
ITEM : in ELEMENTTYPE) ;

Operates on file of mode INOUT_FILE or OUT_FILE.In the case

of the first form, sets the current index of the given file to the index
value given by the parameter TO. Then (for both forms) writes the
value of the parameter ITEM to the cell whose position in the given
file is specified by the current indexof thefile; finally, increases the
current index by one.
The exception MODE_ERRORis raised if the mode ofthe givenfile
is IN_FILE. The exception USE_ERRORis raised if the element
position in the file has already been written.
procedure UPDATE(FILE : in FILETYPE; ITEM : in ELEMENTTYPE) ;

Operates on a file of mode INOUT_FILE. Updates the current

element of the given file with the value of the parameter ITEM.
The exception MODE_ERRORis raised if the current modeis not
INOUT_FILE. The exception USE_ERRORis raised if the current
element is undefined at the start of this operation.

14.2a.2

Relative Input-Output

14-22

procedure UNLOCK(FILE : in FILETYPE);

Operates on a file of any mode. After this operation, the current
element is undefined.
procedure DELETEELEMENT (FILE

in FILETYPE);

Operates on a file of mode INOUT_FILE. Deletes the current

element in thefile.

The exception MODE_ERRORisraised if the current modeis not

INOUT_FILE. The exception USE_ERRORis raised if the current
element is undefined at the start of this operation.

procedure SETINDEX(FILE

in FILETYPE; TO

in POSITIVECOUNT) ;

Operates on a file of any mode. Sets the current index of the given
file to the index value given by the parameter TO.
function INDEX(FILE : in FILETYPE) return POSITIVECOUNT;

Operates on a file of any mode. Returns the current index of the
given file.
function ENDOFFILE(FILE

in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE. Returns
TRUE if nocell, starting at the current index, contains an element;
otherwise returns FALSE.
The exception MODE_ERRORisraised if the current mode is OUT_
FILE.
References: cell 14.2a, current element 14.2a, current index 14.2a, element 14.1a,
end of file 14.2a, existence_error exception 14.4, file 14.1, file mode 14.1, file sharing
14.2a, index 14.2a, in_file 14.1, inout_file 14.1, lock_error exception 14.4, locking

14.2a, mode_error exception 14.4, open file 14.1, out_file 14.1, relative access 14.2a,
relative file 14.2a, status_error exception 14.4, undefined current element 14.2a,
use_error exception 14.4

14.2a.3

Specification of the Package Relative_lO
with IOEXCEPTIONS;

with AUX_IOEXCEPTIONS;

generic
type ELEMENTTYPE is private;
package RELATIVEIO is
type

FILETYPE

is limited private;

type

FILEMODE

type

COUNT

subtype POSITIVECOUNT

14-23

(INFILE,

INOUTFILE,

OUTFILE);

is range 0 .. INTEGER’ LAST;

is COUNT range 1 .. COUNT’ LAST;
Specification of the Package RelativelO

14.2a.3

-- File management
procedure CREATE (FILE
MODE
NAME
FORM :
-- NOTE:

in
in
in
in

out FILETYPE;
FILEMODE := INOUTFILE;
STRING := "";
STRING := "");

If ELEMENTTYPE is an unconstrained type,

-- a maximum record (element)

size must be specified

-- in the FORM parameter of the CREATE procedure.

procedure OPEN

(FILE
MODE
NAME
FORM

procedure CLOSE (FILE
procedure DELETE (FILE
procedure RESET
procedure RESET

(FILE
MODE
(FILE

function MODE
function NAME
function FORM

(FILE
(FILE
(FILE

out FILETYPE;
FILEMODE;
STRING;
STRING ee
in out FILETYPE);
in out FILETYPE);
in out FILETYPE;
in FILEMODE) ;
in out FILETYPE) ;
in FILETYPE) return FILEMODE;
in FILETYPE) return STRING;
: in FILETYPE) return STRING;

function ISOPEN (FILE

in
in
in
in

in FILETYPE)

return BOOLEAN;

-- Input and output operations

procedure READ
procedure READ

(FILE
ITEM :
FROM :
(FILE :
ITEM :

in
out
in
in
out

FILETYPE;

ELEMENTTYPE;

POSITIVECOUNT) ;
FILETYPE;
ELEMENTTYPE) ;

procedure READEXISTING (FILE : in
ITE M: out
FROM : in
procedure READEXISTING (FILE : in
ITE M : out

procedure WRITE
procedure WRITE

(FILE
ITEM :
TO
(FILE
ITEM :

procedure UPDATE (FILE
ITEM :

in
in
in
in
in

FILETYPE;
ELEMENTTYPE;
POSITIVECOUNT) ;
FILETYPE;
ELEMENTTYPE) ;

in FILETYPE;
in ELEMENTTYPE) ;

FILETYPE) ;
procedure DELETEELEMENT (FILE
in FILETYPE);
procedure SETINDEX (FILE
in FILETYPE;
in POSITIVECOUNT) ;
TO
procedure UNLOCK (FILE

14.2a.3

Specification of the Package Relative_lO

14-24

function INDEX(FILE

in FILETYPE)

function ENDOFFILE(FILE

return POSITIVECOUNT;

in FILETYPE)

return BOOLEAN;
a

-- Exceptions
STATUSERROR
MODEERROR
NAMEERROR
USE_ERROR
DEVICEERROR
END_ERROR
DATAERROR
LOCKERROR

:
:
:
:
:
:
:
:

exception
exception
exception
exception
exception
exception
exception
exception

EXISTENCEERROR : exception

renames IOEXCEPTIONS.STATUS_ERROR;
renames IOEXCEPTIONS.MODEERROR;
renames IOEXCEPTIONS.NAMEERROR;
renames IOEXCEPTIONS.USEERROR;
renames IOEXCEPTIONS.DEVICEERROR;
renames IOEXCEPTIONS.END_ERROR;
renames IOEXCEPTIONS.DATA_ERROR;
renames AUX_IOEXCEPTIONS. LOCK_ERROR;

renames AUX_IOEXCEPTIONS.EXISTENCEERROR;

private .
-- implementation-dependent
end RELATIVEI0;

References: aux_io_exceptions package 14.4, close procedure 14.2.1, count type

14.2, create procedure 14.2a.1, data_error exception 14.4, delete procedure 14.2.1,
delete_element procedure 14.2a.2, device_error exception 14.4, element_type 14.1,
end_error exception 14.4, end_of_file function 14.2a.2, existence_error exception
14.4, file_mode 14.1, file_type 14.1, form function 14.2.1, index function 14.2a.2,
integer type 3.5.4, io_exceptions package 14.4, is_open function 14.2.1, lock_error
exception 14.4, mode function 14.2.1, mode_error exception 14.4, name function
14.2.1, name_error exception 14.4, open procedure 14.2.1, read procedure 14.2a.2,
read_existing procedure 14.2a.2, reset procedure 14.2.1, set_index procedure 14.2a.2,
status_error exception 14.4, unconstrained type 3.3 3.3.2, unlock procedure 14.2a.2,
update procedure 14.2a.2, use_error exception 14.4, write procedure 14.2a.2

14.2a.4_

Indexed Input-Output
The operations available for indexed input and output are describedin this

section. The exception STATUS_ERRORisraised if any of these operations

is attempted for a file that is not open.

See section 14.2a.1 for information on the file management operations that
are available for indexed input and output.
The package INDEXED_IO provides a generic READ_BY_KEYprocedure,

which defines input for the given element type. This procedure must be
instantiated with an actual type parameter for the generic parameter
KEY_TYPE; it may be instantiated with or without a value for the generic

parameter DEFAULT_KEY_NUMBER.Therange of values for DEFAULT_

KEY_NUMBERis 0 to 254; a value of 0 (the default) designates the primary
key.

14-25

Indexed Input-Output

14.2a.4

If the RELATION parameter to the READ_BY_KEYprocedureis specified,
it must have a value of EQUAL_NEXT, EQUAL, or NEXT (the default is
EQUAL).
procedure READ

(FILE

: in

FILETYPE;

ITEM :

out

ELEMENTTYPE);

generic
type KEYTYPE is private;
DEFAULTKEYNUMBER

INTEGER

procedure READBYKEY (FILE
ITEM
KEY

KEYNUMBER
RELATION

:= 0;

: in FILETYPE;
: out ELEMENTTYPE;
: in KEYTYPE;
:

INTEGER :=
DEFAULTKEYNUMBER;
RELATIONTYPE := EQUAL);

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, returns, in the parameter ITEM,the value of the next

element, according to the most recent key andrelation information.
In the case of the second form, returns, in the parameter ITEM, the
value of the element specified by the given key information; KEY
gives the key value; KEY_NUMBERdesignates a primary (0) or
alternate key (1 to 254); and RELATION determines the kind of
match to be madefor the key value. For both forms, the element
read becomes the current element. In the case of thefirst form, the

next sequential element becomes the next element, according to the
most recent key and relation information. In the case of the second
form, the next sequential element that matches the key andrelation
information specified becomes the next element. If neither the key
nor the relation information changes from one READ_BY_KEY
operation to the next, the same elementwill continue to be read.
The exception MODE_ERRORisraised if the current mode is OUT_

FILE. The exception END_ERRORisraised if an attempt is made to

read past the endof thefile by the first form. The exception LOCK_
ERRORis raised if the element to be read is locked; this error is

possible only if the external file is being shared. The exception
EXISTENCE_ERRORisraised if the element does not exist. The
exception KEY_ERRORis raised if the size of the given key is not a
multiple of eight bits.
procedure WRITE(FILE

in FILETYPE;

ITEM

in ELEMENTTYPE);

Operates on a file of mode INOUT_FILE or OUT_FILE.Gives the

value of the parameter ITEM to the element whose position in the
given file is specified by the key information contained within the
value of ITEM.

14.2a.4

Indexed Input-Output

14-26

The exception MODE_ERRORisraised if the current modeis

IN_FILE. The exception USE_ERRORis raised if the element

position in thefile has already been written. The exception KEY_
ERRORis raised if a key has been duplicated and if duplicates are
not allowed by the external file.
procedure UPDATE(FILE : in FILETYPE; ITEM : in ELEMENTTYPE) ;

Operates on a file of mode INOUT_FILE. Updates the current
element of the given file with the value of the parameter ITEM.
The exception MODE_ERRORis raised if the current mode is not

INOUT_FILE. The exception USE_ERRORisraised if the current

element is undefined at the start of this operation or if some key
specification in ITEM violates the external file attributes defined for
that key. The exception KEY_ERRORis raised if a key has been
changed or duplicated and if changes or duplicates are not allowed
by the external file.
procedure UNLOCK(FILE

in FILETYPE);

Operates. on a file of any mode. After this operation, the current
element is undefined.
procedure DELETEELEMENT(FILE

in FILETYPE);

Operates on a file of mode INOUT_FILE. Deletes the current
element of thefile.

The exception MODE_ERRORisraised if the current modeis not
INOUT_FILE. The exception USE_ERRORisraised if the current
element is undefined at the start of this operation.
function ENDOFFILE(FILE

in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE. Returns TRUE

if there are no more elements (according to the most recent key
and relation information) starting at the next elementin thefile;
otherwise returns FALSE.

The exception MODE_ERRORisraised if the current mode is OUT_
FILE.
References: current element 14.2a, element 14.1a, element_type 14.1, end_error
exception 14.4, existence_error exception 14.4, external file 14.1, file 14.1, file mode
14.1, file sharing 14.2a, generic actual parameter 12.3, generic formal parameter
12.3, generic procedure 12.1, in_file 14.1, inout_file 14.1, instantiation 12.3, key

14.2a, key_error exception 14.4, lock_error exception 14.4, locking 14.2a, mode_error

exception 14.4, next element 14.2a, out_file 14.1, range 3.5, relation_type 14.2a,
read_by_key procedure 14.2a.4, status_error exception 14.4, undefined current
element 14.2a, use_error exception 14.4
14-27

Indexed Input-Output

14.2a.4

14.2a.5

Specification of the Package Indexed_lO
with IOEXCEPTIONS;
with AUX_IOEXCEPTIONS;

generic
type ELEMENTTYPE is private;
package INDEXEDIO is

type FILETYPE is limited private;
type FILEMODE is

(INFILE,

type RELATIONTYPE is

INOUTFILE,

(EQUALNEXT,

OUTFILE);

EQUAL,

NEXT);

function GREATER return RELATIONTYPE
renames NEXT;

function GREATEREQUAL return RELATIONTYPE
renames EQUALNEXT;

-- File management
procedure CREATE (FILE
MODE
NAME
FORM :

---~—-

in out FILETYPE;
in FILEMODE := INOUTFILE;

in STRING := "";
in STRING);

NOTE: All information about the keys must be provided
in the FORM parameter of the CREATE procedure.
If ELEMENTTYPE is an unconstrained type, a
maximum record (element) size must also be specified.

procedure OPEN

(FILE
MODE
NAME
FORM :

procedure CLOSE (FILE
procedure DELETE (FILE
procedure RESET

(FILE
MODE

procedure RESET

(FILE

in out FILETYPE;
in FILEMODE;
in STRING;
in STRING ee
in out FILETYPE);

in out FILETYPE);

in FILETYPE;
in FILEMODE;

KEYNUMBER :

in INTEGER := 0);
in FILETYPE;
in INTEGER := 0);

KEYNUMBER :
function MODE
function NAME
function FORM

(FILE
(FILE
(FILE

function ISOPEN (FILE

in FILETYPE)
in FILETYPE)
in FILETYPE)

return FILEMODE;
return STRING;
return STRING;

in FILETYPE) return BOOLEAN;

-- Input and output operations
procedure READ

(FILE
ITEM :

14.2a.5

Specification of the Package Indexed_lO

in FILETYPE;

out

ELEMENTTYPE);

14-28

generic
type KEYTYPE is private;
DEFAULTKEYNUMBER

INTEGER

procedure READBYKEY (FILE

ITEM

KEYNUMBER
RELATION
(FILE
ITEM

:
:

>: in

FILETYPE;

: in

KEYTYPE;

> out ELEMENTTYPE;

KEY

procedure WRITE

:= 0;

INTEGER :=
DEFAULTKEYNUMBER;
RELATIONTYPE := EQUAL);

in FILETYPE;
in ELEMENTTYPE) ;

procedure UPDATE(FILE : in FILETYPE;

ITEM : in ELEMENTTYPE);

procedure UNLOCK(FILE : in FILETYPE);

procedure DELETEELEMENT(FILE : in FILETYPE);
function ENDOFFILE(FILE : in FILETYPE)

return BOOLEAN;

-- Exceptions
STATUSERROR
MODEERROR
NAMEERROR
USEERROR
DEVICEERROR

END_ERROR

DATAERROR
LOCKERROR
KEYERROR

:
:
:
:
:

exception
exception
exception
exception
exception

renames
renames
renames
renames
renames

IOEXCEPTIONS.STATUS_ERROR;
IOEXCEPTIONS.MODEERROR;
IOEXCEPTIONS.NAMEERROR;
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICEERROR;

: exception renames IOEXCEPTIONS.ENDERROR;

: exception renames IOEXCEPTIONS.DATAERROR;
: exception renames AUX_IOEXCEPTIONS.LOCK_ERROR;
: exception renames AUX_IOEXCEPTIONS.KEYERROR;

EXISTENCEERROR : exception
renames AUXIOEXCEPTIONS.EXISTENCEERROR;

private
-- implementation-dependent

end INDEX_I0;

References: aux_io_exceptions package 14.4, close procedure 14.2.1, create
procedure 14.2a.1, data_error exception 14.4, delete procedure 14.2.1, delete_element
procedure 14.2a.4, device_error exception 14.4, element_type 14.1, end_error
exception 14.4, end_of_file function 14.2a.4, existence_error exception 14.4, file_

mode 14.1, file_type 14.1, form function 14.2.1, form parameter 14.1, io_exceptions
package 14.4, is_open function 14.2.1, key 14.2a, key_error exception 14.4, lock_
error exception 14.4, mode function 14.2.1, mode_error exception 14.4, name
function 14.2.1, name_error exception 14.4, open procedure 14.2.1, read procedure
14.2a.4, read_by_key procedure 14.2a.4, record size 14.2b, relation_type 14.2a,
reset procedure 14.2a.1, status_error exception 14.4, unconstrained type 3.3 3.3.2,
unlock procedure 14.2a.4, update procedure 14.2a.4, use_error exception 14.4, write
procedure 14.2a.4

14-29

Specification of the Package Indexed_IO

14.2a.5

14.2b Mixed-Type Input-Output
The predefined packages SEQUENTIAL_MIXED_IO, DIRECT_MIXED_IO,
RELATIVE_MIXED_IO, and INDEXED_MIXED_IO provide types and

operationsfor files consisting of elements with any mixture of various types.
Section 14.7a gives an example of using a mixed-type input-output package.

Each file opened by one of these mixed-type input-output packages has an
associated file buffer, which is maintained by the package. Thesize of the
file buffer is limited by the maximum recordsize of the external file.
Element input-output operations, such as READ and WRITE,provide the
meansfor reading a file element into the file buffer (and thus reading a
record of the associated external file), or writing the contents of thefile

buffer into an element (and thus writing a record of the associated external
file).
Item input-output operations, such as GET and PUT, provide the meansfor
transferring a value from orto thefile buffer: The file buffer may contain
zero or more itemsofthefile element. Every element transfer begins on
a byte boundary andinvolves the numberof bits required by the type of
the item; the position or current position in thefile buffer is thus a byte
offset from the beginning of the buffer. All of the predefined mixed-type
input-output packages provide the same item input-output operations; see
section 14.2b.2.
Element (VMS RMSrecord) locking is provided for RELATIVE_MIXED_IO
and INDEXED_MIXED_IO. A brief explanation of how locking affects

relative and indexedfiles containing elements of the same type is given
at the end of section 14.2a; the same information applies to relative and
indexedfiles containing elements of mixed types.
References: direct file 14.2, element 14.1a, locking 14.2a, external file 14.1,
indexed file 14.2, open file 14.1, package 7, relative file 14.2, sequential file 14.2,
VMS RMSrecord 14.1a

14.2b.1

File Management
Except for the following differences, the procedures and functions for
controlling access to files containing mixed-type values are the same as
those for controlling access to files containing values of the same type (see
14.2.1 and 14.2a.1). The default mode for the CREATEprocedure of the
- package SEQUENTIAL_MIXED_IO is OUT_FILE;the default mode for the
CREATE procedures of the packages DIRECT_MIXED_IO, RELATIVE_
MIXED_IO, and INDEXED_MIXED_IO is INOUT_FILE.

14.2b.1

File Management

14-30

For the packages DIRECT_MIXED_IO and RELATIVE_MIXED_IO,a
maximum record size must be specified in the FORM parameterof the
CREATE procedures.
procedure CREATE(FILE : in out FILETYPE;
MODE :
NAME :
FORM :

in FILEMODE := INOUT_FILE;
in STRING := "";
in STRING := "");

-- Example:
-- procedure CREATE (FILE => MYFILE;
-FORM => "RECORD; "
&
_"SIZE 128" );

For the package INDEXED_MIXED_IO,all information about the file keys

must be specified in the FORM parameter of the CREATE procedure.
procedure CREATE(FILE : in out FILETYPE;
MODE : in FILEMODE := INOUT_FILE;
NAME : in STRING := "";
FORM : in STRING) ;

-- Example:

-- procedure CREATE(FILE => MYFILE;
_FORM => "KEY 0;"
-"LENGTH
5;"
&
-"POSITION 0;"
&
-"TYPE
STRING; ");

References: direct_mixed_io package 14.2 14.2b 14.2b.5, file 14.1, file mode 14.1,
form parameter 14.1 14.1b, function 6.5, indexed_mixed_io package 14.2a 14.2b
14.2b.9, inout_file 14.1, key 14.2a, out_file 14.1, procedure 6.1, relative_mixed_io
package 14.2a 14.2b 14.2b.7, sequential_mixed_io package 14.2 14.2b 14.2b.3

14.2b.2

Item Input-Output
The same item input-output operations are available in all four VAX Ada
mixed-type input-output packages: SEQUENTIAL_MIXED_IO, DIRECT_
MIXED_IO, RELATIVE_MIXED_IO, and INDEXED_MIXED_IO. This
section describes the operations that provide item input and output to and
from the file buffer.
All of the mixed-type packages provide generic GET_ITEM, GET_ARRAY,
and PUT_ITEM procedures, which define buffer input and output for given
item and item-array types. The GET_ITEM and PUT_ITEM procedures

14-31

Item Input-Output

14.2b.2

must be instantiated with an actual type parameter for the generic pa-

rameter ITEM_TYPE. The GET_ARRAYprocedure must be instantiated

with actual type parameters for the generic parameters ITEM_TYPE (to
determine the array component types), INDEX (to determine how the array
is indexed), and ITEM_ARRAY(to determinethe array to be output).
generic

type ITEMTYPE is private;

procedure GETITEM(FILE : in FILETYPE;

ITEM : out ITEMTYPE);

Operates on file buffer for a file of mode IN_FILE or INOUT_FILE.

Gets an item from the file buffer at the current position, and returns
its value in the parameter ITEM. Then, the current position in the
file buffer is updated to the position of the next item.
The exception MODE_ERRORisraised if the current modeof the

given file is OUT_FILE. The exception LAYOUT_ERRORisraised if
no more items can be read from thefile buffer.

generic
type ITEMTYPE is private;

type INDEX is (<>);

type ITEMARRAY is array (INDEX range <>) of ITEMTYPE;

procedure GETARRAY(FILE
|

: in FILETYPE;

ITEMS
LAST

:
:

out ITEMARRAY;
out INDEX);

Operates on a file buffer for a file of mode IN_FILE or INOUT_FILE.
Gets the remaining items in thefile buffer, and returns their values
in the parameter ITEMS. Then, sets LAST to the index of the last
element of ITEMS that is updated. Reading stops when the array
ITEMSis full or when no more itemscan be read from thefile buffer.
The current position in the file buffer is updated to the position after
the last position read.

If no items are read, returns in LAST an index value that is one less
than ITEMS’ FIRST.
The exception MODE_ERRORisraised if the current mode of the
given file is OUT_FILE.
generic
type ITEMTYPE is private;

procedure PUT_ITEM(FILE

in FILETYPE;

ITEM

in ITEMTYPE);

Operates on a file buffer for a file of mode OUT_FILE or INOUT_
FILE. The value of the parameter ITEM is written into thefile
buffer at the current position, and the current position is updated to
the position of the next item in the file buffer.

14.2b.2

Item Input-Output

14-32

The exception MODE_ERRORisraised if the current mode of the
given file is IN_FILE. The exception LAYOUT_ERRORisraisedif
the current position exceeds thefile buffer size. Thefile buffer size
is limited by the maximum size of a record in the external file.
function ENDOFBUFFER(FILE : in FILETYPE)

return BOOLEAN;

Operates on file buffer for a file of mode IN_FILE or INOUT_FILE.

Returns TRUE if there are no more items to be read from thefile
buffer. Returns FALSE otherwise.

The exception MODE_ERRORisraised if the current mode of the
given file is OUT_FILE.
procedure SETPOSITION(FILE
TO

:
:

in FILETYPE;
in POSITIVECOUNT) ;

Operates on a file buffer for a file of any mode. Sets the current
position of the file buffer to the position specified by the value of TO.
function POSITION(FILE : in FILETYPE) return POSITIVECOUNT;

Operates on a file buffer for a file of any mode. Returns the current
position in thefile buffer.
|
function MAXELEMENTSIZE(FILE

in FILETYPE)

return COUNT;

Operates on a file of any mode. Returns the maximum record
(element) size (in bytes) specified for the external file. The maximum
record size, in turn, defines the limits for the size of the file buffer.

A value of zero indicates that there is no maximum record size
associated with the file; the buffer size is limited only by the
maximum size of a VMS RMSrecord.

A maximum record size may be specified for a file (when it is created)
with a FORM parameter value that includes the string "RECORD;
SIZE max_record_size".
function ELEMENTSIZE(FILE : in FILETYPE) return COUNT;

Operates on a file buffer for a file of mode IN_FILE or INOUT_FILE.
Returns the size (in bytes) of the record (element) last read into the

file buffer. If no records have ever been read into thefile buffer, a

value of zero is returned.

The ELEMENT_SIZEfunction can be used in combination with the

POSITION function to determine the numberof bytes remaining

in thefile buffer (of the last element read): ELEMENT_SIZE (F) —

POSITION (F) + 1, for any file F.

14-33

Item Input-Output

14.2b.2

The exception MODE_ERRORisraised if the modeis not IN_FILE
or INOUT_FILE. |
References: buffer size 14.2b, current position 14.2b, direct_mixed_io package
14.2 14.2b 14.2b.3, external file 14.1, file 14.1, file buffer 14.2b, file mode 14.1,
indexed_mixed_io package 14.2a 14.2b 14.2b.9, in_file 14.1, inout_file 14.1, item
14.2b, layout_error exception 14.4, mode_error exception 14.4, out_file 14.1, relative_
mixed_io package 14.2a 14.2b 14.2b.7, sequential_mixed_io package 14.2 14.2b
14.2b.3, VMS RMSrecord 14.1la

14.2b.3

Sequential Mixed Input-Output
The operations available for sequential mixed-type input and output are
described in this section. The exception STATUS_ERRORis raised if any of
these operations is attempted for a file that is not open.
See sections 14.2b.1 and 14.2b.2 for information on the file management and
item input-output operations that are available for sequential mixed input
and output.
procedure READ(FILE : in FILETYPE);

Operates on a file of mode IN_FILE. Reads the next sequential
element from the givenfile into thefile buffer.
The exception MODE_ERRORisraised if the mode is not IN_FILE.

The exception END_ERRORisraised if an attempt is made to read

past the end ofthefile.

procedure WRITE(FILE : in FILETYPE);

Operates on a file of mode OUT_FILE.Writesthe file buffer to the
given file as a new element. If the external file record format is fixed
and the current position in the file buffer does not indicate the end
of the buffer, the rest of the buffer is filled with zero bits before being
written to thefile.
The exception MODE_ERRORis raised if the mode is not OUT_

FILE.

function ENDOFFILE(FILE : in FILETYPE) return BOOLEAN;
Operates on a file of mode IN_FILE. Returns TRUE if no more

elements can be read from the givenfile; otherwise returns FALSE.
The exception MODE_ERRORisraised if the mode is not IN_FILE.

14.2b.3

Sequential Mixed Input-Output

14-34

References: current position 14.2b, element 14.1a, end_error exception 14.4,

external file 14.1, file 14.1, file buffer 14.2b, file mode 14.1, in_file 14.1, mixed-type
file 14.1a, mode_error exception 14.4, open file 14.1, out_file 14.1, sequential file
14.2, status_error exception 14.4

14.2b.4

Specification of the Package Sequential_Mixed_!O
with IOEXCEPTIONS;
package SEQUENTIALMIXEDIO is
type FILETYPE is limited private;
type FILEMODE is (IN_FILE, OUT_FILE);
type COUNT is range 0 .. INTEGER’ LAST;
subtype POSITIVECOUNT is COUNT range 1

COUNT’ LAST;

-- File management

in out FILETYPE;
in FILEMODE := OUT_FILE;

procedure CREATE (FILE
MODE
NAME

in STRING := "";
wir) ;
FORM : in STRING

procedure OPEN

(FILE

in out FILETYPE;

MODE : in FILEMODE;
NAME : in STRING;

FORM : in STRING := "");
procedure CLOSE (FILE :
in out FILETYPE);
procedure DELETE(FILE : in out FILETYPE);
procedure RESET

(FILE

in out FILETYPE;

procedure RESET

(FILE : in out FILETYPE);

function MODE
function NAME
function FORM

(FILE : in FILETYPE) return FILEMODE;
(FILE : in FILETYPE) return STRING;
(FILE : in FILETYPE) return STRING;

MODE : in FILEMODE);

function ISOPEN(FILE

in FILETYPE)

return BOOLEAN;

-- Item input and output operations
generic

type ITEMTYPE is private;
procedure GETITEM (FILE : in FILETYPE; ITEM : out ITEMTYPE);
generic
type ITEMTYPE is private;
type INDEX is (<>);
type ITEMARRAY is array (INDEX range <>) of ITEMTYPE;
procedure GETARRAY(FILE
ITEMS
LAST

14-35

: in FILETYPE;
: out ITEMARRAY;
: out INDEX);

Specification of the Package Sequential_Mixed_lO

14.2b.4

generic
type ITEMTYPE is private;
procedure PUTITEM (FILE : in FILETYPE; ITEM : in ITEMTYPE);

function ENDOFBUFFER(FILE : in FILETYPE) return BOOLEAN;

procedure SETPOSITION(FILE
TO
function POSITION(FILE

:
:

in FILETYPE;
in POSITIVECOUNT) ;

in FILETYPE)

return POSITIVECOUNT;

function MAXELEMENTSIZE(FILE : in FILETYPE) return COUNT;
function ELEMENTSIZE(FILE : in FILETYPE) return COUNT;
-- Element input and output operations
procedure READ

(FILE

in FILETYPE);

procedure WRITE(FILE : in FILETYPE);
function ENDOFFILE(FILE

in FILETYPE)

return BOOLEAN;

-- Exceptions
STATUSERROR

USE_ERROR

: exception renames IOEXCEPTIONS.USE_ERROR;

MODEERROR
NAMEERROR

exception renames IO EXCEPTIONS.STATUS_ERROR;

: exception renames IOEXCEPTIONS.MODE_ERROR;
> exception renames IOEXCEPTIONS.NAMEERROR;

DEVICEERROR : exception renames IOEXCEPTIONS.DEVICEERROR;
END_ERROR
> exception renames IOEXCEPTIONS.ENDERROR;
DATA_ERROR
: exception renames IO_EXCEPTIONS.DATA_ERROR;
private
-- implementation-dependent

end SEQUENTIALMIXEDIO;

References: close procedure 14.2.1, count type 14.2, create procedure 14.2.1, data__
error exception 14.4, delete procedure 14.2.1, device_error exception 14.4, element_
size function 14.2b.2, end_error exception 14.4, end_of_buffer function 14.2b.2,
end_of_file function 14.2b.3, file_mode 14.1, file_type 14.1, form function 14.2.1,

get_array procedure 14.2b.2, get_item procedure 14.2b.2, io_exceptions package 14.4,

is_open function 14.2.1, item_array 14.2b.2, item_type 14.2b.2, max_element_size

function 14.2b.2, mode function 14.2.1, mode_error exception 14.4, name function
14.2.1, name_error exception 14.4, open procedure 14.2.1, position function 14.2b.2,
put_item procedure 14.2b.2, read procedure 14.2b.3, reset procedure 14.2.1, set_
position procedure 14.2b.2, status_error exception 14.4, use_error exception 14.4,
write procedure 14.2b.3

14.2b.5

Direct Mixed Input-Output
The operations available for direct mixed-type input and output are described in this section. The exception STATUS_ERRORisraised if any of
these operations is attempted for a file that is not open.

14.2b.5

Direct Mixed Input-Output

14-36

See Sections 14.2b.1 and 14.2b.2 for information on the file management and
element input-output operations that are available for direct mixed input
and output.
procedure READ (FILE : in FILETYPE;

FROM : in POSITIVECOUNT) ;

procedure READ

(FILE : in FILETYPE);

Operates on a file of mode IN_FILE or INOUT_FILE.In the case of
the first form, sets the current index of the givenfile to the index
value given by the parameter FROM.Then (for both forms) returns,
in the file buffer, the value of the element whose position is specified
by the current index of thefile; finally, increases the current index
by one.
The exception MODE_ERRORisraised if the modeof the givenfile

is OUT_FILE. The exception END_ERRORisraised if the index to
be used exceeds the size of the externalfile.
procedure WRITE (FILE : in FILETYPE;

procedure WRITE

: in POSITIVECOUNT);

(FILE : in FILETYPE);

Operates on a file of mode INOUT_FILE or OUT_FILE. In the case

of the first form, sets the index of the given file to the index value
given by the parameter TO. Then (for both forms) writes thefile
buffer to the element whoseposition in the givenfile is specified by
the current index of thefile; finally, increases the current index by

one. If the current position in the file buffer does not indicate the

end of the buffer, the rest of the file buffer is filled with zero bits

before being written to thefile.

The exception MODE_ERRORis raised if the mode of the givenfile
is IN_FILE.

procedure SETINDEX(FILE : in FILETYPE;
TO
: in POSITIVECOUNT) ;
Operates on file of any mode. Sets the current index of the given
file to the index value given by the parameter TO. The value may
exceed thesize ofthefile.
function INDEX(FILE

in FILETYPE)

return POSITIVECOUNT;

Operates on a file of any mode. Returns the current index of the
givenfile.

14-37

Direct Mixed Input-Output

14.2b.5

function SIZE(FILE

in FILETYPE)

return COUNT;

Operates on a file of any mode. Returns the numberof elements
(VMS RMSrecords) in thefile.

function ENDOFFILE(FILE : in FILETYPE) return BOOLEAN;
Operates on a file of mode IN_FILE or INOUT_FILE. Returns TRUE
if the current index exceeds the size of the external file; otherwise
returns FALSE.
The exception MODE_ERRORisraised if the current mode is OUT_
FILE.
References: current index 14.2a, current position 14.2b, direct file 14.2, element
14.1a, end_error exception 14.4, external file 14.1, file 14.1, file buffer 14.2b,file
mode 14.1, index 14.2, in_file 14.1, inout_file 14.1, mixed-type file 14.1a, mode_error
exception 14.4, open file 14.1, out_file 14.1, status_error exception 14.4, VMS RMS
record 14.la

14.2b.6

Specification of the Package Direct_Mixed_lO
with IOEXCEPTIONS;

package DIRECTMIXEDIO is
type FILETYPE is limited private;
type FILEMODE is

(INFILE,

INOUTFILE,

OUTFILE);

type COUNT is range 0 .. INTEGER’ LAST;
subtype POSITIVECOUNT is COUNT range 1 .. COUNT’ LAST;
-- File management

procedure CREATE(FILE : in out FILETYPE;

-- NOTE:

MODE

in FILEMODE

NAME

in STRING

:= "";

FORM

A maximum record

STRING

(element)

INOUTFILE;

"");

size must be

-~ specified in the FORM parameter of the CREATE
-- procedure.

procedure OPEN

(FILE : in out FILETYPE;
MODE : in FILEMODE;

NAME : in STRING;

FORM : in STRING := "");
procedure CLOSE (FILE :
in out FILETYPE);
procedure DELETE(FILE : in out FILETYPE);

procedure RESET (FILE : in out FILETYPE; MODE : in FILEMODE);
procedure RESET (FILE : in out FILETYPE);

14.2b.6

Specification of the Package Direct_Mixed_lO

14-38

function MODE

function NAME

function FORM

(FILE : in FILETYPE) return FILEMODE;

(FILE : in FILETYPE)

return STRING;

(FILE : in FILETYPE) return STRING;

function ISOPEN(FILE

in FILETYPE)

return BOOLEAN;

-- Item input and output operations
generic

type ITEMTYPE is private;

procedure GETITEM

(FILE

in FILETYPE;

ITEM

out ITEMTYPE);

generic

type ITEMTYPE is private;

type INDEX is (<>);
type ITEMARRAY is array (INDEX range <>) of ITEMTYPE;

procedure GETARRAY(FILE

: in FILETYPE;

ITEMS : out ITEMARRAY;
LAST
: out INDEX);

generic

type ITEMTYPE is private;

procedure PUTITEM (FILE : in FILETYPE; ITEM : in ITEMTYPE);
function END_OFBUFFER(FILE

in FILETYPE)

return BOOLEAN;

procedure SETPOSITION(FILE : in FILETYPE;

TO : in POSITIVECOUNT) ;

function POSITION

(FILE

in FILETYPE)

return POSITIVECOUNT;

function MAXELEMENTSIZE(FILE : in FILE_TYPE) return COUNT;
function ELEMENTSIZE(FILE : in FILETYPE) return COUNT;
-- Element input and output operations

procedure READ (FILE : in FILETYPE;
procedure READ

FROM : in POSITIVECOUNT) ;

(FILE : in FILETYPE);

procedure WRITE(FILE : in FILETYPE;
TO
: in POSITIVECOUNT) ;

procedure WRITE(FILE : in FILETYPE);

procedure SETINDEX(FILE : in FILETYPE;
TO

: in POSITIVECOUNT) ;

function INDEX

(FILE : in FILETYPE)

return POSITIVECOUNT;

function SIZE

(FILE : in FILETYPE) return COUNT;

function ENDOFFILE(FILE : in FILETYPE) return BOOLEAN;

14-39

Specification of the Package Direct_Mixed_lO

14.2b.6

-- Exceptions
STATUSERROR : exception renames IOEXCEPTIONS.STATUS_ERROR;
MODEERROR
: exception renames IOEXCEPTIONS.MODE_ERROR;

NAMEERROR

USE_ERROR
DEVICEERROR
END_ERROR
DATAERROR

: exception renames IOEXCEPTIONS.NAMEERROR;

:
:
:
:

exception
exception
exception
exception

renames
renames
renames
renames

IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICEERROR;
IOEXCEPTIONS.END_ERROR;
IOEXCEPTIONS.DATAERROR;

private
-~- implementation-dependent

end DIRECTMIXEDIO;

References: close procedure 14.2.1, count type 14.2, create procedure 14.2b.1,

data_error exception 14.4, delete procedure 14.2.1, device_error exception 14.4,

element_size function 14.2b.2, end_error exception 14.4, end_of_buffer function
14.2b.2, end_of_file function 14.2b.5, file_mode 14.1, file_type 14.1, form function
14.2.1, get_array procedure 14.2b.2, get_item procedure 14.2b.2, index function
14.2b.5, io_exceptions package 14.4, is_open function 14.2.1, item_array 14.2b.2,

item_type 14.2b.2, max_element_size function 14.2b.2, mode function 14.2.1,
mode_error exception 14.4, name function 14.2.1, name_error exception 14.4,

open procedure 14.2.1, position function 14.2b.2, put_item procedure 14.2b.2, read
procedure 14.2b.5, reset procedure 14.2.1, set_index procedure 14.2b.5, set_position
procedure 14.2b.2, size function 14.2b.5, status_error exception 14.4, use_error

exception 14.4, write procedure 14.2b.5

14.2b.7

Relative Mixed Input-Output
The operations available for relative mixed-type input and output are
described in this section. The exception STATUS_ERRORisraised if any of
these operations is attempted for a file that is not open.
See sections 14.2b.1 and 14.2b.2 for information on the file management and
element input-output operations that are available for relative mixed input
and output.
procedure READ

(FILE : in FILETYPE;
FROM : in POSITIVECOUNT) ;

procedure READ

(FILE

in FILETYPE);

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of
the first form, sets the current index of the givenfile to the index
value given by the parameter FROM.Then (for both forms) returns,
in the file buffer, the value of the element whoseposition is specified
by the current index of the given file. The element read becomes the
current element, and the current index is increased by one.

14.2b.7

Relative Mixed Input-Output

14—40

The exception MODE_ERRORisraised if the current mode is OUT_
FILE. The exception LOCK_ERRORisraised if the element to be

read is locked; this error is possible only if the external file is being
shared. The exception EXISTENCE_ERRORisraised if the element
does not exist (that is, the given cell is empty or the current index is
beyond the endofthefile).
procedure READEXISTING

(FILE
FROM

:
:

in FILETYPE;
in POSITIVECOUNT) ;

procedure READEXISTING

(FILE

in FILETYPE);

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, sets the current index of the given file to the index
value given by the parameter FROM.Then (for both forms) starts
at the current index and scans forward, skipping empty cells, and
sets the current index to thefirst nonempty cell. Then returns, in
the file buffer, the value of the element whose position is specified
by the current index of the given file. The element read becomes the
current element, and the current index is increased by one.
The exception MODE_ERRORisraised if the mode of the given file

is OUT_FILE. The exception LOCK_ERRORisraised if the element

to be read is locked; this error is possible only if the external file is
being shared. The exception EXISTENCE_ERRORisraised if the

current index is beyond the endofthe file, or if the end of the file is
reached before an existing element (nonemptycell) is found.

procedure WRITE

(FILE
TO

:
;

in FILETYPE;
in POSITIVECOUNT) ;

procedure WRITE

(FILE

in FILETYPE);

Operates on a file of mode INOUT_FILE or OUT_FILE.In the case
of the first form, sets the current index of the given file to the index
value given by the parameter TO. Then (for both forms) writes the
contents of the file buffer to the cell whose position in the givenfile
is specified by the current index of the file; finally, increases the
current index by one. If the format of the associated external file
is fixed and the current position in thefile buffer does not indicate

the end of the buffer, the rest of the file buffer is filled with zero bits

before being written to thefile.

The exception MODE_ERRORisraised if the modeof the givenfile
is IN_FILE. The exception USE_ERRORis raised if the element

position in thefile has already been written.

Relative Mixed Input-Output

14.2b.7

procedure UPDATE(FILE : in FILETYPE);

Operates on a file of mode INOUT_FILE. Updates the current.
element with the contentsof thefile buffer.
The exception MODE_ERRORisraised if the current mode is not

INOUT_FILE. The exception USE_ERRORis raised if the current

element is undefined at the start of this operation.

procedure UNLOCK (FILE : in FILETYPE);
Operates on a file of any mode. After this operation, the current
element is undefined.
procedure DELETEELEMENT(FILE

in FILETYPE);

Operates on file of mode INOUT_FILE. Deletes the current
elementin thefile.
The exception MODE_ERRORisraised if the current mode is not

INOUT_FILE. The exception USE_ERRORis raised if the current
element is undefined at the start of this operation.

procedure SETINDEX(FILE : in FILETYPE;

TO : in POSITIVECOUNT) ;

Operates on a file of any mode. Sets the current index of the given
file to the index value specified by the parameter TO.
function INDEX (FILE : in FILETYPE)

return POSITIVECOUNT;

Operates on a file of any mode. Returns the current index of the
given file.
function ENDOFFILE(FILE

in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE.Returns

TRUE if nocell, starting at the current index, contains an element;
otherwise returns FALSE.

The exception MODE_ERRORisraised if the current mode is OUT_
FILE.
References: cell 14.2a, current element 14.2a, current index 14.2a, current
mode 14.1, current position 14.2b, element 14.1la, end of file 14.2a, existence_error
exception 14.4, file 14.1, file buffer 14.2b, file mode 14.1, file sharing 14.2a, index
14.2a, in_file 14.1, inout_file 14.1, lock_error exception 14.4, locking 14.2a, mixedtype file 14.1a, mode_error exception 14.4, open file 14.1, out_file 14.1, relative
file 14.2a, status_error exception 14.4, undefined current element 14.2a, use_error
exception 14.4

14.2b.7

Relative Mixed Input-Output

14-42

14.2b.8

Specification of the Package Relative_Mixed_!lO
with IOEXCEPTIONS;
with AUX_IOEXCEPTIONS;

package RELATIVEMIXEDIO is
type FILETYPE is limited private;
type FILEMODE is

(INFILE,

INOUTFILE,

OUTFILE);

type COUNT is range 0 .. INTEGER’ LAST;
subtype POSITIVECOUNT is COUNT range 1 .. COUNT’ LAST;
-- File management

procedure CREATE(FILE : in out FILETYPE;

MODE : in FILEMODE := INOUTFILE;
NAME : in STRING := "";

FORM : in STRING := "");
-~- NOTE: A maximum record (element) size must be
-~- specified in the FORM parameter of the CREATE
-- procedure.

procedure OPEN

(FILE : in out FILETYPE;
MODE : in FILEMODE;
NAME : in STRING;
FORM : in STRING := "");

procedure CLOSE (FILE : in out FILETYPE);
procedure DELETE(FILE : in out FILETYPE);

procedure RESET (FILE : in out FILETYPE; MODE : in FILEMODE);
procedure RESET (FILE : in out FILE_TYPE);
function MODE

function NAME
function FORM

(FILE : in FILETYPE)

return FILEMODE;

(FILE : in FILETYPE) return STRING;
(FILE : in FILETYPE) return STRING;

function IS_OPEN(FILE

in FILE_TYPE) return BOOLEAN;

-- Item input and output operations

generic
type ITEMTYPE is private;
procedure GETITEM(FILE : in FILETYPE; ITEM : out ITEM_TYPE) ;
generic
type ITEMTYPE is private;

type INDEX is (<>);

type ITEMARRAY is array (INDEX range <>) of ITEMTYPE;

procedure GETARRAY(FILE
generic

: in FILE_TYPE;

ITEMS : out ITEMARRAY;
LAST
: out INDEX);

type ITEMTYPE is private;
procedure PUT_ITEM (FILE : in FILETYPE; ITEM : in ITEMTYPE);

14-43

Specification of the Package Relative_Mixed_lIO

14.2b.8

function ENDOFBUFFER (FILE

in FILETYPE) return BOOLEAN;

procedure SETPOSITION (FILE

in FILETYPE;
in POSITIVECOUNT) ;

function POSITION

(FILE

in FILETYPE) return POSITIVECOUNT;

function MAXELEMENTSIZE (F ILE

in FILETYPE) return COUNT;

function ELEMENTSIZE(FILE

-- Element input and output operations

in FILETYPE;
in POSITIVECOUNT) ;
procedure READ
in FILETYPE);
in FILETYPE;
procedure READ_EXISTING (FILE
FROM : in POSITIVECOUNT) ;
procedure READEXISTING (FILE
in FILETYPE);
in FILETYPE;
procedure WRITE (FILE
in POSITIVECOUNT) ;
TO
procedure WRITE (FILE
in FILETYPE) ;
in FILETYPE);
procedure UPDATE (FILE
procedure READ

(FILE
FROM :
(FILE

procedure UNLOCK

(FILE

in FILETYPE);

procedure DELETEELEMENT (FI LE

in FILETYPE);

in FILETYPE;
in POSITIVECOUNT) ;
function INDEX (FILE
in FI LETYPE) return POSITIVECOUNT;
in FILETYPE) return BOOLEAN;
function ENDOFFILE (FILE

procedure SETINDEX (FILE
TO

-- Exceptions

STATUSERROR
MODE_ERROR
NAMEERROR
USE_ERROR
DEVICEERROR
END_ERROR
DATA_ERROR
LOCK_ERROR
EXISTENCEERROR

exception renames IOEXCEPTIONS. STATUSERROR;
exception renames IOEXCEPTIONS. MODEERROR;
exception renames IOEXCEPTIONS. NAMEERROR;
exception renames IOEXCEPTIONS. USE_ERROR;
exception renames IOEXCEPTIONS. DEVICEERROR;
exception renames IOEXCEPTIONS.ENDERROR;
exception renames IOEXCEPTIONS.DATAERROR;
exception renames AUX_IOEXCEPTIONS. LOCKERROR;
exception

renames AUXIOEXCEPTION S.EXISTENCEERROR;

private
-- implementation-dependen t
end RELATIVEMIXEDI0;

14.2b.8

Specification of the Package Relative_Mixed_ lO

14-44

References: aux_io_exceptions package 14.4, close procedure 14.2.1, count type

14.2, create procedure 14.2b.1, data_error exception 14.4, delete procedure 14.2.1,

delete_element procedure 14.2b.7, device_error exception 14.4, element_size function
14.2b.2, end_error exception 14.4, end_of_buffer function 14.2b.2, end_of_file function
14.2b.7, existence_error exception 14.4, file_mode 14.1, file_type 14.1, form function
14.2.1, get_array procedure 14.2b.2, get_item procedure 14.2b.2, index 14.2b.2, index
function 14.2b.7, io_exceptions package 14.4, is_open function 14.2.1, item_array
14.2b.2, item_type 14.2b.2, lock_error exception 14.4, max_element_size function

14.2b.2, mode function 14.2.1, mode_error exception 14.4, name function 14.2.1,
name_error exception 14.4, open procedure 14.2.1, position function 14.2b.2, put_
item procedure 14.2b.2, read procedure 14.2b.7, read_existing procedure 14.2b.7,
reset procedure 14.2.1, set_index procedure 14.2b.7, set_position procedure 14.2b.2,
status_error exception 14.4, unlock procedure 14.2b.7, update procedure 14.2b.7,
use_error exception 14.4, write procedure 14.2b.7

14.2b.9

Indexed Mixed Input-Output
The operations available for indexed mixed-type input and output are
described in this section. The exception STATUS_ERRORis raised if any of
these operations is attempted for a file that is not open.
See sections 14.2b.1 and 14.2b.2 for information on the file management and
element input-output operations that are available for indexed mixed input
and output.
This package provides a generic READ_BY_KEYprocedure, which defines
input for the given element type. This procedure must be instantiated with
an actual type parameter for the generic parameter KEY_TYPE; it may be
instantiated with or without a value for the generic parameter DEFAULT_
KEYNUMBER.The range of values for DEFAULT_KEY_NUMBERis 0 to

254; a value of 0 (the default) designates the primary key.

If the RELATION parameter to the READ_BY_KEYprocedureis specified,
it must have a value of EQUAL_NEXT, EQUAL, or NEXT (the default is
EQUAL).
procedure READ(FILE : in FILETYPE);
generic
type KEYTYPE is private;
DEFAULTKEYNUMBER : INTEGER := 0;
procedure READBYKEY (FILE
: in
FILETYPE;
KEY
: in
KEYTYPE;
KEYNUMBER : in
INTEGER :=
DEFAULTKEYNUMBER;
RELATION
: in
RELATIONTYPE := EQUAL);

14-45

Indexed Mixed Input-Output

14.2b.9

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, returnsin the file buffer the value of the next element,
according to the last specified key and relation information. In the
case of the second form, returns in thefile buffer the value of the
element specified by the given key information; KEY gives the key
value; KEY_NUMBERdesignates a primary (0) or alternate key
(1 to 254); and RELATION determines the kind of match to be made

for the key value. For both forms, the element read becomes the
current element. In the case of the first form, the next sequential
element becomes the next element, according to the most recent key
and relation information. In the case of the second form, the next

sequential element that matches the key andrelation information
specified becomes the next element. If neither the key nor the
relation information changes from one READ_BY_KEY operation to
the next, the same element will continue to be read.
The exception MODE_ERRORisraised if the current mode is OUT_
FILE. The exception END_ERRORisraised if an attempt is made to
read past the end of thefile by the first form. The exception LOCK_
ERRORis raised if the element to be read is locked; this error is
possible only if the external file is being shared. The exception
EXISTENCE_ERRORis raised if the element does not exist. The
exception KEY_ERRORis raised if the size of the given key is not a
multiple of eight bits.
procedure WRITE(FILE : in FILETYPE);

Operates on a file of mode INOUT_FILE or OUT_FILE. Gives the
value of the file buffer to the element whose position in the givenfile
is specified by the key information contained within the file buffer.
If the format of the associated external file is fixed and the current
position in the file buffer does not indicate the end of the buffer, the
rest of the file buffer is filled with zero bits before being written to
the file.
The exception MODE_ERRORisraised if the current modeis

IN_FILE. The exception USE_ERRORisraised if the element

Operates on a file of mode INOUT_FILE. Updates the current

element of the given file with the contents of the file buffer. If the
format of the associated external file record is fixed and the current
position in the file buffer does not indicate the end of the buffer, the
14.2b.9

Indexed Mixed Input-Output

14—46

rest of the file buffer is filled with zero bits before being written to
thefile.
The exception MODE_ERRORisraised if the current modeis not

INOUT_FILE. The exception USE_ERRORisraised if the current
element is undefined at the start of this operation or if some key

specification in the file buffer violates the external file attributes

defined for that key. The exception KEY_ERRORisraised if a key
has been changed or duplicated and if changes or duplicates are not
allowed by the external file. ©
procedure UNLOCK(FILE : in FILETYPE);

Operates on a file of any mode. After this operation, the current
element is undefined.
procedure DELETEELEMENT(FILE : in FILETYPE);

Operates on file of mode INOUT_FILE. Deletes the current
elementof thefile.
The exception MODE_ERRORis raised if the current modeis not
INOUT_FILE. The exception USE_ERRORis raised if the current

element is undefined at the start of this operation.

function ENDOFFILE(FILE : in FILETYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE. Returns TRUE

if there are no more elements (according to the most recent key
and relation information) starting at the next elementin thefile;
otherwise returns FALSE.
The exception MODE_ERRORisraised if the current modeis
OUT_FILE.

References: current element 14.2a, current position 14.2b, element 14.1a,
element_type 14.1, end_error exception 14.4, existence_error exception 14.4, external
file 14.1, file 14.1, file buffer 14.2b, file mode 14.1, file sharing 14.2a, generic actual
parameter 12.3, generic formal parameter 12.3, generic procedure 12.1, indexed file
14.2a, in_file 14.1, inout_file 14.1, instantiation 12.3, key 14.2a, key_error exception
14.4, lock_error exception 14.4, locking 14.2a, match 14.2a, mixed-type file 14.1a,
mode_error exception 14.4, next element 14.2a, open file 14.1, out_file 14.1, range
3.5 relation_type 14.2a, status_error exception 14.4, use_error exception 14.4

14-47

Indexed Mixed Input-Output

14.2b.9

14.2b.10

Specification of the Package Indexed_Mixed_lO
with IOEXCEPTIONS;
with AUX_IOEXCEPTIONS;

package INDEXEDMIXEDIO is
type FILETYPE is limited private;

type FILEMODE is (INFILE, INOUTFILE, OUTFILE);
type RELATIONTYPE is

(EQUALNEXT, EQUAL, NEXT);

function GREATER return RELATIONTYPE
renames NEXT;
function GREATEREQUAL return RELATIONTYPE
renames EQUALNEXT;

type COUNT is range 0 .. INTEGER’ LAST;
subtype POSITIVECOUNT is COUNT range 1 .. COUNT’ LAST;
-- File management

procedure CREATE(FILE : in out FILETYPE;

MODE : in FILEMODE := INOUTFILE;
NAME : in STRING := "";
FORM : in STRING) ;

-- All information about the keys must be provided in the
-- FORM parameter of the CREATE procedure.

procedure OPEN

(FILE : in out FILETYPE;
MODE : in FILEMODE;
NAME : in STRING;

FORM : in STRING := "");
procedure CLOSE

(FILE :

in out FILETYPE);

procedure DELETE(FILE : in out FILETYPE);
procedure RESET (FILE
: in FILETYPE;

MODE
: in FILEMODE;
KEYNUMBER : in INTEGER := 0);

procedure RESET (FILE

: in FILETYPE;

KEYNUMBER : in INTEGER := 0);

function MODE

(FILE : in FILETYPE)

return FILEMODE;

function FORM

(FILE

in FILETYPE)

return STRING;

function ISOPEN(FILE

in FILETYPE)

return BOOLEAN;

function NAME

(FILE : in FILETYPE) return STRING;

-- Item input and output operations
generic

type ITEMTYPE is private;

procedure GETITEM(FILE : in FILETYPE;

14.2b.10

Specification of the Package Indexed_Mixed_lO

ITEM : out ITEMTYPE);

14-48

generic
type ITEMTYPE is private;

type INDEX is (<>);

type ITEMARRAY is array (INDEX range <>) of ITEMTYPE;

procedure GETARRAY (FILE

in FILETYPE;
out ITEMARRAY;
out INDEX);

ITEMS
LAST

generic
type ITEMTYPE is private;

procedure PUT_ITEM(FILE

in FILETYPE;

ITEM :

in ITEMTYPE) ;

function ENDOFBUFFER (FILE

in FILETYPE)

procedure SETPOSITION (FILE
TO

in FILETYPE;
in POSITIVECOUNT) ;

in FILETYPE)

function POSITION (FILE

function MAXELEMENTSIZE (FILE

return BOOLEAN;

return POSITIVECOUNT;

in FILETYPE) return COUNT;

function ELEMENTSIZE (FILE

-- Element input and output operations

procedure READ

(FILE

in FILETYPE);

generic
type KEYTYPE is private;
DEFAULTKEYNUMBER

INTEGER

procedure READBYKEY (FILE

procedure WRITE

:= 0;

>: in

KEY
>:
KEYNUMBER :

in
in

RELATION

(FILE

in FILETYPE);

procedure UPDATE (FILE

in FILETYPE);

procedure UNLOCK (FILE

in FILETYPE);

procedure DELETEELEMENT (FILE
function ENDOFFILE(FILE

FILETYPE;

KEYTYPE;
INTEGER :=
DEFAULTKEYNUMBER;
RELATIONTYPE := EQUAL);

in FILETYPE);

in FILETYPE)

return BOOLEAN;

-- Exceptions
STATUSERROR
MODEERROR
NAMEERROR
USE_ERROR
DEVICEERROR
END_ERROR
DATAERROR
LOCKERROR
KEYERROR

EXISTENCEERROR

exception
exception
exception
exception
exception
exception
exception
exception
exception

exception

renames
renames
renames
renames
renames
renames
renames
renames
renames

IOEXCEPTIONS.STATUS_ERROR;
IOEXCEPTIONS.MODEERROR;
IOEXCEPTIONS.NAMEERROR;
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICE_ERROR;
IOEXCEPTIONS.END_ERROR;
IOEXCEPTIONS.DATA_ERROR;
AUX_IOEXCEPTIONS.LOCK_ERROR;
AUX_IOEXCEPTIONS.KEY_ERROR;

renames AUX_IOEXCEPTIONS.EXISTENCEERROR;

14-49

Specification of the Package Indexed_Mixed_lO

14.2b.10

private
-- implementation-dependent

end INDEXMIXEDI0;

References: aux_io_exceptions package 14.4, close procedure 14.2.1, count type
14.2, create procedure 14.2b.1, data_error exception 14.4, delete procedure 14.2.1,
delete_element procedure 14.2b.9, device_error exception 14.4, element_size function

14.2b.2, end_error exception 14.4, end_of_buffer function 14.2b.2, end_of_file function

14.2b.9, existence_error exception 14.4, file_mode 14.1, file_type 14.1, form function
14.2.1, get_array procedure 14.2b.2, get_item procedure 14.2b.2, index 14.2b.2,
io_exceptions package 14.4, is_open function 14.2.1, item_array 14.2b.2, item_type
14.2b.2, key_error exception 14.4, lock_error exception 14.4, max_element_size
function 14.2b.2, mode function 14.2.1, mode_error exception 14.4, name function
14.2.1, name_error exception 14.4, open procedure 14.2.1, position function 14.2b.2,
put_item procedure 14.2b.2, read procedure 14.2b.9, read_by_key procedure 14.2b.9,
relation_type 14.2a, reset procedure 14.2a.1, set_position procedure 14.2b.2, status_
error exception 14.4, unlock procedure 14.2b.9, update procedure 14.2b.9, use_error
exception 14.4, write procedure 14.2b.9

14.3 Text Input-Output
1

This section describes the package TEXT_IO, which provides facilities for
input and output in human-readable form. Each file is read or written
sequentially, as a sequence of characters grouped into lines, and as a
sequence of lines grouped into pages. The specification of the package is
given below in section 14.3.10.15
The facilities for file management given above, in sections 14.2.1 and 14.2.2,
are available for text input-output. In place of READ and WRITE, however,

there are procedures GET and PUT that input values of suitable types

from text files, and output values to them. These values are provided to
the PUT procedures, and returned by the GET procedures, in a parameter
ITEM.Several overloaded procedures of these namesexist, for different
types of ITEM. These GET procedures analyze the input sequences of

characters as lexical elements (see chapter 2) and return the corresponding

values; the PUT procedures output the given values as appropriate lexical
elements. Procedures GET and PUTare also available that input and
output individual characters treated as character values rather than as
lexical elements.

15 See also Appendix G, AI-00355.
14.3.

Text Input-Output

14-50

In addition to the procedures GET and PUT for numeric and enumeration
types of ITEM that operate on text files, analogous procedures are provided
that read from and write to a parameter of type STRING. These procedures
perform the same analysis and composition of character sequencesas their
counterparts which havea file parameter.
For all GET and PUT procedures that operate on text files, and for many
other subprograms, there are forms with and without a file parameter. Each

such GET procedure operates on an inputfile, and each such PUT procedure
operates on an outputfile. If no file is specified, a default input file or a
default outputfile is used.

At the beginning of program execution the default input and output files are
the so-called standard inputfile and standard output file. These files are
open, have respectively the current modes IN_FILE and OUT_FILE, and
are associated with two implementation-defined external files. Procedures
are provided to change the current default input file and the current default
outputfile.
VAX Ada has twological file names, ADA$INPUT and ADA$OUTPUT,
which can be defined to refer to the standard input and standard output
files. If these logical names are not defined, then the standard input and
standard output files are represented by the default system input and output
logical names SYS$INPUT and SYS$OUTPUT.By defining ADA$INPUT
and ADA$OUTPUT to refer to nonprocess-permanentfiles, these logical
names can be used to achieve asynchronousterminal input-output in
tasking programs. See the VAX Ada Run-Time Reference Manual for more
information.
From a logical point of view, a text file is a sequence of pages, a page is a

sequence of lines, and a line is a sequence of characters; the end of a line is

markedby a line terminator; the end of a page is marked by the combination
of a line terminator immediately followed by a page terminator; and the
end of a file is marked by the combination of a line terminator immediately
followed by a page terminator andthena file terminator. Terminators are
generated during output; either by calls of procedures provided expressly for
that purpose; or implicitly as part of other operations, for example, when a
boundedline length, a bounded page length, or both, have been specified for
a file.
The actual nature of terminators is not defined by the language and hence
depends on the implementation. Although terminators are recognized or
generated by certain of the procedures that follow, they are not necessarily
implemented as characters or as sequences of characters. Whether they are
characters (and if so which ones) in any particular implementation need not
concern a user who neither explicitly outputs nor explicitly inputs control
14-51

Text Input-Output

14.3

characters. The effect of input or output of control characters (other than
~ horizontal tabulation) is not defined by the language.
The VAX Ada Run-Time Reference Manual describes howline, page, andfile
terminators are interpreted in VAX Ada.
8

The characters of a line are numbered, starting from one; the number of
a character is called its column number. For a line terminator, a column
numberis also defined: it is one more than the numberof characters in the
line. The lines of a page, and the pagesof a file, are similarly numbered.
The current column numberis the column numberof the next character or
line terminator to be transferred. The current line number is the number

of the current line. The current page number is the numberof the current
page. These numbers are values of the subtype POSITIVE_COUNTofthe

type COUNT(by convention, the value zero of the type COUNTis used to
indicate special conditions).
type COUNT is range 0 .. implementationdefined;
subtype POSITIVECOUNT is COUNT range 1 .. COUNT’ LAST;

In VAX Ada, the integer type COUNTis range 0..INTEGER’ LAST.
9

For an output file, a maximum line length can be specified and a maximum

page length can be specified. If a value to be output cannot fit on the current
line, for a specified maximum line length, then a newline is automatically
started before the value is output; if, further, this new line cannotfit

on the current page, for a specified maximum page length, then a new
page is automatically started before the value is output. Functions are
provided to determine the maximum line length and the maximum page
length. Whena file is opened with mode OUT_FILE, both values are
zero: by convention, this means that the line lengths and page lengths
are unbounded. (Consequently, output consists of a single line if the
subprogramsfor explicit control of line and page structure are not used.)
The constant UNBOUNDEDis provided for this purpose.
10

14.3.

References : count type 14.3.10, default current input file 14.3.2, default current
output file 14.3.2, external file 14.1, file 14.1, get procedure 14.3.5, in_file 14.1,
out_file 14.1, put procedure 14.3.5, read 14.2.2, sequential access 14.1, standard
input file 14.3.2, standard outputfile 14.3.2

Text Input-Output

14-52

14.3.1

File Management
1

The only allowed file modes for text files are the modes IN_FILE and OUT_

FILE. The subprogramsgiven in section 14.2.1 for the control of external

files, and the function END_OF_FILE given in section 14.2.2 for sequential
input-output, are also available for text files. There is also a version of

END_OF_FILE that refers to the current default input file. For text files,
the procedures have the following additional effects:
e

For the procedures CREATE and OPEN:After opening a file with mode
OUT_FILE, the page length and line length are unbounded (both have
the conventional value zero). After opening a file with mode IN_FILE or
OUT_FILE, the current column, current line, and current page numbers
are set to one.

For the procedure CLOSE: If the file has the current mode OUT_FILE,
has the effect of calling NEW_PAGE, unless the current page is already
terminated; then outputs a file terminator.

For the procedure RESET:If the file has the current mode OUT_FILE,
has the effect of calling NEW_PAGE, unless the current pageis already
terminated; then outputs a file terminator. If the new file modeis
OUT_FILE, the page and line lengths are unbounded. For all modes,
the current column, line, and page numbersareset to one.16

The exception MODE_ERRORis raised by the procedure RESET upon an
attempt to change the modeofa file that is either the current default input

file, or the current default output file.17

References: create procedure 14.2.1, current column number 14.3, current default
input file 14.3, current line number 14.3, current page number 14.3, end_of_file
14.3, external file 14.1, file 14.1, file mode 14.1, file terminator 14.3, in_file 14.1, line
length 14.3, mode_error exception 14.4, open procedure 14.2.1, out_file 14.1, page
length 14.3, reset procedure 14.2.1

16 See also Appendix G, AI-00047.
17 See also Appendix G, AI-00048.
14-53

File Management

14.3.1

14.3.2

Default Input and Output Files
1

The following subprograms provide for the control of the particular default
files that are used whena file parameter is omitted from a GET, PUT or
other operation of text input-output described below. 18
procedure SETINPUT(FILE

in FILETYPE);

Operates on a file of mode IN_FILE. Sets the current default input

file to FILE.

The exception STATUS_ERRORisraised if the given file is not open.

The exception MODE_ERRORisraised if the modeof the givenfile
is not IN_FILE.

procedure SETOUTPUT(FILE : in FILETYPE);

Operates on a file of mode OUT_FILE. Sets the current default

output file to FILE.

The exception STATUS_ERRORisraised if the givenfile is not open.
The exception MODE_ERRORisraised if the modeof the givenfile
is not OUT_FILE.
function STANDARDINPUT return FILETYPE;
Returns the standard inputfile (see 14.3).
function STANDARDOUTPUT return FILETYPE;

Returns the standard output file (see 14.3).
function CURRENTINPUT return FILETYPE;

Returns the current default inputfile.
function CURRENTOUTPUT return FILETYPE;
7

Returns the current default outputfile.
Note:

The standard input and the standard output files cannot be opened, closed,
reset, or deleted, because the parameter FILE of the corresponding procedures has the mode in out.
References: current default file 14.3, default file 14.3, file_type 14.1, get procedure 14.3.5, mode_error exception 14.4, put procedure 14.3.5, status_error
exception 14.4

18 See also Appendix G, AI-00048.
14.3.2

Default Input and Output Files

14-54

14.3.3

Specification of Line and Page Lengths
1

The subprogramsdescribed in this section are concerned with the line and
page structure of a file of mode OUT_FILE. They operate either on thefile

given as the first parameter, or, in the absence of such a file parameter,
on the current default output file. They provide for output of text with a
specified maximum line length or page length. In these cases, line and
page terminators are output implicitly and automatically when needed.
Whenline and page lengths are unbounded(that is, when they have the
conventional value zero), as in the case of a newly openedfile, new lines and
new pages are only started when explicitly called for.
In all cases, the exception STATUS_ERRORisraised if the file to be used

is not open; the exception MODE_ERRORisraised if the modeofthefile is
not OUT_FILE.
procedure SETLINELENGTH(FILE
procedure SETLINELENGTH (TO

:
:

in FILETYPE;
in COUNT) ;

in COUNT);

Sets the maximumline length of the specified outputfile to the
numberof characters specified by TO. The value zero for TO specifies
an unboundedline length.
The exception USE_ERRORis raised if the specified line length is
inappropriate for the associated externalfile.
procedure SETPAGELENGTH(FILE : in FILETYPE; TO : in COUNT);
procedure SETPAGELENGTH (TO
> in COUNT);

Sets the maximum pagelength of the specified output file to the
numberof lines specified by TO. The value zero for TO specifies an
unboundedpage length.
The exception USE_ERRORisraised if the specified page length is
inappropriate for the associated externalfile.
function LINELENGTH(FILE : in FILETYPE) return COUNT;
function LINELENGTH return COUNT;
10

Returns the maximum line length currently set for the specified
output file, or zero if the line length is unbounded.
function PAGELENGTH(FILE : in FILETYPE)

function PAGELENGTH return COUNT;
12

14-55

return COUNT;

Returns the maximum page length currently set for the specified
output file, or zero if the page length is unbounded.

Specification of Line and Page Lengths

14.3.3

References : count type 14.3, current default output file 14.3, external file 14.1,
file 14.1, file_type 14.1, line 14.3, line length 14.3, line terminator 14.3, maximum

line length 14.3, maximum page length 14.3, mode_error exception 14.4, open file
14.1, out_file 14.1, page 14.3, page length 14.3, page terminator 14.3, status_error
exception 14.4, unbounded page length 14.3, use_error exception 14.4

14.3.4

Operations on Columns, Lines, and Pages
1

The subprogramsdescribed in this section provide for explicit control of
line and page structure; they operate either on the file given as thefirst

parameter, or, in the absence of such a file parameter, on the appropriate

(input or output) current default file.1? The exception STATUS_ERRORis
raised by any of these subprogramsif the file to be used is not open.
:= 1);

procedure NEWLINE(SPACING : in POSITIVECOUNT :

procedure NEWLINE(FILE : in FILETYPE;
SPACING :: in POSITIVECOUNT

1);

Operates on a file of mode OUT_FILE.
For a SPACING of one: Outputs a line terminator and sets the

current column numberto one. Then increments the current line
numberby one, except in the case that the current line numberis
already greater than or equal to the maximum pagelength, for a
bounded page length; in that case a page terminatoris output, the
current page numberis incremented by one, and the current line
numberis set to one.
For a SPACINGgreater than one, the above actions are performed

SPACINGtimes.

The exception MODE_ERRORisraised if the modeis not
OUT_FILE.
procedure SKIPLINE (FILE
: in FILETYPE;
SPACING : in POSITIVECOUNT := 1);
procedure SKIPLINE(SPACING : in POSITIVECOUNT := 1);

Operates on file of mode IN_FILE.

For a SPACINGof one: Reads and discards all characters until a

line terminator has been read, and then sets the current column

numberto one. If the line terminator is not immediately followed by
a page terminator, the current line numberis incremented by one.
Otherwise, if the line terminator is immediately followed by a page

19 See also Appendix G, AI-00320.
14.3.4

Operations on Columns, Lines, and Pages

14-56

terminator, then the page terminator is skipped, the current page
numberis incremented by one, and the current line numberis set
to one.

For a SPACING greater than one, the above actions are performed
SPACINGtimes.
The exception MODE_ERRORisraised if the mode is not IN_FILE.

The exception END_ERRORisraised if an attempt is made to read
a file terminator.
function ENDOFLINE(FILE : in FILETYPE)
function ENDOFLINE return BOOLEAN;

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUEif a line |

terminator or a file terminator is next; otherwise returns FALSE.

The exception MODE_ERRORis raised if the mode is not IN_FILE.
procedure NEWPAGE(FILE

procedure NEWPAGE;

in FILETYPE);

Operates on a file of mode OUT_FILE. Outputs a line terminatorif
the current line is not terminated, or if the current page is empty
(that is, if the current column and line numbersare both equal to
one). Then outputs a page terminator, which terminates the current
page. Adds one to the current page numberandsets the current
column and line numbersto one.
The exception MODE_ERRORisraised if the modeis not

OUT_FILE.

procedure SKIP PAGE(FILE:

procedure SKIPPAGE;

in FILETYPE);

Operates on file of mode IN_FILE. Reads and discardsall characters and line terminators until a page terminator has been read.
Then adds one to the current page number, andsets the current
column and line numbersto one.
The exception MODE_ERRORis raised if the mode is not IN_FILE.
The exception END_ERRORis raised if an attempt is made to read
a file terminator.
20

function ENDOFPAGE(FILE : in FILETYPE)

function ENDOFPAGE return BOOLEAN;

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUE if the combination of a line terminator and a page terminatoris next, orif a file
terminator is next; otherwise returns FALSE.

14-57

Operations on Columns, Lines, and Pages

14.3.4

22
23

25
26

The exception MODE_ERRORis raised if the modeis not IN_FILE.
function ENDOFFILE(FILE : in FILETYPE)
function ENDOFFILE return BOOLEAN;

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUEif a file terminator is next, or if the combination of a line, a page, anda file
terminator is next; otherwise returns FALSE.

The exception MODE_ERRORisraised if the mode is not IN_FILE.
The following subprogramsprovide for the control of the current position of
reading or writing in a file. In all cases, the default file is the current output
file.

procedure SETCOL(FILE : in FILETYPE; TO : in POSITIVECOUNT) ;
procedure SETCOL(TO
: in POSITIVECOUNT) ;

If the file mode is OUTFILE:

If the value specified by TO is greater than the current column
number, outputs spaces, adding one to the current column number
after each space, until the current column number equals the
specified value. If the value specified by TO is equal to the current
column number, there is no effect. If the value specified by TO is
less than the current column number, hastheeffect of calling NEW_
LINE (with a spacing of one), then outputs (TO — 1) spaces, and sets
the current column numberto the specified value.
The exception LAYOUT_ERRORisraised if the value specified by

TO exceeds LINE_LENGTH whentheline length is bounded (that
is, when it does not have the conventional value zero).
If the file mode is IN_FILE:
32

Reads (and discards) individual characters, line terminators, and

page terminators, until the next character to be read has a column
number that equals the value specified by TO; there is no effect
if the current column numberalready equals this value. Each

transfer of a character or terminator maintains the current column,

line, and page numbers in the same way as a GET procedure (see
14.3.5). (Short lines will be skipped until a line is reached that has a
character at the specified column position.)

14.3.4

Operations on Columns, Lines, and Pages

14-58

The exception END_ERRORisraised if an attempt is made to read
a file terminator.
procedure SETLINE(FILE
TO

:
:

in FILETYPE;
in POSITIVECOUNT) ;

procedure SETLINE (TO

> in POSITIVECOUNT) ;

If the file mode is OUT_FILE:
36

If the value specified by TO is greater than the current line number,
has the effect of repeatedly calling NEW_LINE (with a spacing of
one), until the current line number equals the specified value. If the
value specified by TO is equal to the current line number, there is
no effect. If the value specified by TO is less than the current line
number, has the effect of calling NEW_PAGEfollowed by call of
NEW_LINEwith a spacing equal to (TO — 1).
The exception LAYOUT_ERRORisraised if the value specified by

TO exceeds PAGE_LENGTH whenthe page length is bounded (that
is, when it does not have the conventional value zero).
If the mode is IN_FILE:

42
43

14-59

Has the effect of repeatedly calling SKIP_LINE (with a spacing of
one), until the current line number equals the value specified by
TO; there is no effect if the current line number already equals this
value. (Short pages will be skipped until a page is reached that has
a line at the specified line position.)
The exception END_ERRORisraised if an attempt is made to read
a file terminator.
function COL(FILE : in FILETYPE) return POSITIVECOUNT;
function COL return POSITIVECOUNT;
Returns the current column number.

The exception LAYOUT_ERRORisraised if this number exceeds
COUNT’ LAST.
function LINE(FILE : in FILETYPE)

return POSITIVECOUNT;

function LINE return POSITIVECOUNT;
Returns the current line number.

Operations on Columns, Lines, and Pages

14.3.4

The exception LAYOUT_ERRORisraised if this number exceeds
COUNT’ LAST.

function PAGE(FILE

in FILETYPE)

return POSITIVECOUNT;

function PAGE return POSITIVECOUNT;

Returns the current page number.

The exception LAYOUT_ERRORisraised if this number exceeds
COUNT" LAST.

The column number, line number, or page numberare allowed to exceed
COUNT’ LAST(as a consequence of the input or output of sufficiently many
characters, lines, or pages). These events do not cause any exception to

be raised. However, a call of COL, LINE, or PAGE raises the exception

LAYOUT_ERRORif the corresponding number exceeds COUNT’ LAST.
Note:

A page terminator is always skipped wheneverthe preceding line terminator
is skipped. An implementation may represent the combination of these

terminators by a single character, provided that it is properly recognized at
input.
The interpretation of these terminatorsis given in the VAX Ada Run-Time
Reference Manual.
52

References : current column number 14.3, current default file 14.3, current line
number 14.8, current page number 14.3, end_error exception 14.4, file 14.1, file

terminator 14.3, get procedure 14.3.5, in_file 14.1, layout_error exception 14.4, line
14.3, line number 14.3, line terminator 14.3, maximum page length 14.3, mode_error

exception 14.4, open file 14.1, page 14.3, page length 14.3, page terminator 14.3,
positive count 14.3, status_error exception 14.4

14.3.5

Get and Put Procedures
,|

The procedures GET and PUTfor items of the types CHARACTER, STRING,
numeric types, and enumeration types are described in subsequent sections.
Features of these procedures that are common to most of these types are

described in this section. The GET and PUT proceduresfor items of type

CHARACTER and STRINGdeal with individual character values; the GET

and PUT procedures for numeric and enumeration types treat the items as
lexical elements.

14.3.5

Get and Put Procedures

14—60

All procedures GET and PUT have forms with a file parameter, written first.
Where this parameter is omitted, the appropriate (input or output) current
default file is understood to be specified. Each procedure GET operates on
a file of mode IN_FILE. Each procedure PUT operates on file of mode
OUT_FILE.

All procedures GET and PUT maintain the current column, line, and

page numbersof the specified file: the effect of each of these procedures
upon these numbersis the resultant of the effects of individual transfers
of characters and of individual output or skipping of terminators. Each

transfer of a character adds one to the current column number. Each output
of a line terminator sets the current column numberto one and addsone to
the current line number. Each output of a page terminator sets the current
column and line numbers to one and adds one to the current page number.
For input, each skipping of a line terminator sets the current column
number to one and adds oneto the current line number; each skipping of
a page terminator sets the current column and line numbers to one and

adds one to the current page number. Similar considerations apply to the

procedures GET_LINE, PUT_LINE, and SET_COL2°
4

Several GET and PUT procedures, for numeric and enumeration types, have

format parameters which specify field lengths; these parameters are of the
nonnegative subtype FIELD of the type INTEGER.
Input-output of enumeration values uses the syntax of the corresponding
lexical elements. Any GET procedure for an enumeration type begins by
skipping any leading blanks, or line or page terminators; a blank being
defined as a space or a horizontal tabulation character. Next, characters
are input only so long as the sequence input is an initial sequence of an
identifier or of a character literal (in particular, input ceases when a line
terminator is encountered). The character or line terminator that causes

input to cease remains available for subsequent input.
6

For a numeric type, the GET procedures have a format parameter called

WIDTH.If the value given for this parameteris zero, the GET procedure

proceeds in the same manneras for enumeration types, but using the syntax

of numeric literals instead of that of enumeration literals. If a nonzero value

is given, then exactly WIDTH characters are input, or the characters up

to a line terminator, whichever comesfirst; any skipped leading blanks are
included in the count. The syntax used for numeric literals is an extended
syntax that allows a leading sign (but no intervening blanks, or line or page
terminators).

20 See also Appendix G, AI-00320.
14-61

Get and Put Procedures

14.3.5

Any PUT procedure, for an item of a numeric or an enumeration type,

outputs the value of the item as a numericliteral, identifier, or character
literal, as appropriate. This is preceded by leading spaces if required by
the format parameters WIDTH or FORE(as described in later sections),
and then a minussign for a negative value; for an enumeration type, the

spaces follow instead of leading. The format given for a PUT procedure is

overriddenif it is insufficiently wide. 21
8

Two further cases arise for PUT procedures for numeric and enumeration

types, if the line length of the specified output file is bounded (that is, if it

does not have the conventional value zero). If the number of characters to
be output does not exceed the maximum line length, but is such that they
cannot fit on the current line, starting from the current column, then (in
effect) NEW_LINEis called (with a spacing of one) before output of the item.
Otherwise, if the number of characters exceeds the maximum line length,
then the exception LAYOUT_ERRORis raised and no characters are output.
9

The exception STATUS_ERRORis raised by any of the procedures GET,
GET_LINE, PUT, and PUT_LINEif the file to be used is not open. The
exception MODE_ERRORis raised by the procedures GET and GET_LINE
if the modeof thefile to be used is not IN_FILE; and by the procedures PUT
and PUT_LINE, if the mode is not OUT_FILE.

The exception END_ERRORis raised by a GET procedure if an attempt
is made to skip a file terminator. The exception DATA_ERRORis raised
by a GET procedure if the sequencefinally input is not a lexical element
corresponding to the type, in particular if no characters were input; for this

test, leading blanks are ignored; for an item of a numeric type, when a sign
is input, this rule applies to the succeeding numericliteral. The exception
LAYOUT_ERRORis raised by a PUT procedure that outputs to a parameter
of type STRING,if the length of the actual string is insufficient for the
output of the item.

Examples:

In the examples, here and in sections 14.3.7 and 14.3.8, the string quotes

and the lower case letter b are not transferred: they are shown only to

reveal the layout and spaces.

21 See also Appendix G, AI-00243.
14.3.5

Get and Put Procedures

14-62

INTEGER;

GET (N) ;

-- Characters at input
-bb-12535b
-—
bb12 535E1b
-bb12_ 535E;

Sequence input
-12535
12535E1
125355

Value of N
~12535
125350
(none)

DATAERROR raised

Example of overridden width parameter:
PUT(ITEM => -23, WIDTH => 2);

"-23"

References : blank 14.3.9, column number 14.3, current default file 14.3, data_
error exception 14.4, end_error exception 14.4, file 14.1, fore 14.3.8, get procedure
14.3.6 14.3.7 14.3.8 14.3.9, in_file 14.1, layout_error exception 14.4, line number
14.1, line terminator 14.1, maximum line length 14.8, mode 14.1, mode_error

exception 14.4, new_file procedure 14.3.4, out_file 14.1, page number 14.1, page
terminator 14.1, put procedure 14.3.6 14.3.7 14.3.8 14.3.9, skipping 14.3.7 14.3.8
14.3.9, status_error exception 14.4, width 14.3.5 14.3.7 14.3.9

14.3.6

Input-Output of Characters and Strings
For an item of type CHARACTERthe following procedures are provided:
procedure GET(FILE : in FILETYPE;
ITEM

out CHARACTER) ;

procedure GET(ITEM

out CHARACTER);

After skipping any line terminators and any page terminators, reads
the next character from the specified input file and returns the value
of this character in the out parameter ITEM.
The exception END_ERRORisraised if an attempt is made to skip a
file terminator.
procedure PUT(FILE
procedure PUT(ITEM

:
:

in FILETYPE; ITEM
in CHARACTER);

in CHARACTER) ;

If the line length of the specified output file is bounded (thatis,
does not have the conventional value zero), and the current column
number exceeds it, has the effect of calling NEW_LINE with a

spacing of one. Then, or otherwise, outputs the given character to
the file.

14-63

Input-Output of Characters and Strings

14.3.6

For an item of type STRINGthe following procedures are provided:

procedure GET(FILE
procedure GET(ITEM

:
:

in FILETYPE;
out STRING);

ITEM

out STRING);

Determines the length of the given string and attempts that num-

ber of GET operations for successive characters of the string (in
particular, no operation is performed if the string is null).
procedure PUT(FILE : in FILETYPE;
procedure PUT(ITEM : in STRING);

ITEM : in STRING);

Determines the length of the given string and attempts that number of PUT operations for successive characters of the string (in
particular, no operation is performedif the string is null).
procedure GETLINE(FILE
ITEM
LAST

:
:
:

in FILETYPE;
out STRING;
out NATURAL) ;

procedure GETLINE(ITEM : out STRING;
LAST

out NATURAL) ;

Replaces successive characters of the specified string by successive
characters read from the specified input file. Reading stops if the

end of the line is met, in which case the procedure SKIP_LINE

is then called (in effect) with a spacing of one; reading also stops

if the end of the string is met. Characters not replaced are left
undefined.”
14

If characters are read, returns in LAST the index value such that

ITEM(LAST)is the last character replaced (the index of the first
character replaced is ITEM’ FIRST). If no characters are read,

returns in LAST an index value that is one less than ITEM’ FIRST.

15
16

The exception END_ERRORisraised if an attempt is made to skip a
file terminator.

procedure PUTLINE(FILE : in FILETYPE;
procedure PUTLINE(ITEM : in STRING);

ITEM : in STRING);

Calls the procedure PUT for the given string, and then the procedure
NEW_LINE with a spacing of one.

22 See also Appendix G, AI-00050 and AI-00172.
14.3.6

Input-Output of Characters and Strings

14-64

Notes:

Ina literal string parameter of PUT, the enclosing string bracket characters
are not output. Each doubled string bracket character in the enclosed string
is output as a single string bracket character, as a consequenceofthe rule
for string literals (see 2.6).

1i9
20

#Astring read by GET or written by PUT can extend over several lines.
References : current column number 14.3, end_error exception 14.4, file 14.1, file

terminator 14.3, get procedure 14.3.5, line 14.3, line length 14.3, new_line procedure

14.3.4, page terminator 14.8, put procedure 14.3.4, skipping 14.3.5

14.3.7

Input-Output for Integer Types
1

The following procedures are defined in the generic package INTEGER_IO.
This must be instantiated for the appropriate integer type (indicated by
NUM in thespecification).

Values are output as decimal or based literals, without underline characters
or exponent, and preceded by a minussign if negative. The format (which
includes any leading spaces and minussign) can be specified by an optional
field width parameter. Values of widths of fields in output formats are of
the nonnegative integer subtype FIELD. Values of bases are of the integer
subtype NUMBER_BASE.
subtype NUMBERBASE is INTEGER range 2

16;

The default field width and base to be used by output procedures are
defined by the following variables that are declared in the generic package
INTEGER_IO:
DEFAULTWIDTH : FIELD := NUM’ WIDTH;
DEFAULTBASE : NUMBERBASE := 10;

The following procedures are provided:

procedure GET(FILE

ITEM

WIDTH
procedure GET(ITEM

14-65

: in FILETYPE;

: out NUM;
:

in FIELD

:= 0);

out NUM;

WIDTH

in FIELD

:= 0);

If the value of the parameter WIDTHis zero, skips any leading
blanks, line terminators, or page terminators, then reads a plusor
a minus sign if present, then reads according to the syntax of an
integer literal (which may be a basedliteral). If a nonzero value of
WIDTHis supplied, then exactly WIDTH characters are input, or

Input-Output for Integer Types

14.3.7

the characters (possibly none) up to a line terminator, whichever

comesfirst; any skipped leading blanks are included in the count.2°

Returns, in the parameter ITEM,the value of type NUM that
corresponds to the sequence input.
The exception DATA_ERRORisraised if the sequence input does
not have the required syntax or if the value obtained is not of the
subtype NUM.

procedure PUT(FILE
ITEM
WIDTH
BASE

:
+
:
:

in FILETYPE;
in NUM;
in FIELD := DEFAULTWIDTH;
in NUMBERBASE := DEFAULTBASE) ;

procedure PUT(ITEM
: in NUM;
WIDTH : in FIELD := DEFAULTWIDTH;
BASE
: in NUMBERBASE := DEFAULTBASE) ;

Outputs the value of the parameter ITEM as an integer literal, with

no underlines, no exponent, and no leading zeros (but a single zero

for the value zero), and a preceding minus sign for a negative value.
If the resulting sequence of characters to be output has fewer than

WIDTHcharacters, then leading spacesare first output to make up

the difference.

Uses the syntax for decimal literal if the parameter BASE hasthe
value ten (either explicitly or through DEFAULT_BASE); otherwise,
uses the syntax for based literal, with any letters in uppercase.
procedure GET(FROM :
ITEM :
LAST :

in STRING;
out NUM;
out POSITIVE);

Reads an integer value from the beginning of the given string,
following the same rules as the GET procedure that reads an
integer value from a file, but treating the end of the string asa file
terminator. Returns, in the parameter ITEM,the value of type NUM
that corresponds to the sequence input. Returns in LAST the index

value such that FROM(LAST)is the last character read.24
15

The exception DATA_ERRORisraised if the sequence input does
not have the required syntax or if the value obtained is not of the
subtype NUM.

23 See also Appendix G, AI-00051 and AI-00307.
24 See also Appendix G, AI-00307.
14.3.7

Input-Output for Integer Types

14-66

procedure PUT (TO

: out STRING;

ITEM
BASE

:
:

in NUM;
in NUMBERBASE

:= DEFAULTBASE);

Outputs the value of the parameter ITEM to the givenstring,

following the samerule as for output to a file, using the length of the
given string as the value for WIDTH.
Examples:
package INTIO is new INTEGERIO(SMALLINT); use INTIO;
—-- default

format used at

instantiation,

-- DEFAULTWIDTH = 4, DEFAULTBASE = 10
PUT (126);
PUT (-126, 7);
PUT (126, WIDTH => 13,

BASE => 2);

-- "b126"
-- "bbb-126"
-- "bbb2#1111110#"

References : based literal 2.4.2, blank 14.3.5, data_error exception 14.4, decimal
literal 2.4.1, field subtype 14.3.5, file_type 14.1, get procedure 14.3.5, integer_io
package 14.3.10, integer literal 2.4, layout_error exception 14.4, line terminator
14.3, put procedure 14.3.5, skipping 14.3.5, width 14.3.5

14.3.8

Input-Output for Real Types
The following procedures are defined in the generic packages FLOAT_IO and
FIXED_IO, which must be instantiated for the appropriate floating point or

fixed point type respectively (indicated by NUM in thespecifications).

Values are output as decimal literals without underline characters. The
format of each value output consists of a FORE field, a decimal point, an
AFT field, and Gf a nonzero EXP parameteris supplied) the letter E and an
EXP field. The two possible formats thus correspondto:
FORE

AFT

andto:
FORE

E-

EXP

without any spaces between these fields. The FORE field may include
leading spaces, and a minussign for negative values. The AFTfield includes
only decimal digits (possibly with trailing zeros). The EXP field includes the
sign (plus or minus) and the exponent (possibly with leading zeros).
For floating point types, the default lengths of these fields are defined by the
following variables that are declared in the generic package FLOAT_IO:

14-67

Input-Output for Real Types

14.3.8

DEFAULTFORE
DEFAULTAFT
DEFAULTEXP

:
:
;

FIELD
FIELD
FIELD

NUM’ DIGITS-1;
3;

Forfixed point types, the default lengths of these fields are defined by the
following variables that are declared in the generic package FIXED_IO:
DEFAULTFORE
DEFAULTAFT
DEFAULTEXP

:
:
:

FIELD
FIELD
FIELD

:= NUM’ FORE;
:= NUM’AFT;
:= 0;

The following procedures are provided:
procedure GET(FILE
ITEM
WIDTH

:
:
:

procedure GET(ITEM

in FILETYPE;
out NUM;
in FIELD := QO);

: out NUM;

WIDTH

in FIELD

:= QO);

If the value of the parameter WIDTHis zero, skips any leading

blanks, line terminators, or page terminators, then reads a plus

or a minussign if present, then reads according to the syntax of
a real literal (which may be a based literal). If a nonzero value of

WIDTHis supplied, then exactly WIDTH characters are input, or
the characters (possibly none) up to a line terminator, whichever

comesfirst; any skipped leading blanks are included in the count.*°

Returns, in the parameter ITEM,the value of type NUM that
corresponds to the sequence input.

The exception DATA_ERRORis raised if the sequence input does

not have the required syntax or if the value obtained is not of the

subtype NUM.

in
in
in
in
in

FILETYPE;
NUM;
FIELD
DEFAULTFORE;
FIELD
DEFAULTAFT;
FIELD
DEFAULTEXP);

procedure PUT(ITEM

in NUM;

FORE

in FIELD

AFT

in FIELD

EXP

in FIELD

:
:
:
:
:

ton

procedure PUT(FILE
ITEM
FORE
AFT
EXP

DEFAULTFORE;
DEFAULTAFT;
DEFAULTEXP) ;

Outputs the value of the parameter ITEM as a decimalliteral with
the format defined by FORE, AFT and EXP If the valueis negative,
a minus sign is included in the integer part. If EXP has the value
zero, then the integer part to be output has as many digits as are

25 See also Appendix G, AI-00307.
14.3.8

Input-Output for Real Types

14-68

needed to represent the integer part of the value of ITEM,overriding
FOREif necessary, or consists of the digit zero if the value of ITEM
has no integer part.
14

If EXP has a value greater than zero, then the integer part to be
output has a single digit, which is nonzero except for the value 0.0
of ITEM.
In both cases, however, if the integer part to be output has fewer
than FORE characters, including any minus sign, then leading
spaces are first output to make up the difference. The numberof

digits of the fractional part is given by AFT, or is one if AFT equals

zero. The value is rounded; a value of exactly one half in the last
place may be roundedeither up or down.
16

If EXP has the value zero, there is no exponent part. If EXP has

a value greater than zero, then the exponent part to be output has
as many digits as are needed to represent the exponent part of the
value of ITEM (for which a single digit integer part is used), and
includes an initial sign (plus or minus). If the exponent part to be
output has fewer than EXP characters, including the sign, then
leading zeros precede the digits, to make up the difference. For the
value 0.0 of ITEM, the exponent has the value zero.
procedure GET(FROM : in STRING;

ITEM

out

LAST

out POSITIVE);

NUM;

Reads a real value from the beginning of the given string, following
the same rule as the GET procedure that reads a real value from a
file, but treating the end of the string as a file terminator. Returns,
in the parameter ITEM, the value of type NUM that corresponds
to the sequence input. Returns in LAST the index value such that

FROM(LAST)is the last character read. 26

The exception DATA_ERRORisraised if the sequence input does

not have the required syntax, or if the value obtained is not of the
subtype NUM.

procedure PUT(TO

: out STRING;

ITEM : in NUM;
AFT : in FIELD := DEFAULTAFT;
EXP

:; in FIELD := DEFAULTEXP); 27

Outputs the value of the parameter ITEM to the given string,
following the samerule as for output to a file, using a value for

26 See also Appendix G, AI-00307.
27 Specification corrected according to AI-00215; see Appendix G.
14-69

Input-Output for Real Types

14.3.8

FORE such that the sequence of characters output exactly fills the
string, including any leading spaces.

Examples:
package REALIO is new FLOATIO(REAL); use REALIO;

-~- default format used at instantiation, DEFAULTEXP = 3

X : REAL := -123.4567;

PUT (X) ;

digits 8

-- default

PUT (X,

FORE

PUT (X,

AFT

EXP

format
2);

O);

(see 3.5.7)
"-1.2345670E+02"
-_—

"bbb-1.235E+2"

-—-

"p-123.457"

Note:

For an item with a positive value, if output to a string exactly fills the string
without leading spaces, then output of the corresponding negative value will
raise LAYOUT_ERROR.

References : aft attribute 3.5.10, based literal 2.4.2, blank 14.3.5, data_error
exception 14.3.5, decimal literal 2.4.1, field subtype 14.3.5, file_type 14.1, fixed_io
package 14.38.10, floating_io package 14.3.10, fore attribute 3.5.10, get procedure
14.3.5, layout_error 14.3.5, line terminator 14.3.5, put procedure 14.3.5, real literal
2.4, skipping 14.3.5, width 14.3.5

14.3.9

Input-Output for Enumeration Types
1

The following procedures are defined in the generic package
ENUMERATION_IO, which must be instantiated for the appropriate
enumeration type (indicated by ENUM in the specification).

Values are output using either upper or lowercase letters for identifiers.
This is specified by the parameter SET, which is of the enumeration type
TYPE_SET.
type TYPESET is

UPPERCASE) ;

The format (which includes any trailing spaces) can be specified by an

optional field width parameter. The default field width and letter case are
defined by the following variables that are declared in the generic package
ENUMERATION_IO:
DEFAULTWIDTH
DEFAULTSETTING

14.3.9

(LOWERCASE,

:
:

FIELD := 0;
TYPESET := UPPER_CASE;

Input-Output for Enumeration Types

14~—70

The following procedures are provided:

procedure GET(FILE
procedure GET(ITEM

:
:

in FILETYPE;
out ENUM);

ITEM

out ENUM);

After skipping any leading blanks, line terminators, or page ter-

minators, reads an identifier according to the syntax of this lexical
element (lower and upper case being considered equivalent), or
a character literal according to the syntax of this lexical element
(including the apostrophes). Returns, in the parameter ITEM, the
value of type ENUM that corresponds to the sequence input.28
The exception DATA_ERRORis raised if the sequence input does not
have the required syntax, or if the identifier or characterliteral does
not correspond to a value of the subtype ENUM.
procedure PUT(FILE
ITEM
WIDTH
SET

:
:
:
:

in FILETYPE;
in ENUM;
in FIELD := DEFAULTWIDTH;
in TYPESET := DEFAULTSETTING);

procedure PUT(ITEM

: in ENUM;

WIDTH : in FIELD := DEFAULTWIDTH;
SET
: in TYPESET := DEFAULTSETTING);

Outputs the value of the parameter ITEM as an enumeration
literal (either an identifier or a character literal). The optional
parameter SET indicates whether lower case or upper case is used

for identifiers; it has no effect for character literals. If the sequence
of characters produced has fewer than WIDTH characters, then

trailing spaces are finally output to make up the difference.*”
10

procedure GET(FROM : in STRING;
ITEM

out ENUM;

LAST : out POSITIVE) ;

Reads an enumeration value from the beginning of the given
string, following the same rule as the GET procedure that reads an
enumeration value from a file, but treating the end ofthe string as
a file terminator. Returns, in the parameter ITEM,the value of type
ENUM that corresponds to the sequence input. Returns in LAST the
index value such that FROM(LAST)is the last character read.°°

28 See also Appendix G, AI-00239, AI-00307, and AI-00316.

29 See also Appendix G, AI-00239
30 See also Appendix G, AI-00307.
14-71

Input-Output for Enumeration Types

14.3.9

The exception DATA_ERRORisraised if the sequence input does not

have the required syntax, or if the identifier or character literal does
not correspond to a value of the subtype ENUM.
13

procedure PUT (TO
ITEM
SET

> out STRING;
:
:

in ENUM;
in TYPESET

:= DEFAULTSETTING) ;

Outputs the value of the parameter ITEM to the given string,

following the samerule as for output to a file, using the length of the
given string as the value for WIDTH.
15

Although the specification of the package ENUMERATION_IO would allow
instantiation for an integer type, this is not the intended purpose of this
generic package, and the effect of such instantiations is not defined by the
language.
Notes:

There is a difference between PUT defined for characters, and for enumeration values. Thus
TEXTIO.PUT(’A’);

outputs the character A

package CHARIO is new TEXTIO.ENUMERATIONIO (CHARACTER) ;

CHARIO.PUT(’A’);

outputs the character ’A’,

between single quotes

The type BOOLEAN is an enumeration type, hence ENUMERATION_IO
can be instantiated for this type.
Whena control character is input or output using one of the GET or PUT operations resulting from an instantiation of the package ENUMERATION_IO
for the type CHARACTER,the text input (for GET) or output (for PUT) is
the two- or three-character mnemonic for the control character, as shown (in

italics) in Annex C. Thus

CHAR_IO.PUT(ASCII.NUL); -- outputs the characters NUL

For the analogous operation CHAR_IO.GET, the input value would be NUL.
18

References : blank 14.3.5, data_error 14.3.5, enumeration_io package 14.3.10,
field subtype 14.3.5, file_type 14.1, get procedure 14.3.5, line terminator 14.3.5, put
procedure 14.3.5, skipping 14.3.5, width 14.3.5
character type 3.5.2, instantiation 12.3

14.3.9

Input-Output for Enumeration Types

14-72

14.3.10
1

Specification of the Package Text_lO
with IOEXCEPTIONS;

package TEXTIO is

type FILETYPE is limited private;
type FILEMODE is

(INFILE,

OUTFILE) ;

type COUNT is range 0

.
implementationdefined;
subtype POSITIVECOUNT is COUNT range 1
COUNT’ LAST;
UNBOUNDED
constant COUNT := QO; -- line and page length
implementationdefined;
16;

is INTEGER range 0
subtype NUMBERBASE is INTEGER range 2
subtype FIELD

type TYPESET is (LOWER_CASE, UPPERCASE) ;
-- File Management
procedure CREATE

(FILE

in out FILETYPE;

MODE

in FILEMODE

in STRING

2S IT

FORM

in STRING

2= NN)

NAME

procedure OPEN

(FILE

MODE

:= OUTFILE;

in out FILETYPE;

in FILEMODE;

NAME

in STRING;

procedure CLOSE
procedure DELETE
procedure RESET

(FILE
(FILE
(FILE

in out FILETYPE);
in out FILETYPE);
in out FILETYPE;

procedure RESET

(FILE

MODE

in FILEMODE);

function
function
function

MODE
NAME
FORM

(FILE
(FILE
(FILE

in FILETYPE)
in FILETYPE)
in FILETYPE)

function

ISOPEN(FILE : in FILETYPE)

FORM

in STRING := "");

in out FILETYPE);

-- Control of default input and output

procedure SETINPUT

return FILEMODE;
return STRING;
return STRING;
return BOOLEAN;
files

(FILE

in FILETYPE);

procedure SETOUTPUT (FILE

in FILETYPE);

function
function

STANDARDINPUT return FILETYPE;
STANDARDOUTPUT return FILETYPE;

function
function

CURRENTINPUT
CURRENTOUTPUT

return FILETYPE;
return FILETYPE;

-- Specification of line and page lengths
procedure SETLINELENGTH (FILE
in FILETYPE;
TO
> in COUNT);
procedure SETLINELENGTH (TO
in COUNT) ;

14-73

Specification of the Package Text_lIO

14.3.10

procedure

in FILETYPE;

SETPAGELENGTH (FILE

in COUNT) ;
in COUNT) ;

procedure
function
function
function
function

SETPAGELENGTH (TO
in FILETYPE)
LINELENGTH (FILE
in FILETYPE)
PAGELENGTH (FILE
PAGELENGTH return COUNT;
Line,

procedure

NEWLINE

procedure NEWLINE

SKIPLINE

procedure SKIPLINE

(FILE
SPACING
(SPACING

in FILETYPE;

(FILE
SPACING
(SPACING

in
in
in

in POSITIVECOUNT
in POSITIVECOUNT

ENDOFLINE (FILE
in FILETYPE)
ENDOFLINE return BOOLEAN;

procedure

NEWPAGE
NEWPAGE;

procedure SKIP_PAGE
procedure SKIPPAGE;

1);

FILETYPE;
POSITIVECOUNT
POSITIVECOUNT

function
function
procedure

return COUNT;

and Page Control

-- Column ,

procedure

return COUNT;

LINELENGTH return COUNT;

(FILE

in FILETYPE);

(FILE

in FILETYPE);

return BOOLEAN;

function
function

in FILETYPE)
ENDOFPAGE (FILE
ENDOFPAGE return BOOLEAN;

return BOOLEAN;

function
function

ENDOFFILE (FILE
in FILETYPE)
ENDOFFILE return BOOLEAN;

return BOOLEAN;

procedure SETCOL

procedure

(FILE
TO

SETCOL (TO

procedure SETLINE(FILE
TO
procedure SETLINE (TO
function COL
function col

(FILE

in FILETYPE;
in POSITIVECOUNT) ;
in POSITIVECOUNT) ;
in FILETYPE;
in POSITIVECOUNT) ;
in POSITIVECOUNT) ;

in FILETYPE)

return POSITIVECOUNT;

function LINE (FILE
in FILETYPE) return POSITIVECOUNT;
function LINE return POSITIVECOUNT;
function PAGE (FILE
in FILETYPE) return POSITIVECOUNT;
function PAGE return POSITIVECOUNT;
-- Character Input-Output

14.3.10

Specification of the Package Text_lO

14-74

procedure GET (FILE

in
FILETYPE;
out CHARACTER) ;
out CHARACTER) ;
in
FILETYPE;
in CHARACTER) ;
in
CHARACTER) ;

ITEM
procedure GET (ITEM
procedure PUT (FILE
ITEM
procedure PUT (ITEM

-- String Input-Output
procedure GET(FILE : in
ITEM :
procedure GET (ITEM :
procedure PUT(FILE :
ITEM :
procedure PUT(ITEM :

FILETYPE;

out STRING);
out STRING);
in
FILETYPE;
in STRING) ;
in
STRING) ;

procedure GETLINE (FILE
ITEM
LAST
procedure GETLINE (ITEM
LAST
procedure PUTLINE (FILE
ITEM
procedure PUTLINE (ITEM

in
FILETYPE;
out STRING;
out NATURAL) ;
out STRING;
out NATURAL);
in
FILETYPE;
in STRING);
in
STRING);

-- Generic package for Input-Output of Integer Types

generic
type NUM is range <>;

package INTEGERIO is
DEFAULTWIDTH
DEFAULTBASE

FIELD >= NUM’ WIDTH;
NUMBERBASE := 10;

procedure GET (FILE
ITEM
WIDTH

procedure GET (ITEM
procedure PUT (FILE

ITEM
WIDTH
BASE

procedure PUT (ITEM

WIDTH
BASE

procedure GET (FROM
ITEM :
LAST

procedure PUT(TO

ITEM :
BASE

FILETYPE;
in
out NUM;
in FIELD := 0);
ovt NUM; WIDTH :
in
in
in
in
in

in FIELD

FILETYPE;
NUM;
FIELD := DEFAULTWIDTH;
NUMBERBASE := DEFAULTBASE) ;
NUM;

in FIELD

DEFAULTWIDTH;

in NUMBERBASE

:= DEFAULTBASE) ;

in
STRING;
out NUM;
out

POSITIVE) ;

out

STRING;

in NUM;
in NUMBER_BASE

:= DEFAULTBASE) ;

end INTEGERIO;

--~ Generic packages for Input-Output of Real Types

14-75

Specification of the Package Text_lO

14.3.10

generic
type NUM is digits <>;
package FLOATIO is
DEFAULTFORE
DEFAULTAFT
DEFAULTEXP

FIELD
FIELD
FIELD

:= 2;
:= NUM’DIGITS-1;
:= 3;

procedure GET (FILE

in FILETYPE;

ITEM
WIDTH
procedure GET (ITEM

out NUM;
in FIELD
:= 0);
out NUM; WIDTH

procedure PUT (FILE

ITEM
FORE
AFT
EXP

procedure GET (FROM
ITEM
LAST

procedure PUT(TO

end FLOATI0;

:= Q);

in FILETYPE;

in
in
in
in

NUM;
FIELD
FIELD
FIELD

:= DEFAULTFORE;
:= DEFAULTAFT;
:= DEFAULTEXP);

in FIELD
in FIELD
in FIELD

:= DEFAULTFORE;
:= DEFAULTAFT;
:= DEFAULTEXP);

procedure PUT(ITEM : in NUM;
FORE
AFT
EXP

in FIELD

ITEM
AFT
EXP

in STRING;
out NUM;
out POSITIVE) ;

out STRING;
in NUM;
in FIELD
in FIELD

:= DEFAULTAFT;
:= DEFAULTEXP);

generic
type NUM is delta <>;
package FIXEDIO is
DEFAULTFORE
DEFAULTAFT
DEFAULTEXP

FIELD
FIELD
FIELD

procedure GET (FILE
ITEM
WIDTH

procedure GET (ITEM
procedure PUT (FILE
ITEM
FORE
AFT
EXP

procedure PUT (ITEM
FORE
AFT
EXP

14.3.10

Specification of the Package Text_lO

:= NUM’FORE;
:= NUM’AFT;
:= QO;

in FILETYPE;
out NUM;
in FIELD

:= 0);

out NUM; WIDTH
in
in
in
in
in

in FIELD

:= 0);

FILETYPE;
NUM;
FIELD
:= DEFAULTFORE;
FIELD
:= DEFAULTAFT;
FIELD
:= DEFAULTEXP);

in NUM;

in FIELD
in FIELD
in FIELD

:= DEFAULTFORE;
:= DEFAULTAFT;
:= DEFAULTEXP);

14-76

procedure GET(FROM : in
ITEM
LAST

:
:

procedure PUT (TO
ITEM
AFT
EXP

STRING;

out NUM;
out POSITIVE);

:
:
:
:

out STRING;
in NUM;
in FIELD := DEFAULTAFT;
in FIELD := DEFAULTEXP);

end FIXEDI0;

—-- Generic package for Input-Output of Enumeration Types
generic
type ENUM is

(<>);

package ENUMERATIONIO is
DEFAULTWIDTH
DEFAULTSETTING

:
:

FIELD := QO;
TYPESET := UPPERCASE;

procedure GET(FILE

procedure GET(ITEM

in FILETYPE;

: out ENUM);

procedure PUT(FILE

: in FILETYPE;

ITEM
WIDTH
SET
procedure PUT(ITEM
WIDTH
SET

:
:
>
:
:
>

procedure GET(FROM :
ITEM :

in
in
in
in
in
in

ENUM;
FIELD
TYPESET
ENUM;
FIELD
TYPESET

out ENUM);

>= DEFAULTWIDTH;
:= DEFAULTSETTING) ;
:= DEFAULTWIDTH;
:= DEFAULTSETTING) ;

in
STRING;
out ENUM;

LAST

out

POSITIVE) ;

ITEM
SET
end ENUMERATIONI0;

:
:

in
in

ENUM;
TYPESET

procedure PUT (TO

ITEM

: out STRING;

:= DEFAULTSETTING) ;

-- Exceptions
STATUSERROR

MODEERROR
NAMEERROR
USEERROR
DEVICEERROR
ENDERROR
DATA ERROR
LAYOUTERROR

:
:
:
:
>
:
:

exception renames IOEXCEPTIONS.STATUS_ERROR;

exception
exception
exception
exception
exception
exception
exception

renames
renames
renames
renames
renames
renames
renames

IOEXCEPTIONS.MODEERROR;
IOEXCEPTIONS.NAMEERROR;
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICEERROR;
IOEXCEPTIONS.END_ERROR;
IOEXCEPTIONS.DATAERROR;
IOEXCEPTIONS. LAYOUTERROR;

private
-- implementation-dependent

end TEXTIO;

14-77

Specification of the Package Text_lO

14.3.10

14.4 Exceptions in Input-Output
1

The following exceptions can be raised by input-output operations. They
are declared in the package IO_EXCEPTIONS,defined in section 14.5; this
package is namedin the context clause for each of the three input-output
packages. Only outline descriptions are given of the conditions under
which NAME_ERROR, USE_ERROR, and DEVICE_ERRORareraised;

for full details see Appendix F. If more than one error condition exists, the
corresponding exception that appears earliest in the followinglist is the one
that is raised.
In VAX Ada, DEVICE_ERRORis never raised; device-related errors raise

the exception USE_ERROR.The input-output operation descriptions in the
preceding sections give the conditions under which NAME_ERROR and
USE_ERRORare raised; Appendix F summarizes these conditions.
2

The exception STATUS_ERRORis raised by an attempt to operate upon a

The exception MODE_ERRORis raised by an attempt to read from,or test

file that is not open, and by an attempt to open file that is already open.
for the end of, a file whose current mode is OUT_FILE, andalso by an
attempt to write to a file whose current mode is IN_FILE. In the case of

TEXT_IO, the exception MODE_ERRORis also raised by specifying a file

whose current mode is OUT_FILEin a call of SET_INPUT, SKIP_LINE,
END_OF_LINE, SKIP_PAGE, or END_OF_PAGE; and by specifyinga file
whose current mode is IN_FILE in a call of SET_OUTPUT, SET_LINE_

LENGTH, SET_PAGE_LENGTH, LINE_LENGTH, PAGE_LENGTH, NEW_
LINE, or NEW_PAGE.

The exception NAME_ERRORis raised by a call of CREATE or OPENif the
string given for the parameter NAME doesnot allow the identification of an
external file. For example, this exception is raised if the string is improper,
or, alternatively, if either none or more than one externalfile corresponds to

the string?!
5

The exception USE_ERRORisraised if an operation is attempted that is not
possible for reasons that depend on characteristics of the external file. For
example, this exception is raised by the procedure CREATE, among other
circumstances, if the given mode is OUT_FILE but the form specifies an
input only device, if the parameter FORM specifies invalid access rights, or

if an externalfile with the given namealready exists and overwritingis not
allowed.22
|
31 See also Appendix G, AI-00332.
32 See also Appendix G, AI-00332.
14.4

Exceptions in Input-Output

14-78

The exception DEVICE_ERRORisraised if an input-output operation
cannot be completed because of a malfunction of the underlying system.
The exception DEVICE_ERRORis never raised in VAX Ada. Any devicerelated errors will raise the exception USE_ERROR.
The exception END_ERRORis raised by an attempt to skip (read past) the
end ofa file.
The exception DATA_ERROR mayberaised by the procedure READ if the

element read cannot be interpreted as a value of the required type. This

exception is also raised by a procedure GET (defined in the package TEXT_
IO) if the input character sequencefails to satisfy the required syntax,or if

the value input does not belong to the range of the required type or subtype.
The exception LAYOUT_ERRORisraised (in text input-output) by COL,

LINE, or PAGEif the value returned exceeds COUNT’ LAST. The exception
LAYOUT_ERRORis also raised on output by an attempt to set column

or line numbers in excess of specified maximum line or page lengths,
respectively (excluding the unboundedcases). It is also raised by an attempt
to PUT too many charactersto a string.
The exception LAYOUT_ERROR mayalso be raised in VAX Ada by the
GET_ITEM and PUT_ITEM procedures in the mixed-type packages.

LAYOUT_ERRORis raised for GET_ITEM if no more items can be read

from the file buffer; it is raised for PUT_ITEM if the current position exceeds
the file buffer size.
The following exceptions mayalso be raised by the VAX Ada input-output

operations described in sections 14.2a.2, 14.2a.4, 14.2b.7, and 14.2b.9. These

exceptions are declared in the VAX Ada package AUX_IO_EXCEPTIONS
(defined in section 14.5a), which is namedin the context clause for the

packages RELATIVE_IO, RELATIVE_MIXED_IO, INDEXED_IO, and
INDEXED_MIXED_IO.

The exception LOCK_ERRORis raised by the READ or READ_EXISTING
proceduresif the result is a locked record error in a relative or indexedfile.
See section 14.1 for a general explanation of record locking; see the VAX Ada
Run-Time Reference Manual for a more detailed explanation.
The exception EXISTENCE_ERRORis raised by the READ or READ_
EXISTING procedures if the element to be read cannot be found in a
relative or indexedfile.
The exception KEY_ERRORis raised in an indexed file if the key has been
changed or duplicated and changes or duplicates are not permitted. The
exception KEY_ERRORis also raised by the READ_BY_KEY proceduresif
the size of the given keyis not a multiple of eight bits.
14-79

Exceptions in Input-Output

14.4

References: col function 14.3.4, create procedure 14.2.1, end_of_line function

14.3.4, end_of_page function 14.3.4, external file 14.1, file 14.1, form string 14.1,

get procedure 14.3.5, in_file 14.1, io_exceptions package 14.5, line function 14.3.4,
line_length function 14.3.4, name string 14.1, new_line procedure 14.3.4, new_page
procedure 14.3.4, open procedure 14.2.1, out_file 14.1, page function 14.3.4, page_

length function 14.3.4, put procedure 14.3.5, read procedure 14.2.2 14.2.3, set_input

procedure 14.3.2, set_line_length 14.3.3, set_page_length 14.3.3, set_output 14.3.2,
skip_line procedure 14.3.4, skip_page procedure 14.3.4, text_io package 14.3
indexed_io package 14.2a 14.2a.4, indexed_mixed_io package 14.2a 14.2b 14.2b.9,

key 14.2a, locking 14.2a, read procedure 14.2a.2 14.2a.4 14.2b.7 14.2b.9, read_
existing procedure 14.2a.2 14.2b.7, relative_io package 14.2a 14.2a.2, relative_
mixed_io package 14.2a 14.2b 14.2b.7

14.5 Specification of the Package IOExceptions
1

This package defines the exceptions needed by the packages SEQUENTIAL_
IO, DIRECT_IO, and TEXT_IO.

package IOEXCEPTIONS is
STATUSERROR
MODEERROR
NAMEERROR
USEERROR
DEVICEERROR
ENDERROR
DATAERROR
LAYOUTERROR

:
:
:
:
:
>:
:
:

exception;
exception;
exception;
exception;
exception;
exception;
exception;
exception;

end IOEXCEPTIONS;

14.5a Specification of the Package Aux_lO_Exceptions
This package defines the exceptions needed by the VAX Ada packages
RELATIVE_IO, INDEXED_IO, RELATIVE_MIXED_IO, and INDEXED_
MIXED_IO.
package AUX_IOEXCEPTIONS is
LOCKERROR

: exception;

KEYERROR

: exception;

EXISTENCEERROR : exception;

end AUX_IOEXCEPTIONS;

14.5a

Specification of the Package Aux_lO_Exceptions

14-80

14.6 Low Level Input-Output
VAX Ada does not provide the package LOW_LEVEL_IO.Thelibrary
packages STARLET and TASKING_SERVICESproviderelated capabilities
(see the VAX Ada Run-Time Reference Manual for more information).
1

A low level input-output operation is an operation acting on a physical
device. Such an operation is handled by using one of the (overloaded)

predefined procedures SEND_CONTROL and RECEIVE_CONTROL.
2

A procedure SEND_CONTROL maybe used to send control information to a
physical device. A procedure RECEIVE_CONTROLmaybe used to monitor
the execution of an input-output operation by requesting information from
the physical device.
Such procedures are declared in the standard package LOW_LEVEL_IO

and have two parameters identifying the device and the data. However, the
kinds and formats of the control information will depend on the physical
characteristics of the machine and the device. Hence, the types of the
parameters are implementation-defined. Overloaded definitions of these
procedures should be provided for the supported devices.

The visible part of the package defining these proceduresis outlined as
follows:

package LOWLEVELIO is
--

declarations of the possible types for DEVICE and DATA;

-declarations of overloaded procedures for these types:
procedure SENDCONTROL
(DEVICE : devicetype;

DATA

procedure RECEIVECONTROL

(DEVICE

DATA

: in out datatype);
:

devicetype;

: in out data_ type);

end; 33

The bodies of the procedures SEND_CONTROL and RECEIVE_CONTROL

for various devices can be supplied in the body of the package LOW_LEVEL_
IO. These procedure bodies may be written with code statements.

33 See also Appendix G, AI-00355.

14-81

Low Level Input-Output

14.6

14.7 Example of Input-Output
1

The following example shows the use of some of the text input-output

facilities in a dialogue with a user at a terminal. The user is prompted to

type a color, and the program respondsby giving the numberof items of
that color available in stock, according to an inventory. The default input
and outputfiles are used. For simplicity, all the requisite instantiations
are given within one subprogram; in practice, a package, separate from the
procedure, would be used.
2

with TEXTI0; use TEXTIO;
procedure DIALOGUE is
type COLOR is (WHITE, RED,

ORANGE, YELLOW, GREEN, BLUE,
package COLOR_IO is new ENUMERATIONIO(ENUM => COLOR) ;
package NUMBER_IO is new INTEGER_IO(INTEGER) ;
use COLOR_I0O, NUMBERIO;

INVENTORY
CHOICE

BROWN);

array (COLOR) of INTEGER := (20, 17, 43, 10,
28,

COLOR;

procedure ENTERCOLOR (SELECTION
begin

173,

out COLOR)

87);

loop

begin
PUT ("Color selected:

GET (SELECTION) ;

");

---

prompts user

accepts color typed,
or raises exception

return;

exception

when DATAERROR =>
PUT("Invalid color,

try again.

user has typed new line

");

NEWLINE (2) ;
-completes execution of the block statement

end;
end loop;
-- repeats the block statement until color accepted
end;
begin -statements of DIALOGUE;
NUMBERIO.DEFAULTWIDTH := 5;
loop

ENTERCOLOR (CHOICE) ;
SETCOL(5);
SETCOL(40);

NEW_LINE;
end loop;

user types color and new line

PUT (CHOICE) ; PUT(" items available:");
PUT (INVENTORY (CHOICE) );
-- default width is 5

end DIALOGUE;

14.7.

Example of Input-Output

14-82

Example of an interaction (characters typed by the userareitalicized):
Color selected:
Black
Invalid color, try again.
Color selected:
Blue
BLUE items available:
Color selected:
Yellow
YELLOW items available:

173
10

14.7a Example of Additional VAX Ada Input-Output
This example showsthe useof the additional VAX Ada input-outputpackage
SEQUENTIAL_MIXED_IO. This program reads values of mixed types from
different records and then processes the values for output to an array.
with SEQUENTIALMIXEDI0; use SEQUENTIALMIXEDI0;
procedure READFILE(FILENAME : STRING) is

type FLOATARRAY is array

FARRAY
F2, F3, F4
Il, I5, I6
LAST
FILE

(INTEGER range <>)

of FLOAT;

: FLOATARRAY(1 .. 100);
: FLOAT;
: INTEGER;
: INTEGER;
: FILETYPE;

-- Instantiate GET_ITEM for each type in the file.
procedure GETINTEGER is new GET_ITEM(INTEGER) ;

procedure GETFLOAT is new GETITEM(FLOAT) ;
procedure GETSTRING is new GETITEM(STRING) ;

-- Instantiate GETARRAY for a sequence of floating values.

procedure GETFLOATARRAY is
new GETARRAY (FLOAT,

INTEGER, FLOATARRAY)

-- Procedure for processing the values

procedure PROCESSARRAY (FA

: FLOATARRAY;

LAST :

INTEGER)

is separate;

begin
OPEN(FILE,

INFILE,

FILENAME);

-- Read the first record consisting of an integer and two
-- floating values.
READ (FILE) ;
GETINTEGER(FILE, 11);
GETFLOAT(FILE, F2);
GETFLOAT(FILE, F3);

14-83

Example of Additional VAX Ada Input-Output

14.7a

-- Read the second record consisting of a floating value and two
-- integers.
READ (FILE) ;
GETFLOAT(FILE, F4);
GETINTEGER(FILE, 15);
GET_INTEGER(FILE, 16);
-~ The remainder of the file consists of a number of records

~- (each of which contains a variable number of F_floating
-- values), which are processed up to 100 at a time.
READ (FILE) ;

loop

if ENDOFBUFFER(FILE)
READ (FILE) ;

then

GETFLOATARRAY (FILE,

FARRAY,

end if;

PROCESSARRAY (F_ARRAY, LAST);

LAST);

end loop;

CLOSE (FILE) ;

exception
when ENDERROR => CLOSE (FILE) ;

end READFILE;

14.7a

Example of Additional VAX Ada Input-Output

14-84

Annex A

Predefined LanguageAttributes
This annex summarizes the definitions given elsewhere of the predefined

language attributes.

P’ ADDRESS

For a prefix P that denotes an object, a

program unit, a label, or an entry:

Yields the address of thefirst of the storage
units allocated to P. For a subprogram,

package, task unit, or label, this value refers

to the machine code associated with the

corresponding body or statement. For an

entry for which an address clause has been

given, the value refers to the corresponding

hardware interrupt. The value of this
attribute is of the type ADDRESSdefined in
the package SYSTEM.(See 13.7.2.)
For a prefix P that denotes a fixed point
subtype:
Yields the number of decimal digits needed

after the point to accommodate the precision
of the subtype P, unless the delta of the
subtype P is greater than 0.1, in which case
the attribute yields the value one. (P’ AFT
is the smallest positive integer N for which
(10**N)*P’ DELTAis greater than or equal to
one.) The value of this attribute is of the type
universal_integer. (See 3.5.10.)

Predefined Language Attributes A—1

P’ AST_ENTRY

For a prefix P that denotes a single entry of
an object of a task type or an entry of a single
task:
Yields a value of the type AST_HANDLER
(in the package SYSTEM)that transforms an
AST occurrence into a call of the given entry.
This attribute can only occur in a compilation
unit to which the package SYSTEM applies,
and the pragma AST_ENTRY must have been
specified for the entry. (See 9.12a.)

P’ BASE

For a prefix P that denotes a type or subtype:
This attribute denotes the base type of
P. It is only allowed as the prefix of the
name of another attribute: for example,
P’ BASE’ FIRST. (See 3.3.3.)

P’ BIT

For a prefix P that denotes an object:
Yields the bit offset within the storage unit
(byte) containing thefirst bit of the storage
for the object P. The value of this attribute is
of the type universal_integer. (See 13.7.2.)

P’ CALLABLE

For a prefix P that is appropriate for a task

type:

Yields the value FALSE when the execution of

the task P is either completed or terminated,
or when the task is abnormal; yields the
value TRUE otherwise. The value of this
attribute is of the predefined type BOOLEAN.
(See 9.9.)

P’ CONSTRAINED

For a prefix P that denotes an object of a type
with discriminants:
Yields the value TRUEif a discriminant
constraint applies to the object P, or if the
object is a constant (including a formal
parameter or generic formal parameter of
mode in); yields the value FALSE otherwise.
If P is a generic formal parameter of mode in
out, or if P is a formal parameter of mode in
out or out and the type mark given in the
corresponding parameter specification denotes

A-2

Predefined LanguageAttributes

an unconstrained type with discriminants,

then the value of this attribute is obtained
from that of the corresponding actual

parameter. The value of this attribute is of

the predefined type BOOLEAN.(See 3.7.4.)
7

P’ CONSTRAINED

For a prefix P that denotes a private type or
subtype:

Yields the value FALSE if P denotes an
unconstrained nonformal private type with
discriminants; also yields the value FALSE
if P denotes a generic formal private type

and the associated actual subtypeis either

an unconstrained type with discriminants or

an unconstrained array type;yields the value

TRUE otherwise. The value of this attribute

is of the predefined type BOOLEAN.
(See 7.4.2.)
8

P’ COUNT

For a prefix P that denotes an entry of a task
unit:
Yields the numberof entry calls presently
queued on the entry (if the attributeis
evaluated within an accept statement for the
entry P, the count does not include the calling
task). The value of this attribute is of the
type wniversal_integer. (See 9.9.)

P’ DELTA

For a prefix P that.denotes a fixed point
subtype:

Yields the value of the delta specified in the
fixed accuracy definition for the subtype P.
The value of this attribute is of the type
universal_real. (See 3.5.10.)

P’ DIGITS

For a prefix P that denotes a floating point
subtype:

Yields the number of decimal digits in the
decimal mantissa of model numbersof the
subtype P. (This attribute yields the number
D of section 3.5.7.) The value of this attribute
is of the type universal_integer. (See 3.5.8.)

Predefined Language Attributes

A-3

P’ EMAX

For a prefix P that denotes a floating point

subtype:

Yields the largest exponent value in the
binary canonical form of model numbers

_ of the subtype P. (This attribute yields the
product 4*B of section 3.5.7.) The value of
this attribute is of the type wniversal_integer.
(See 3.5.8.)
12

P’ EPSILON

For a prefix P that denotes a floating point
subtype:
Yields the absolute value of the difference

between the model number 1.0 and the

next model numberabove, for the subtype

P. The value of this attribute is of the type
universal_real. (See 3.5.8.)

133

P’ FIRST

For a prefix P that denotes a scalar type, or a
subtype of a scalar type:

Yields the lower bound of P. The value of this
attribute has the same type as P. (See 3.5.)
14

P’ FIRST

For a prefix P that is appropriate for an array

type, or that denotes a constrained array
subtype:

Yields the lower bound of the first index

range. The value of this attribute has the
same type as this lower bound.
(See 3.6.2 and 3.8.2.)

P’FIRST(N)

For a prefix P that is appropriate for an array

type, or that denotes a constrained array

subtype:

Yields the lower bound of the N-th index
range. The value of this attribute has
the same type as this lower bound. The
argument N must be a static expression of

type universal_integer. The value of N must

be positive (nonzero) and no greater than the
dimensionality of the array. (See 3.6.2 and
3.8.2.)

A-4

Predefined Language Attributes

P’ FIRST_BIT

For a prefix P that denotes a componentof a
record object:
Yields the offset, from the start of the first of

the storage units occupied by the component,
of the first bit occupied by the component.

This offset is measured in bits. The value of
this attribute is of the type universal_integer.
(See 13.7.2.)

P’ FORE

For a prefix P that denotes a fixed point
subtype:
Yields the minimum numberof characters
needed for the integer part of the decimal

representation of any value of the subtype

P, assuming that the representation does
not include an exponent, but includes a
one-character prefix that is either a minus
sign or a space. (This minimum number does

not include superfluous zeros or underlines,

and is at least two.) The value of this

attribute is of the type universal_integer.

(See 3.5.10.)
18

P’ IMAGE

For a prefix P that denotes a discrete type or
subtype:
This attribute is a function with a single
parameter. The actual parameter X must
be a value of the base type of P. The result

type is the predefined type STRING. The
result is the image of the value of X, that is, a

sequence of characters representing the value
in display form. The imageof an integer
value is the corresponding decimalliteral;
without underlines, leading zeros, exponent,

or trailing spaces; but with a one character

prefix that is either a minus sign or a space.

The image of an enumeration value is either
the corresponding identifier in upper case or

the corresponding characterliteral (including

the two apostrophes); neither leading nor

trailing spaces are included. The image of a
character other than a graphic characteris
implementation-defined. (See 3.5.5.)
Predefined Language Attributes

A—5

P’ LARGE

For a prefix P that denotes a real subtype:
The attribute yields the largest positive
model number of the subtype P. The value of
this attribute is of the type universal_real.

(See 3.5.8 and 3.5.10.)

P’ LAST

For a prefix P that denotes a scalar type, or a

subtype of a scalar type:

Yields the upper boundof P. The value ofthis
attribute has the sametypeas P. (See 3.5.)
21

P’ LAST

For a prefix P that is appropriate for an array

type, or that denotes a constrained array
subtype:

Yields the upper boundofthefirst index

range. The value of this attribute has the

same type as this upper bound. (See 3.6.2
and 3.8.2.)

P’ LAST(N)

For a prefix P that is appropriate for an array
type, or that denotes a constrained array

subtype:

Yields the upper bound of the N-th index
range. The value of this attribute has

the same type as this upper bound. The
argument N must be a static expression of
type universal_integer. The value of N must
be positive (nonzero) and no greater than the
dimensionality of the array. (See 3.6.2 and
3.8.2.)
23

P’ LAST_BIT

For a prefix P that denotes a component of a
record object:
Yields the offset, from the start of the first of

the storage units occupied by the component,
of the last bit occupied by the component.
This offset is measured in bits. The value of
this attribute is of the type wniversal_integer.
(See 13.7.2.)

A-6

Predefined Language Attributes

P’ LENGTH

For a prefix P that is appropriate for an array
type, or that denotes a constrained array
subtype:
Yields the numberof values of the first index
range (zero for a null range). The value of
this attribute is of the type wniversal_integer.
(See 3.6.2.)

P’ LENGTH)

For a prefix P that is appropriate for an array
type, or that denotes a constrained array
subtype:
Yields the numberof values of the N-th index
range (zero for a null range). The value of
this attribute is of the type universal_integer.

The argument N must be a static expression
of type universal_integer. The value of N
must be positive (nonzero) and no greater
than the dimensionality of the array. (See
3.6.2 and 3.8.2.)
P’ MACHINE_EMAX

For a prefix P that denotes a floating point

type or subtype:

Yields the largest value of exponent for the
machine representation of the base type of
P. The value of this attribute is of the type
universal_integer. (See 13.7.3.)
P’ MACHINE_EMIN

For a prefix P that denotes a floating point

type or subtype:

Yields the smallest (most negative) value of
exponent for the machine representation of
the base type of P. The valueof this attribute
is of the type uwniversal_integer. (See 13.7.3.)
28

P’ MACHINE_MANTISSA

For a prefix P that denotes a floating point

type or subtype:

Yields the numberof digits in the mantissa
for the machine representation of the base

type of P (the digits are extended digits in
the range 0 to P’- MACHINE_RADIX 1).

The value of this attribute is of the type
universal_integer. (See 13.7.3.)

Predefined Language Attributes

A-7

P* MACHINEOVERFLOWS

Fora prefix P that denotes a real type or

subtype:

Yields the value TRUE if every predefined
operation on values of the base type of P

either provides a correct result, or raises the

exception NUMERIC_ERRORin overflow
situations; yields the value FALSE otherwise.
The value of this attribute is of the predefined
type BOOLEAN.(See 13.7.3.)
30

P*’MACHINE_RADIX

For a prefix P that denotes a floating point

type or subtype:

Yields the value of the radix used by the

machinerepresentation of the base type of

P. The value of this attribute is of the type
universal_integer. (See 13.7.3.)

P*MACHINE_ROUNDS

For a prefix P that denotes a real type or
subtype:
Yields the value TRUE if every predefined
arithmetic operation on values of the base

type of P either returns an exact result or
performs rounding; yields the value FALSE

otherwise. The value of this attribute is of

the predefined type BOOLEAN.(See 13.7.3.)

P’ MACHINE_SIZE

For a prefix P that denotes any type or
subtype:
Yields the number of machinebits to be
allocated for variables of the type or subtype.
This value takes into account any padding
bits used by VAX Ada when allocating a
variable on a byte boundary. The value of
this attributeis of the type universal_integer.

(See 13.7.2.)

P’ MANTISSA

For a prefix P that denotes a real subtype:
Yields the numberof binary digits in the

binary mantissa of model numbersof the

subtype P. (This attribute yields the number

B of section 3.5.7 for a floating point type,
or of section 3.5.9 for a fixed point type.)

A-8

Predefined Language Attributes

The value of this attribute is of the type
universal_integer. (See 3.5.8 and 3.5.10.)
P’ NOULL_PARAMETER

For a prefix P that denotes any type or
subtype:
Yields an (imaginary) object of type or
subtype P allocated at (machine) address
zero. The attribute is allowed only as the
default expression of a formal parameter
or as an actual expression of a subprogram
call; in either case, the subprogram must be
imported. (See 13.9a.1.3.)

P’POS

For a prefix P that denotes a discrete type or
subtype:

This attribute is a function with a single

parameter. The actual parameter X must be

a value of the base type of P. The result type

is the type universal_integer. The result is

the position numberof the value of the actual
parameter. (See 3.5.5.)

P’ POSITION |

For a prefix P that denotes a componentof a

record object: 1

Yields the offset, from the start of thefirst
storage unit occupied by the record, of the

first of the storage units occupied by the

component. This offset is measured in storage

units. The value of this attribute is of the
type universal_integer. (See 13.7.2.)
35

P’' PRED

For a prefix P that denotes a discrete type or
subtype:

This attribute is a function with a single
parameter. The actual parameter X must be
a value of the base type of P. The result type
is the base type of P. The result is the value

whose position numberis one less than that

of X. The exception CONSTRAINT_ERRORis

raised if X equals P’ BASE’ FIRST.
(See 3.5.5.)

1 See also Appendix G, AI-00258.
Predefined Language Attributes

A—9

P’ RANGE

For a prefix P that is appropriate for an array

type, or that denotes a constrained array
subtype:

Yields the first index range of P, that is, the

range P’ FIRST .. P’ LAST. (See 3.6.2.)

P’ RANGE(N)

For a prefix P that is appropriate for an array

type, or that denotes a constrained array
subtype:

Yields the N-th index range ofP, that is, the
range P’ FIRST(N) .. P’ LAST(N). (See 3.6.2.)
38

P’SAFE_EMAX

For a prefix P that denotes a floating point
type or subtype:
Yields the largest exponent value in the
binary canonical form of safe numbers of
the base type of P. (This attribute yields the

numberE of section 3.5.7.) The value of this
attribute is of the type universal_integer.
(See 3.5.8.)

P’ SAFE_LARGE

For a prefix P that denotes a real type or
subtype:
Yields the largest positive safe numberof the
base type of P. The value of this attribute is
of the type uwniversal_real. (See 3.5.8
and 3.5.10.)

P’ SAFE_SMALL

For a prefix P that denotes a real type or
subtype:
Yields the smallest positive (nonzero) safe
numberof the base type of P. The value of
this attribute is of the type wniversal_real.

(See 3.5.8 and 3.5.10.)

P’ SIZE

For a prefix P that denotes an object:
Yields the numberof bits allocated to hold
the object. The value of this attribute is of
the type universal_integer. (See 13.7.2.)

A-10

P’ SIZE

Predefined Language Attributes

For a prefix P that denotes any type or
subtype:

Yields the minimum numberofbits that
is needed by the implementation to hold
any possible object of the type or subtype
P. The value of this attribute is of the type
universal_integer. (See 13.7.2.)
43

P’ SMALL

For a prefix P that denotes a real subtype:

Yields the smallest positive (nonzero) model
numberof the subtype P. The valueof this
attribute is of the type wniversal_real. (See
3.5.8 and 3.5.10.)
44

P’ STORAGE_SIZE

For a prefix P that denotes an access type or
subtype:

Yields the total numberof storage units
reserved for the collection associated with the
base type of P. The value of this attributeis
of the type universal_integer. (See 13.7.2.)
45

P’ STORAGE_SIZE

For a prefix P that denotes a task type or a

task object:

Yields the number of storage units reserved
for each activation of a task of the type P
or for the activation of the task object P.
The value of this attribute is of the type

universal_integer. (See 13.7.2.)

P’SUCC

For a prefix P that denotes a discrete type or
subtype:
This attribute is a function with a single
parameter. The actual parameter X must
be a value of the base type of P. Theresult

type is the base type of P. The result is the

value whose position numberis one greater
than that of X. The exception CONSTRAINT_
ERRORis raised if X equals P’ BASE’ LAST.
(See 3.5.5.)
47

P’ TERMINATED

For a prefix P that is appropriate for a task

type:

Yields the value TRUEif the task P

is terminated; yields the value FALSE
otherwise. The value of this attribute is of

the predefined type BOOLEAN.(See 9.9.)
Predefined Language Attributes

A—11

P’ TYPE_CLASS

For a prefix P that denotes a type or subtype:
Yields the value of the type class for the full
type of P. If P is a generic formal type, then
the value is that for the corresponding actual
subtype. The value of this attribute is of the
type TYPE_CLASSin the package SYSTEM.
(See 13.7a.2.)

P’ VAL

For a prefix P that denotes a discrete type or
subtype:
This attribute is a special function with

a single parameter X which can be of any

integer type. The result type is the base

type of P. The result is the value whose

position numberis the wniversal_integer

value corresponding to X. The exception

CONSTRAINT_ERRORis raised if the
universal_integer value corresponding to X is

not in the range P’ POS(P’ BASE’ FIRST)..
P’ POS(P’ BASE’ LAST). (See 3.5.5.)
49

P’ VALUE

For a prefix P that denotes a discrete type or
subtype:

This attribute is a function with a single

parameter. The actual parameter X must be
a value of the predefined type STRING. The
result type is the base type of P. Any leading
and any trailing spaces of the sequence of

characters that corresponds to X are ignored.
For an enumeration type, if the sequence of
characters has the syntax of an enumeration
literal and if this literal exists for the base
type of P, the result is the corresponding
enumeration value. For an integer type, if

the sequence of characters has the syntax
of an integerliteral, with an optional single
leading character that is a plus or minus
sign, and if there is a corresponding value
in the base type of P, the result is this
value. In any other case, the exception
CONSTRAINTERRORis raised. (See 3.5.5.)

A-12

Predefined Language Attributes

5s.

PP’ WIDTH

For a prefix P that denotes a discrete subtype:
Yields the maximum imagelength over

all values of the subtype P (the image is

the sequence of characters returned by the

attribute IMAGE). The value of this attribute
is of the type universal_integer. (See 3.5.5.)

Predefined Language Attributes

A-—13

Annex. B

Predefined Language Pragmas
This annex defines the pragmas LIST, PAGE, and OPTIMIZE, and

summarizes the definitions given elsewhere of the remaining language-

defined pragmas.

The VAX Ada pragmas IDENTand TITLEarealso defined in this annex.

Pragma

Meaning

AST_ENTRY

Takes the simple nameof a single entry
as the single argument; at most one
AST_ENTRY pragmais allowed for any
given entry. This pragma must be used
in combination with the AST_ENTRY
attribute, and is only allowed after the
entry declaration and in the same task
type specification or single task as the
entry to which it applies. This pragma
specifies that the given entry may be
used to handle a VMSasynchronous
system trap (AST) resulting from a VMS
system service call. The pragma does
not affect normal use of the entry (see
9.12a).

CONTROLLED

Takes the simple nameof an access type
as the single argument. This pragma
is only allowed immediately within the
declarative part or package specification

that contains the declaration of the
access type; the declaration must occur
before the pragma. This pragma is
Predefined Language Pragmas

B-1

not allowed for a derived type. This
pragmaspecifies that automatic storage
reclamation must not be performed

for objects designated by values of the
access type, except upon leaving the
innermost block statement, subprogram

body, or task body that encloses the

access type declaration, or after leaving
the main program (see 4.8).

ELABORATE

Takes one or more simple names
denoting library units as arguments.
This pragmais only allowed immediately
after the context clause of a compilation
unit (before the subsequent library unit
or secondary unit). Each argument must
be the simple nameof a library unit

mentioned by the context clause. This

pragmaspecifies that the corresponding

library unit body must be elaborated
before the given compilation unit. If the
given compilation unit is a subunit, the
library unit body must be elaborated

before the body of the ancestor library
unit of the subunit (see 10.5).
EXPORT_EXCEPTION

B-2

Predefined Language Pragmas

Takes an internal name denoting an
exception, and optionally takes an
external designator (the name of a VMS
Linker global symbol), a form (ADA
or VMS), and a code(a static integer
expression that is interpreted as a VAX
condition code) as arguments. A code
value must be specified when the form
is VMS(the default if the form is not
specified). This pragmais only allowed
at the place of a declarative item, and
must apply to an exception declared by
an earlier declarative item of the same
declarative part or package specification;
it is not allowed for an exception
declared with a renaming declaration or
for an exception declared in a generic
unit. This pragma permits an Ada
exception to be handled by programs

written in other VAX languages (see
13.9a.3.2).
EXPORT_FUNCTION

Takes an internal name denoting
a function, and optionally takes an
external designator (the nameof a
VMSLinker global symbol), parameter
types, and result type as arguments.

This pragmais only allowed at the
place of a declarative item, and must
apply to a function declared by an
earlier declarative item of the same
declarative part or package specification.
In the case of a function declared as a
compilation unit, the pragmais only
allowed after the function declaration
and before any subsequent compilation
unit. This pragmais not allowed for
a function declared with a renaming
declaration, and it is not allowed for a
generic function (it may be given for
a generic instantiation). This pragma
permits an Ada function to be called
from a program written in another VAX
language (see 13.9a.1.4).

EXPORT_OBJECT

Takes an internal name denoting an
object, and optionally takes an external
designator (the name of a VMS Linker
global symbol) and size designator (a
VMSLinker global symbol whose value
is the size, in bytes, of the exported
object) as arguments. This pragmais
only allowed at the place of a declarative
item at the outermost level of a library
package specification or body, and must
apply to a variable declared by an
earlier declarative item of the same
package specification or body; the
variable must be of a type or subtype
that has a constant size at compile time.
This pragmais not allowed for objects
declared with a renaming declaration,
and is not allowed in a generic unit.
This pragma permits an Adaobjectto
Predefined Language Pragmas

B-3

be referred to by a routine written in
another VAX language (see 13.9a.2.2).

EXPORT_PROCEDURE

Takes an internal name denoting a
procedure, and optionally takes an
external designator (the name of a VMS
Linker global symbol) and parameter
types as arguments. This pragmais
only allowed at the place of a declarative
item, and must apply to a procedure
declared by an earlier declarative
item of the same declarative part or
package specification. In the case of
a procedure declared as a compilation
unit, the pragmais only allowed
after the procedure declaration and
before any subsequent compilation
unit. This pragmais not allowed for
a procedure declared with a renaming
declaration, and is not allowed for a

generic procedure (it may be given for
a generic instantiation). This pragma

permits an Ada routine to be called
from a program written in another VAX
language (see 13.9a.1.4).
EXPORT_VALUED_PROCEDURE Takes an internal name denoting a
procedure, and optionally takes an
external designator (the name of a VMS
Linker global symbol) and parameter
types as arguments. This pragmais
only allowed at the place of a declarative
item, and must apply to a procedure
declared by an earlier declarative
item of the same declarative part or
package specification. In the case of
a procedure declared as a compilation
unit, the pragmais only allowed after
the procedure declaration and before
any subsequent compilation unit. The
first (or only) parameter of the procedure
must be of mode out. This pragmais
not allowed for a procedure declared
with a renaming declaration andis not
allowed for a generic procedure (it may
B-—4

Predefined Language Pragmas

be given for a generic instantiation).
This pragma permits an Ada procedure
to behave as a function that both
returns a value and causesside effects
on its parameters whenit is called
from a routine written in another VAX
language (see 13.9a.1.4).
IDENT

Takes a string literal of 31 or fewer
characters as the single argument. The
pragma IDENThasthe following form:
pragma IDENT

(string_literal);

This pragmais allowed only in the
outermost declarative part or declarative
items of a compilation unit. The given
string is used to identify the object
module associated with the compilation
unit in which the pragma IDENT occurs.
IMPORT_EXCEPTION

of the same declarative part or package
specification; it is not allowed for an
exception declared with a renaming
declaration. This pragma permits a
non-Ada exception (most notably, a VAX
condition) to be handled by an Ada
program (see 13.9a.3.1).
IMPORT_FUNCTION

Takes an internal name denoting
a function, and optionally takes an
external designator (the nameof a
VMSLinker global symbol), parameter
Predefined Language Pragmas

B-5

types, parameter mechanisms,result
mechanism, anda first optional

parameter as arguments. The pragma

INTERFACE must be used with this
pragma(see 13.9). This pragmais only
allowed at the place of a declarative
item, and must apply to a function
declared by an earlier declarative
item of the same declarative part or
package specification. In the case of
a function declared as a compilation
unit, the pragmais only allowed after
the function declaration and before
any subsequent compilation unit.
This pragmais allowed for a function
declared with a renaming declaration;
it is not allowed for a generic function
or ageneric function instantiation. This
pragma permits a non-Ada routine to be
used as an Ada function (see 13.9a.1.1).
IMPORT_OBJECT

Takes an internal name denoting an
object, and optionally takes an external
designator (the name of a VMS Linker
global symbol) and size (a VMS Linker
global symbol whose valueis the size
in bytes of the imported object) as
arguments. This pragmais only allowed
at the place of a declarative item at the
outermost level of a library package
specification or body, and must apply
to a variable declared by an earlier
declarative item of the same package
specification or body; the variable
must be of a type or subtype that
has a constant size at compile time.

This pragmais not allowed for objects
declared with a renaming declaration,
and is not allowed in a generic unit.

This pragma permits storage declared in

a non-Ada routine to be referred to by
an Ada program (see 13.9a.2.1).

B-6

Predefined Language Pragmas

IMPORT_PROCEDURE

Takes an internal name denoting a
procedure, and optionally takes an
external designator (the name of a VMS
Linker global symbol), parameter types,
parameter mechanisms, anda first
optional parameter as arguments. The
pragma INTERFACE mustbe used with
this pragma(see 13.9). This pragmais
only allowed at the place of a declarative
item, and must apply to a procedure
declared by an earlier declarative

item of the same declarative part or
package specification. In the case of
a procedure declared as a compilation
unit, the pragmais only allowed after
the procedure declaration and before
any subsequent compilation unit. This
pragmais allowed for a procedure
declared with a renaming declaration;
it is not allowed for a generic procedure
or a generic procedure instantiation.

This pragma permits a non-Ada routine
to be used as an Ada procedure (see
13.9a.1.1).
IMPORT_VALUED_PROCEDURE Takes an internal name denoting a
procedure, and optionally takes an
external designator (the name of a VMS
Linker global symbol), parameter types,
parameter mechanisms, anda first
optional parameter as arguments. The
pragma INTERFACE must be used with
this pragma(see 13.9). This pragmais
only allowed at the place of a declarative
item, and must apply to a procedure
declared by an earlier declarative

item of the same declarative part or
package specification. In the case of
a procedure declared as a compilation
unit, the pragmais only allowed after
the procedure declaration and before
any subsequent compilation unit. The
first (or only) parameter of the procedure
must be of mode out. This pragma
Predefined Language Pragmas

B-7

is allowed for a procedure declared
with a renaming declaration; it is not
allowed for a generic procedure. This
pragma permits a non-Ada routine that
returns a value and causesside effects
on its parametersto be used as an Ada
procedure (see 13.9a.1.1).
4

INLINE

Takes one or more names as arguments;
each nameis either the nameof a
subprogram or the nameof a generic
subprogram. This pragma is only

allowed at the place of a declarative

item in a declarative part or package
specification, or after a library unit in a

compilation, but before any subsequent.
compilation unit. This pragma specifies
that the subprogram bodies should be
expandedinline at each call whenever
possible; in the case of a generic

subprogram, the pragmaapplies to calls

of its instantiations (see 6.3.2).
INLINE_GENERIC

B-8

Predefined Language Pragmas

Takes one or more names as arguments;
each nameis either the nameof a
generic declaration or the name of an
instance of a generic declaration. This
pragmais only allowed at the place
of a declarative item in a declarative
part or package specification, or after
a library unit in a compilation, but
before any subsequent compilation
unit. Each argument must be the
simple nameof a generic subprogram or
package, or a (nongeneric) subprogram
or package that is an instance of a
generic subprogram or package declared
by an earlier declarative item of the
same declarative part or package
specification. This pragmaspecifies that
inline expansion of the generic body
is desired for each instantiation of the
named generic declarations or of the
particular namedinstances; the pragma

does not apply to calls of instances of
generic subprograms(see 12.1a).
5

INTERFACE

Takes a language name and a
subprogram nameas arguments. This
pragmais allowed at the place of a
declarative item, and must apply in
this case to a subprogram declared by
an earlier declarative item of the same

declarative part or package specification.

This pragmais also allowed for a
library unit; in this case the pragma
must appear after the subprogram
declaration, and before any subsequent

compilation unit. This pragma specifies

the other language (and thereby the
calling conventions) and informs the
compiler that an object module will
be supplied for the corresponding

subprogram (see 13.9).

In VAX Ada, the pragma INTERFACE
is required in combination with the
pragmas IMPORT_FUNCTION,
IMPORT_PROCEDURE, and IMPORT_
VALUED_PROCEDUREwhen anyof
those pragmasare used (see 13.9a.1).
6

LIST

Takes one of the identifiers ON or
OFFas the single argument. This

pragmais allowed anywhere a pragma

is allowed. It specifies that listing of
the compilation is to be continued or
suspended until a LIST pragma with the
opposite argumentis given within the
same compilation. The pragmaitselfis
always listed if the compiler is producing
a listing.

LONG_FLOAT

Takes either D_FLOAT or G_FLOAT
as the single argument. The default is
G_FLOAT. This pragmais only allowed
at the start of a compilation, before
the first compilation unit (if any) of
the compilation. It specifies the choice
of representation to be used for the
Predefined Language Pragmas

B-9

predefined type LONG_FLOATin the
package STANDARD,andfor floating
point type declarations with digits
specified in the range 7..15 (see 3.5.7a).

B-10

MAIN_STORAGE

Takes one or two nonnegative static
simple expressions of some integer type
as arguments. This pragmais only
allowed in the outermost declarative
part of a library subprogram; at most
one such pragmais allowed in a library
subprogram. It has an effect only when
the subprogram to which it applies is
used as a main program. This pragma
causes a fixed-size stack to be created
for a main task (the task associated with
a main program), and determines the
numberof storage units (bytes) to be
allocated for the stack working storage
area or guard pages or both. The value
specified for either or both the working
storage area and guard pagesis rounded
up to an integral numberof pages. A
value of zero for the working storage
area results in the use of a default
size; a value of zero for the guard pages
results in no guard storage. A negative
value for either working storage or
guard pages causes the pragma to be
ignored (see 13.2b).

MEMORY_SIZE

Takes a numeric literal as the single
argument. This pragmais only allowed
at the start of a compilation, before the
first compilation unit (Gif any) of the
compilation. The effect of this pragma is
to use the value of the specified numeric
literal for the definition of the named
number MEMORY_SIZE (see 13.7).

OPTIMIZE

Takes one of the identifiers TIME
or SPACEasthe single argument.
This pragmais only allowed within a
declarative part and it applies to the
block or body enclosing the declarative

Predefined Language Pragmas

part. It specifies whether time or space
is the primary optimization criterion.
In VAX Ada, this pragmais only allowed
immediately within a declarative part of
a body declaration.
9

PACK

Takes the simple nameofa record or
array type as the single argument. The
allowed positions for this pragma, and

the restrictions on the namedtype,
are governed by the samerules as for
a representation clause. The pragma
specifies that storage minimization
should be the main criterion when
selecting the representation of the given
type (see 13.1).
10

PAGE

This pragma has no argument, andis
allowed anywhere a pragmais allowed.
It specifies that the program text which
follows the pragma should start on a
new page(if the compiler is currently
producinga listing).

PRIORITY

Takes a static expression of the
predefined integer subtype PRIORITY

as the single argument. This pragma is

only allowed within the specification of
a task unit or immediately within the

outermost declarative part of a main
program. It specifies the priority of the
task (or tasks of the task type) or the
priority of the main program (see 9.8).

PSECT_OBJECT

Takes an internal name denoting an
object, and optionally takes an external
designator (the name of a program
section) and a size (a VMS Linkerglobal
symbol whose valueis interpreted as the
size, in bytes, of the exported/imported
object) as arguments. This pragmais

only allowed at the place of a declarative
item at the outermost level of a library
package specification or body, and must
apply to a variable declared by an
Predefined Language Pragmas

B-11

earlier declarative item of the same
package specification or body; the
variable must be of a type or subtype
that has a constant size at compile time.
This pragmais not allowed for an object
declared with a renaming declaration,
and is not allowed in a generic unit.
This pragma enables the shared use
of objects that are stored in overlaid
program sections (see 13.9a.2.3).
122

SHARED

Takes the simple nameof a variable as
the single argument. This pragmais
allowed only for a variable declared by
an object declaration and whose type

is a scalar or access type; the variable

SHARE_GENERIC

B-12

Predefined Language Pragmas

declaration and the pragma must both
occur (in this order) immediately within
the same declarative part or package
specification. This pragma specifies that
every read or update of the variable is a
synchronization point for that variable.
An implementation must restrict
the objects for which this pragmais
allowed to objects for which each of
direct reading and direct updatingis
implemented as an indivisible operation
(see 9.11).
Takes one or more names as arguments;
each nameis either the nameof a
generic declaration or the nameof an
instance of a generic declaration. This
pragmais only allowed at the place
of a declarative item in a declarative
part or packagespecification, or after a
library unit in a compilation, but before
any subsequent compilation unit. Each
argument must be the simple name
of a generic subprogram or package,
or a (nongeneric) subprogram or
package that is an instance of a generic
subprogram or package declared by an
earlier declarative item of the same
declarative part or package specification.

This pragma specifies that generic code
sharing is desired for each instantiation
of the named generic declarations or
of the particular named instances (see
12.1b).
13

STORAGE_UNIT

Takes a numeric literal as the single
argument. This pragmais only allowed
at the start of a compilation, before the
first compilation unit (if any) of the
compilation. The effect of this pragma is
to use the value of the specified numeric
literal for the definition of the named
number STORAGE_UNIT(see 13.7).

In VAX Ada, the only argument allowed
for this pragmais (bits).
14

SUPPRESS

Takes as arguments the identifier of a
check and optionally also the name of
either an object, a type or subtype, a
subprogram, a task unit, or a generic

unit. This pragmais only allowed
either immediately within a declarative
part or immediately within a package
specification. In the latter case, the
only allowed form is with a name that

denotes an entity (or several overloaded
subprograms) declared immediately
within the package specification. The
permission to omit the given check
extends from the place of the pragma
to the end of the declarative region
associated with the innermost enclosing
block statement or program unit. For a

pragma given in a packagespecification,

the permission extendsto the end of the
scope of the namedentity.
If the pragma includes a name, the
permission to omit the given check
is further restricted: it is given only
for operations on the namedobject
or on all objects of the base type of a
named type or subtype; for calls of a
named subprogram; for activations of
Predefined Language Pragmas

B-13

tasks of the named task type;or for
instantiations of the given generic unit
(see 11.7).

SUPPRESS_ALL

This pragma has no argument andis
only allowed following a compilation
unit. This pragmaspecifies that all runtime checks in the unit are suppressed
(see 11.7).

SYSTEMNAME

Takes an enumeration literal as the
single argument. This pragmais only
allowed at the start of a compilation,

before the first compilation unit (if

any) of the compilation. The effect of

this pragmais to use the enumeration

literal with the specified identifier for
the definition of the constant SYSTEM_
NAME. This pragmais only allowedif
the specified identifier corresponds to
one oftheliterals of the type NAME
declared in the package SYSTEM
(see 13.7).
TASK_STORAGE

Takes the simple nameof a task
type and a static expression of some
integer type as arguments. This
pragmais allowed anywhere that a
task storage specification is allowed;
that is, the declaration of the task type
to which the pragma applies and the
pragma mustboth occur (in this order)
immediately within the same declarative
part, package specification, or task
specification. The effect of this pragma

is to use the value of the expression as
the numberof storage units (bytes) to be
allocated as guard storage. The value
is rounded up to an integral number
of pages: a value of zero results in no
guard storage; a negative value causes
the pragmato be ignored (see 13.2a).

B-14

Predefined Language Pragmas

TIME_SLICE

Takes a static expression of the
predefined fixed point type DURATION
(in the package STANDARD)as the
single argument. This pragmais only
allowed in the outermost declarative
part of a library subprogram, and at
most one such pragmais allowed in a
library subprogram. It has an effect
only when the subprogram to which
it applies is used as a main program.
This pragmaspecifies the nominal
amount of elapsed time permitted for
the execution of a task when other tasks
of the samepriority are also eligible ~
for execution. A positive, nonzero
value of the static expression enables
round-robin scheduling for all tasks in
the subprogram; a negative or zero value
disables it (see 9.8a).

TITLE

Takes title or a subtitle string, or both,
as arguments. The pragma TITLE has
the following form:
pragma TITLE

(titling-option

[,titling-option]);

titling-option :=
|

[TITLE =>] stringliteral
[SUBTITLE =>] stringliteral

This pragmais allowed anywhere a
pragmais allowed; the given strings
supersede the default title and/or
subtitle portions of a compilation listing.
VOLATILE

Takes the simple nameof a variable
as the single argument. This pragma
is only allowed for a variable declared
by an object declaration. The variable
declaration and the pragma must both
occur (in this order) immediately within
the same declarative part or package
specification. The pragma must appear
before any occurrence of the nameof
the variable other than in an address
clause or in one of the VAX Ada pragmas
Predefined Language Pragmas

B-15

IMPORT_OBJECT, EXPORT_OBJECT,

or PSECT_OBJECT. The variable cannot

be declared by a renaming declaration.
The pragma VOLATILEspecifies
that the variable may be modified
asynchronously. This pragmainstructs
the compiler to obtain the value of a
variable from memory each timeit is
used (see 9.11).

B-16

Predefined Language Pragmas

Annex C

Predefined Language Environment
This annex outlines the specification of the package STANDARDcontaining
all predefined identifiers in the language. The corresponding package body
is implementation-defined and is not shown.

The operators that are predefined for the types declared in the package
STANDARDare given in commentssince they are implicitly declared.
Italics are used for pseudo-names of anonymoustypes (such as uwniversal_
real) and for undefined information (such as implementation_defined and
any_fixed_point_type).
package STANDARD is
type BOOLEAN is

(FALSE,

TRUE);

-- The predefined relational operators for this type are
-- as follows:
---~----

function
function
function
function
function
function

"="
"/="
"<"
"<="
">"
">="

(LEFT,
(LEFT,
(LEFT,
(LEFT,
( LEFT,
( LEFT,

RIGHT
RIGHT
RIGHT
RIGHT
RIGHT
RIGHT

:
:
:
:
:
:

BOOLEAN)
BOOLEAN)
BOOLEAN)
BOOLEAN)
BOOLEAN )
BOOLEAN )

return
return
return
return
return
return

BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;

-~- The predefined logical operators and the predefined logical
-- negation operator are as follows:
-- function "and"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-- function "xor"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-- function "not"

(RIGHT

function

"or"

BOOLEAN)

return BOOLEAN;

-- The universal type universalinteger is predefined.
type INTEGER is implementationdefined;
-- The predefined operators for this type are as follows:

Predefined Language Environment

C-1

-------

function
function
function
function
function
function

"="
"/="
"<"
"<="
">"
">="

(LEFT,
(LEFT,
(LEFT,
(LEFT,
(LEFT,
(LEFT,

-- function "+"
-- function "-"
-- function "abs"

(RIGHT
(RIGHT
(RIGHT

-------

(LEFT,
(LEFT,
(LEFT,
(LEFT,
(LEFT,
(LEFT,

function
function
function
function
function
function

"+"
"-"
"*"
"/"
"rem"
"mod"

-~ function "**"
--

RIGHT
RIGHT
RIGHT
RIGHT
RIGHT
RIGHT

INTEGER)
INTEGER)
INTEGER)
INTEGER)
INTEGER)
INTEGER)

INTEGER)
INTEGER)
INTEGER)
RIGHT
RIGHT
RIGHT
RIGHT
RIGHT
RIGHT

(LEFT
RIGHT

BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;

return INTEGER;
return INTEGER;
return INTEGER;

INTEGER)
INTEGER)
INTEGER)
INTEGER)
INTEGER)
INTEGER)

INTEGER;
INTEGER)

return
return
return
return
return
return

INTEGER;
INTEGER;
INTEGER;
INTEGER;
INTEGER;
INTEGER;

return INTEGER;

An implementation may provide additional predefined integer types.
It is recommended that the names of such additional types end
with INTEGER as in SHORTINTEGER
or
LONGINTEGER. The specification of each operator for the type universalinteger, or for

any additional predefined integer type, is obtained by replacing
INTEGER by the name of the type
in
the specification of the
corresponding operator of the type INTEGER, except for the
right operand of the exponentiating operator.

type SHORT_INTEGER is implementationdefined;
type SHORT_SHORT_INTEGER is implementation_defined;
The universal type universal_real is predefined.
type FLOAT is implementationdefined;
-- The predefined operators
-- function "="
-- function "/="
-- function "<"

(LEFT,
(LEFT,
(LEFT,

function

RIGHT
RIGHT
RIGHT

FLOAT)
FLOAT)
FLOAT)

return BOOLEAN;
return BOOLEAN;
return BOOLEAN;

"<="

(LEFT,

RIGHT

FLOAT)

return BOOLEAN;

-- function ">"
-- function ">="

(LEFT,
(LEFT,

RIGHT
RIGHT

FLOAT)
FLOAT)

return BOOLEAN;
return BOOLEAN;

(RIGHT

FLOAT)

return FLOAT;

(RIGHT
(RIGHT

FLOAT)
FLOAT)

return FLOAT;
return FLOAT;

function

"+"

-- function "-"
-- function "abs"
--

C-—2

for this type are as follows:

"+"

(LEFT,

RIGHT

FLOAT)

return FLOAT;

-- function "-"
-~ function "*"
-- function "/"

function

(LEFT,
(LEFT,
(LEFT,

RIGHT
RIGHT
RIGHT

FLOAT)
FLOAT)
FLOAT)

return FLOAT;
return FLOAT;
return FLOAT;

(LEFT

function

"**"

Predefined Language Environment

FLOAT;

RIGHT

INTEGER)

return FLOAT;

An implementation may provide additional predefined floating poin
types.

It is recommended that the names of such additional types

end with FLOAT as in SHORTFLOAT or LONGFLOAT.

The specificatio

of each operator for the type universalreal, or for any addition
predefined floating point type, is obtained by replacing FLOAT b
the name of the type in the specification of the corresponding
operator of the type FLOAT.

type LONGFLOAT is implementation_defined;

type LONGLONGFLOAT is implementation_defined;
In addition, the following operators are predefined for
universal types:
-- function "*"

--- function "*"
--- function "/"

(LEFT

RIGHT
(LEFT
RIGHT
(LEFT

:
:
:
:

universalinteger;

universalreal)
return universalreal,
universalreal;
universalinteger) return universalreal
universalreal;

-- The type universalfixed is predefined.
-- declared for this type are

The only operators

-~- function "*" (LEFT
: anyfixed_point_type;
—RIGHT : anyfixed_point_type)
—return universalfixed;
-- function "/" (LEFT
: anyfixed_point_type;
-RIGHT : anyfixedpointtype)
--

return universalfixed;

The following characters form the standard ASCII character set.
Character
literals corresponding to control characters are not

identifiers;

they are indicated in italics in this definition.

type CHARACTER is
(nul,
bs,
dle,
can,
7

soh,
ht,
dcli,
em,

StxX,
lf,
dc2,
sub,

etx,
vt,
dc3,
e@SC,

eot,
ff,
ac4,
fs,

eng,
Cr,
nak,
gs,

ack,
bel,
SO,
Si,
syn,
etb,
rs,
us,

‘,

rier,

fur

THT

‘Ss’,

msl,

'&!’,

‘rer

rc’,

ry’,

r4r

rity

ral

rif,

n/t,

‘OQ’,

‘1’,

‘2’,

‘3’,

ra’,

‘5’,

‘6’,

‘7y',

‘8’,

‘gr,

rs',

raf,

r<',

‘=!,

‘>!,

ror,

‘@’,

‘A’,

‘B’,

‘Cc’,

‘DD’,

‘EE’,

‘FEF’,

‘GCG’,

‘H’,

‘Tt’,

‘J’,

‘KK’,

‘L’,

‘mM’,

'N’,

‘OQ’,

‘Pp’,

‘OQ’,

‘R’,

‘Ss’,

‘tT’,

‘U’',

‘Vv’,

‘WwW’,

'xX’,

ry’,

‘2’,

‘{’,

‘j’,

cary

xr,

‘a’,

‘db’,

‘coc’,

‘d’,

‘e’,

‘ft’,

‘gg’,

'h’,

ri’,

nal,

‘k’,

‘l’,

‘m’,

‘nn’,

‘o’,

‘po’,

‘q’,

‘r’,

‘ss’,

‘t’,

‘ul’,

‘vl,

‘wl,

‘x’,

‘y’,

‘Zz’,

‘{’,

‘|’,

‘y’,

Pal,

del);

Predefined Language Environment

C-—3

for CHARACTER use

(0, 1, 2, 3, 4, 5,

128 ASCII character set without holes
., 125, 126, 127);

for CHARACTER’ SIZE use 8;
-- The predefined operators for the type CHARACTER are the same
-- as for any enumeration type.
15

package ASCII is
Control characters:

C-4

Other

characters:

Predefined Language Environment

CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER

=
i

constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant

nul;

soh;
SCX;

etx;
eot;
eng;
ack;
bel;
bs;
ht;

lf;
ll

NUL
SOH
STX
ETX
EOT
BENQ
ACK
BEL
BS
HT
LE
VT
BF
CR
SO
SI
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
KM
SUB
ESC
E'S
GS
RS
US
DEL

vt;
ff;

Cr;
SO;
Sil;
dle;
dcl;
dc2;
dc3;
dc4;
nak;
Syn;
eth;
can;
em;
sub;
eSC;
fs;
GS,
rs;
us;
del;

|
|

ole Ops He

:= /’!7;
:= /"/;

Q
~
~
~

a“ os

i
I!

;
:
Ps!;
:=
';°7;
:
:= ’@Q’;

ted

a
~

~
i]

:
:= ’%’;
:
, of;
:
;
:= ’

:= /~’;

~
“

constant CHARACTER

LCZ

constant CHARACTER

LCA

letters:

case

Lower

CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER
CHARACTER

constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant
constant

EXCLAM
QUOTATION
SHARP
DOLLAR
PERCENT
AMPERSAND
COLON
SEMICOLON
QUERY
ATSIGN
L_BRACKET
BACKSLASH
R_BRACKET
CIRCUMFLEX
UNDERLINE
GRAVE
L_BRACE
BAR
R_BRACE
TILDE

end ASCII;

-- Predefined subtypes:
subtype NATURAL is INTEGER range 0
subtype POSITIVE is INTEGER range 1

INTEGER’ LAST;
INTEGER’ LAST;

-- Predefined string type:
type STRING is array(POSITIVE range <>)
pragma PACK (STRING) ;

of CHARACTER;

-~- The predefined operators for this type are as follows:
Function
function
function
function
function
function

Won

RIGHT
RIGHT
RIGHT
RIGHT
RIGHT
RIGHT

" j="

Wen
Weon
Wn
wu

function "¢"
function "&"

function "&"
function "¢&"

(LEFT
RIGHT
(LEFT
RIGHT
(LEFT
RIGHT
(LEFT
RIGHT

STRING)
STRING)
STRING)
STRING)
STRING)
STRING)

STRING;
STRING)
CHARACTER;
STRING)
STRING;
CHARACTER)
CHARACTER;

return
return
return
return
return
return

BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;
BOOLEAN;

return STRING;
return STRING;
return STRING;

CHARACTER) return STRING;
Predefined Language Environment

C-—5

type DURATION is delta implementationdefined
range implementationdefined;
for DURATION’ SIZE use 32;
-- The predefined operators

for the type DURATION are the same

-- as for any fixed point type.
20

-- The predefined exceptions:
CONSTRAINTERROR : exception;

NUMERIC_ERROR

: exception;

STORAGEERROR

: exception;

PROGRAMERROR

TASKINGERROR

: exception;
: exception;

end STANDARD;

Certain aspects of the predefined entities cannot be completely described in

the languageitself. For example, although the enumeration type BOOLEAN
can be written showing the two enumeration literals FALSE and TRUE, the

short-circuit control forms cannot be expressed in the language.
Note:

The language definition predefines the following library units: 1
-

The package CALENDAR

(see 9.6)

The package SYSTEM

(see 13.7)

The package MACHINE_CODE (if provided)

(see 13.8)

The generic procedure UNCHECKED_DEALLOCATION

(see 13.10.1)

The generic function UNCHECKED_CONVERSION

(see 13.10.2)

The generic package SEQUENTIAL_IO

(see 14.2.3)

The generic package DIRECT_IO

(see 14.2.5)

The package TEXT_IO

(see 14.3.10)

The package IO_EXCEPTIONS

(see 14.5)

The package LOW_LEVEL_IO

(see 14.6)

1 See also Appendix G, AI-00355.
C-6

Predefined Language Environment

Appendix D

Glossary
This appendix is informative andis not part of the standard definition of the

Ada programming language. Italicized terms in the abbreviated descriptions
below either have glossary entries themselves or are described in entries for
related terms.
Absolute global symbol.
An absolute global symbol is a global symbol with a fixed numerical
value. The value is not relocatable; that is, it is not changed during
linking operations.
Accept statement.
See entry.

Accesstype.
A value of an access type (an access value) is either a null value, or a

value that designates an object created by an allocator. The designated

object can be read and updated via the access value. The definition of an
access type specifies the type of the objects designated by values of the
access type. See also collection.

Actual parameter.
See parameter.
Aggregate.
The evaluation of an aggregate yields a value of a composite type. The

value is specified by giving the value of each of the components. Either

positional association or named association may be used to indicate

which value is associated with which component.

Glossary

D-1

Allocator.

The evaluation of an allocator creates an object and returns a new access
value which designates the object.
Array type.
A value of an array type consists of components which areall of the

same subtype (and hence, of the same type). Each component is uniquely
distinguished by an index (for a one-dimensional array) or by a sequence
of indices (for a multidimensional array). Each index must be a value of
a discrete type and mustlie in the correct index range.

Assignment.
Assignmentis the operation that replaces the current value of a variable

by a new value. An assignment statement specifies a variable on theleft,

and on the right, an expression whose value is to be the new value of the
variable.
Asynchronous system trap.
An asynchronous system trap (AST) is a VAX interrupt mechanism
that is used by some VMSsystem services to transfer control to a
user-specified procedure when an asynchronousevent occurs during a
process’s execution. In VAX Ada,control can be passed to a task entry
that handles the event.
Attribute.

The evaluation of an attribute yields a predefined characteristic of a
namedentity; some attributes are functions.

Bit array.
A bit array is an array whose components are not byte aligned, yet
which is also not a bit string.
Bit string.
A bit string is any one-dimensional array of a discrete type whose
components occupy successive single bits.
Block statement.
A block statementis a single statement that may contain a sequence

of statements. It may also include a declarative part, and exception

handlers; their effects are local to the block statement.

D-2

Glossary

Body.
A body defines the execution of a subprogram, package,or task. A body
stub is a form of body that indicates that this execution is defined in a
separately compiled subunit.
Box.
A box is an Ada delimiter (<>) used to denote an undefined discrete

range for array types and generic formaltypes.

Collection.
A collection is the entire set of objects created by evaluation of allocators
for an access type.

Compilation unit.
A compilation unit is the declaration or the body of a program unit,
presented for compilation as an independent text. It is optionally
preceded by a context clause, naming other compilation units upon which
it depends by meansof one or more with clauses.
Component.
A componentis a value that is a part of a larger value, or an object that
is part of a larger object.
Composite type.
A composite type is one whose values have components. There are two
kinds of composite type: array types and record types.
Condition.
A VAX exception condition is a hardware- or software-detected event
that alters the normal flow of instruction execution.
Condition value.
A condition valueis a 32-bit value used to uniquely identify a VAX
exception condition.
Constant.

See object.
Contiguousarray.
A contiguous array is a VAX descriptor class. A contiguous array is one
in which the storage of the array components is allocated without any
separation between adjacent components.

Glossary

D-3

Constraint.

A constraint determines a subset of the values of a type. A value in that
subset satisfies the constraint.

Context clause.
See compilation unit.
Declaration.

A declaration associates an identifier (or some other notation) with an
entity. This association is in effect within a region of text called the
scope of the declaration. Within the scope of a declaration, there are
places whereit is possible to use the identifier to refer to the associated
declared entity. At such places the identifier is said to be a simple name
of the entity; the nameis said to denote the associated entity.
Declarative Part.

A declarative part is a sequence of declarations. It may also contain
related information such as subprogram bodies and representation
clauses.
Denote.
See declaration.

Derived Type.
A derived type is a type whose operations and valuesare replicas of
those of an existing type. The existing type is called the parent type of
the derived type.
Descriptor.
|
A descriptor is a VAX data structure used for parameter passing; the
descriptor contains the address, data type, and size of the parameter,
as well as other information neededto fully describe the data being
passed.
Designate.
See access type, task.

Direct visibility.
See visibility.

D-4

Glossary

Discrete Type.
A discrete type is a type which has an orderedsetof distinct values. The
discrete types are the enumeration and integer types. Discrete types are
used for indexing and iteration, and for choices in case statements and
record variants.
Discriminant.
A discriminant is a distinguished component of an object or value of a
record type. The subtypes of other components, or even their presence or
absence, may depend on the value of the discriminant.

Discriminant constraint.

A discriminant constraint on a record type or private type specifies a
value for each discriminant of the type.
Elaboration.
The elaboration of a declaration is the process by which the declaration
achievesits effect (such as creating an object); this process occurs during
program execution.
Entry.
An entry is used for communication between tasks. Externally, an entry

is called just as a subprogram iscalled; its internal behavioris specified
by one or more accept statements specifying the actions to be performed

whentheentry is called.

Enumeration type.
An enumeration type is a discrete type whose values are represented by
enumeration literals which are given explicitly in the type declaration.|
These enumeration literals are either identifiers or character literals.
Evaluation.

The evaluation of an expression is the process by which the value of the
expression is computed. This process occurs during program execution.
Exception.
An exception is an error situation which may arise during program

execution. To raise an exception is to abandon normal program execution
so as to signal that the error has taken place. An exception handler is a
portion of program text specifying a response to the exception. Execution
of such a program text is called handling the exception.

Glossary

D-5

Expanded name.
An expanded name denotes an entity which is declared immediately
within some construct. An expanded namehasthe form of a selected
component: the prefix denotes the construct (a program unit; or a block,
loop, or accept statement); the selector is the simple nameof the entity.
Expression.
An expression defines the computation of a value.
Fixed point type.
See real type.
Floating point type.
See real type.
Formal parameter.
See parameter.

Function.
See subprogram.
Generic unit.
A generic unit is a template either for a set of subprogramsor for a set

of packages. A subprogram or package created using the templateis
called an instance of the generic unit. A generic instantiation is the kind
of declaration that creates an instance. A generic unit is written as a
subprogram or package but with the specification prefixed by a generic

formal part which may declare generic formal parameters. A generic

formal parameteris either a type, a subprogram,or an object. A generic
unit is one of the kinds of program unit.

Global symbol.
A symbol defined in a VMS module (such as a source, object, or image
module) that is potentially available for reference by another module.
The VMSLinker resolves global symbols (that is, the linker matches
references with definitions).
Handler.
See exception.
Index.
See array type.

D-6

Glossary

Index constraint.

An index constraint for an array type specifies the lower and upper
bounds for each index range of the array type.
Indexed component.
An indexed component denotes a component in an array. It is a form of

name containing expressions which specify the values of the indices of

the array component. An indexed component mayalso denote an entry

in a family of entries.
Instance.
See generic unit.

instantiation.
An instantiation is the creation of a particular instance of a generic
unit. In other words, the template defined by the generic package or
subprogram is named, and all generic parameters are replaced by actual
parameters.

Integer type.
An integer type is a discrete type whose values represent all integer
numbers within a specific range.
Lexical element.
A lexical element is an identifier, a literal, a delimiter, or a comment.

Limited type.
A limited type is a type for which neither assignment nor the predefined

comparison for equality is implicitly declared. All task types are limited.

A private type can be defined to be limited. An equality operator can be

explicitly declared for a limited type.

Linker.

A system program that creates an executable program, called an image,
from one or more object modules produced by a language compiler or
assembler. The VMS Linker resolves external references between object
modules, acquires referenced library routines, service entry points, and
data for the image, and assigns virtual addresses to components of the
image.
Literal.

A literal represents a value literally, that is, by means of letters and

other characters. A literal is either a numeric literal, an enumeration

literal, a character literal, or a string literal.

Glossary

D-7

Membershiptest.
A membershiptest is a basic operation that indicates whether a given
value is contained in a given range or subtype.
Mode.
See parameter.
Model number.

A model numberis an exactly representable value of a real type.
Operations of a real type are defined in terms of operations on the model
numbers of the type. The properties of the model numbers andof their
operations are the minimal properties preserved by all implementations
of the real type.
Name.

A nameis a construct that stands for an entity: it is said that the name

denotes the entity, and that the entity is the meaning of the name. See
also declaration, prefix.

Named association.
A namedassociation specifies the association of an item with one or
more positions in a list, by namingthe positions.

Noncontiguousarray.
A noncontiguous array is a VAX descriptor class. A noncontiguous array
is one in which the storage of the array components maybeallocated
with a fixed, nonzero numberof bytes separating logically adjacent
components.

Object.
An object contains a value. A program creates an object either by

elaborating an object declaration or by evaluating an allocator. The

declaration or allocator specifies a type for the object: the object can only
contain values of that type.

Object module.
The binary output of a VMS language processor (such as an assembler,
or compiler), which is used as input to the VMS Linker.
Operation.
An operation is an elementary action associated with one or more types.
It is either implicitly declared by the declaration of the type, or it is a
subprogram that has a parameter or result of the type.

D-—8

Glossary

Operator.
An operator is an operation which has one or two operands. A unary
operator is written before an operand; a binary operator is written

between two operands. This notation is a special kind of function call.

An operator can be declared as a function. Many operators are implicitly
declared by the declaration of a type (for example, most type declarations

imply the declaration of the equality operator for values of the type).

Overloading.
An identifier can have several alternative meanings at a given point in
the program text: this property is called overloading. For example, an
overloaded enumeration literal can be an identifier that appears in the
definitions of two or more enumeration types. The effective meaning of
an overloaded identifier is determined by the context. Subprograms,
aggregates, allocators, and string literals can also be overloaded.

Packable.

A type is packable if storage for objects of the type can be aligned on an
arbitrary bit boundary.
Package.
A package specifies a group of logically related entities, such as types,
objects of those types, and subprograms with parameters of those types.
It is written as a package declaration and a package body. The package
declaration has a visible part, containing the declarations of all entities
that can be explicitly used outside the package. It may also have a

private part containing structural details that complete the specification
of the visible entities, but which are irrelevant to the user of the
package. The package body contains implementations of subprograms

(and possibly tasks as other packages) that have been specified in the
package declaration. A package is one of the kinds of program unit.

Parameter.

A parameteris one of the namedentities associated with a subprogram,
entry, or generic unit, and used to communicate with the corresponding
subprogram body, accept statement or generic body. A formal parameter

is an identifier used to denote the namedentity within the body.
An actual parameter is the particular entity associated with the

corresponding formal parameter by a subprogram call, entry call,

or generic instantiation. The mode of a formal parameter specifies
whetherthe associated actual parameter supplies a value for the formal
parameter, or the formal supplies a value for the actual parameter, or
both. The association of actual parameters with formal parameters can

Glossary

D-9

be specified by named associations, by positional associations, or by a
combination of these.
Parent type.

See derived type.
Positional association.

A positional association specifies the association of an item with a
position in a list, by using the same position in the text to specify the
item.

Pragma.
A pragma conveys information to the compiler.
Prefix.

A prefix is used as the first part of certain kinds of name. A prefix is
either a function call or a name.

Private part.

See package.
Private type.

A private type is a type whose structure and set of values are clearly
defined, but not directly available to the user of the type. A private type
is known only by its discriminants (if any) and by the set of operations
defined for it. A private type and its applicable operations are defined

in the visible part of a package, or in a generic formal part. Assignment,
equality, and inequality are also defined for private types, unless the
private type is limited.
Procedure.
See subprogram.

Program.
A program is composed of a number of compilation units, one of
which is a suwbprogram called the main program. Execution of the
program consists of execution of the main program, which may invoke
subprograms declared in the other compilation units of the program.
Program section.
A program section (psect) is a portion of a program with a given VMS
protection and set of storage managementattributes. Program sections
with the sameattributes are gathered by the VMS Linker to form an
imagesection.
D-10

Glossary

Program unit.
A program unit is any one of a generic unit, package, subprogram, or
task unit.
Psect.
See program section.
Qualified expression.
A qualified expression is an expression preceded by an indication of

its type or subtype. Such qualification is used when, in its absence,

the expression might be ambiguous (for example as a consequence of

overloading).

Raising an exception.
See exception.
Range.
A range is a contiguous set of values of a scalar type. A range is
specified by giving the lower and upper boundsfor the values. A value
in the range is said to belong to the range.
Range constraint.
A range constraint of a type specifies a range, and thereby determines
the subset of the values of the type that belong to the range.

Real type.
A real type is a type whose values represent approximations to the
real numbers. There are two kinds of real type: fixed point types are
specified by absolute error bound; floating point types are specified by
a relative error bound expressed as a numberof significant decimal
digits.
Record type.
A value of a record type consists of components which are usually of
different types or subtypes. For each component of a record value or
record object, the definition of the record type specifies an identifier that
uniquely determines the component within therecord.
Renaming declaration.
A renaming declaration declares another namefor an entity.

Glossary

D-11

Rendezvous.

A rendezvousis the interaction that occurs between two parallel tasks
when one task has called an entry of the other task, and a corresponding
accept statement is being executed by the other task on behalf of the
calling task.
Representation clause.

A representation clause directs the compiler in the selection of the
mapping of a type, an object, or a task onto features of the underlying
machine that executes a program. In somecases, representation clauses
completely specify the mapping; in other cases, they provide criteria for

choosing a mapping.

Satisfy.
See constraint, subtype.
Scalar type.
An object or value of a scalar type does not have components. A scalar
type is either a discrete type or a real type. The values of a scalar type
are ordered.

Scope.
See declaration.

Selected component.
A selected componentis a name consisting of a prefix and of an identifier
called the selector. Selected components are used to denote record
components, entries, and objects designated by access values; they are

also used as expanded names.

Selector.
See selected component.
Short circuit control form.

A short circuit control form is one of the reserved word pairs and then
and or else; each has the same precedence as a logical operator.
Simple name.
See declaration, name.

D-12

Glossary

Simple record.
A simplerecord type is one that does not have a variant part and in
which any constraint for each component and subcomponentis static.
A simple record subtype is either a simple record typeor static
constrained subtype of a record type (with discriminants) in which any
constraint for each component and subcomponentof the record type is
static.
Statement.

A statement specifies one or more actions to be performed during the
execution of a program.
Status value.

A status value is the condition value returned by a VMSroutine to
indicate whetheror not the routine completed successfully.
Subcomponent.
A subcomponentis either a component, or a component of another
subcomponent.
Subprogram.
A subprogram is either a procedure or a function. A procedure specifies
a sequence of actions and is invoked by a procedure call statement. A
function specifies a sequence of actions and also returns a value called
the result, and so a function call is an expression. A subprogram is
written as a subprogram declaration, which specifies its name, formal
parameters, and (for a function) its result; and a subprogram body which
specifies the sequence of actions. The subprogram call specifies the
actual parameters that are to be associated with the formal parameters.
A subprogram is one of the kinds of program unit.

Subtype.
A subtype of a type characterizes a subset of the values of the type. The

subset is determined by a constraint on the type. Each value in the set
of values of a subtype belongs to the subtype andsatisfies the constraint
determining the subtype.

Subunit.
See body.

Glossary

D-13

Task.

A task operates in parallel with other parts of the program. It is written

as a task specification (which specifies the name of the task and the

names and formal parameters of its entries), and a task body which

defines its execution. A task unit is one of the kinds of program unit.
A task type is a type that permits the subsequent declaration of any
numberof similar tasks of the type. A value of a task type is said to
designate a task.

Type.
A type characterizes both a set of values, and a set of operations
applicable to those values. A type definition is a language construct that
defines a type. A particular type is either an access type, an array type,
a private type, a record type, a scalar type, or a task type.
Use clause.

A use clause achieves direct visibility of declarations that appear in the
visible parts of named packages.
Variable.
See object.

Variant part.
A variant part of a record specifies alternative record components,
depending on a discriminant of the record. Each value of the
discriminant establishes a particular alternative of the variant part.
Visibility.
At a given point in a program text, the declaration of an entity with
a certain identifier is said to be visible if the entity is an acceptable
meaning for an occurrence at that point of the identifier. The declaration
is visible by selection at the place of the selector in a selected component
or at the place of the namein a named association. Otherwise, the
declaration is directly visible, that is, if the identifier alone has that
meaning.

Visible part.
See package.
With clause.
See compilation unit.

D-14

Glossary

Appendix E

Syntax Summary
NOTE
This syntax summary is not part of the standard definition of the

Ada programming language.

format_effector

2.3
identifier ::=

letter {[underline]

letterordigit

letterordigit}

::= letter

letter ::= upper_caseletter

digit
|

lower_caseletter

2.4
numericliteral

::= decimalliteral

| basedliteral

2.4.1:
decimalliteral

::= integer

[.integer]

integer ::= digit {[underline]
exponent

::= E

[+]

integer

[exponent]

digit}

E - integer

Syntax Summary

E-1

2.4.2:
basedliteral ::=
base # basedinteger [.basedinteger]

[exponent]

base ::= integer
basedinteger ::=
extendeddigit

extendeddigit

{[underline]

::= digit

extended_digit}

letter

2.5
characterliteral ::= ‘’graphic_character’

2.6
stringliteral

::= "{graphic_character}"

2.8
pragma ::=
pragma identifier

[(argument_association

{, argument_association}) ];

argumentassociation ::=

[argument_identifier =

name
expression

| |
V V

[argument_identifier =

3.1
basicdeclaration ::=
object_declaration

| numberdeclaration

| taskdeclaration

| genericdeclaration

|
|

typedeclaration
| subtypedeclaration
subprogramdeclaration | packagedeclaration

|
|

exceptiondeclaration

renamingdeclaration

|
|

genericinstantiation

deferred_constant_declaration

3.2
objectdeclaration

identifierlist

::=
:

| identifierlist :

[constant] subtypeindication
[:= expression];

[constant] constrainedarraydefinition
[:= expression];

numberdeclaration

::=

identifierlist ::=

identifier {, identifier}

identifierlist : constant := universal_static_expression;

E-2

Syntax Summary

3.3.1:
typedeclaration ::=
full_typedeclaration
| incompletetypedeclaration | privatetypedeclaration
fulltypedeclaration

::=

type identifier [discriminantpart]

is typedefinition;

type definition ::=
|

enumerationtypedefinition | integertypedefinition
realtypedefinition
| arraytypedefinition

derivedtypedefinition

| recordtypedefinition

| accesstypedefinition

3.3.2:
subtypedeclaration

::=

subtype identifier is subtypeindication;

subtypeindication ::=

typemark

::= typename

[constraint]

subtypename

constraint ::=
rangeconstraint

floatingpointconstraint

| fixed_pointconstraint | index_constraint
| discriminantconstraint

3.4

derivedtypedefinition ::= new subtypeindication

3.5
rangeconstraint ::=
range

::=

range range

rangeattribute

| simpleexpression .. simpleexpression

3.5.1:
enumerationtypedefinition ::=

(enumerationliteralspecification
{, enumerationliteralspecification})

enumerationliteralspecification ::=
enumerationliteral ::=

enumerationliteral

identifier | characterliteral

3.5.4:
integertypedefinition ::=

range_constraint

Syntax Summary

E-3

3.5.6:
realtypedefinition

::=

floatingpointconstraint | fixed_pointconstraint

3.5.7:
floatingpointconstraint ::=
floatingaccuracydefinition
floatingaccuracydefinition

[rangeconstraint]

::=

digits staticsimpleexpression

3.5.9:
fixedpointconstraint

::=

fixedaccuracydefinition [range_constraint]

fixedaccuracydefinition ::=
delta static_simpleexpression

3.6
arraytypedefinition ::=
unconstrainedarraydefinition
| constrainedarraydefinition
unconstrainedarraydefinition ::=
array (indexsubtypedefinition
{, indexsubtypedefinition})
componentsubtypeindication
constrainedarraydefinition

::=

array indexconstraint of component_subtypeindication

indexsubtypedefinition ::= typemark range <>

indexconstraint ::=

(discreterange {, discreterange})

discreterange ::= discretesubtypeindication

range

3.7
recordtypedefinition ::=
record

componentlist
end record
componentlist ::=
componentdeclaration {componentdeclaration}
| {componentdeclaration} variantpart
|
null;
componentdeclaration ::=
identifierlist : component subtypedefinition

[:= expression];

componentsubtypedefinition ::=

E-4

Syntax Summary

subtypeindication

3.7.1:
discriminantpart

::=

(discriminantspecification {; discriminantspecification} )

discriminantspecification ::=
identifierlist : typemark

[:= expression]

3.7.2:
discriminantconstraint ::=
(discriminantassociation {,
discriminantassociation ::=
[discriminantsimplename {|
expression

discriminant_association})
discriminant_simplename} =>]

3.7.3:
variantpart ::=
case discriminantsimplename is
variant
{variant }
end case;
variant ::=
when choice

choice}

componentlist

choice ::= simpleexpression
|

discreterange

others

component_simplename

3.8
accesstypedefinition ::= access subtypeindication

3.8.1:
incompletetypedeclaration ::=
type identifier [discriminantpart];

3.9
declarativepart

::=

{basicdeclarativeitem}

{laterdeclarativeitem}

| useclause

| genericinstantiation

Syntax Summary

E-5

body

:3= properbody

properbody ::=
subprogram_body

bodystub

package_body

task_body

4.1
name ::= simplename
|
|
|

characterliteral
indexedcomponent
selected_component

|
|
|

operatorsymbol
slice
attribute

simplename ::= identifier

prefix ::= name | function_call
4.1.1:
indexedcomponent

::= prefix(expression {,

expression})

4.1.2:
slice

::= prefix(discreterange)

4.1.3:
selectedcomponent

::= prefix.selector

selector ::= simplename
| characterliteral | operatorsymbol

all

4.1.4:
attribute ::= prefix’attributedesignator

attributedesignator
simplename

[ (universalstatic_expression) ]

4.3
aggregate ::=
(component association

componentassociation
[choice {| choice} => ]

expression

component_association})

4.4
expression ::=
|
|

E-6

Syntax Summary

relation
relation
relation

{and relation}
{or relation}
{xor relation}

|
|

relation
relation

{and then relation}
{or else relation}

relation ::=
Simpleexpression
| simpleexpression
|

simpleexpression

[relationaloperator simpleexpression]
[not] in range
[not]

in typemark

Simpleexpression ::=

[unaryaddingoperator] term {binaryaddingoperator term}

term ::= factor {multiplyingoperator factor}
factor ::= primary

[** primary]

primary ::=
numericliteral

| null

| abs primary

aggregate

| not primary

stringliteral

qualifiedexpression

(expression)

4.5
logicaloperator

::=

relationaloperator

and | or | xor
::=

binaryaddingoperator

unaryaddingoperator

::=

multiplyingoperator

::=

/= |<

+
+
*

|
|

highestprecedenceoperator

::=

| mod |
**

rem

abs

not

4.6
typeconversion

::= typemark (expression)

4./
qualifiedexpression ::=
typemark’ (expression)

typemark’ aggregate

allocator

::=

new subtypeindication

| new qualifiedexpression

5.1

sequenceofstatements
statement

::= statement {statement }

::=

{label} simplestatement

{label} compound_statement

simplestatement ::= nullstatement
|
|
|
|

assignmentstatement
exitstatement
gotostatement
delaystatement

| raisestatement

|
|
|
|

procedurecallstatement
returnstatement
entrycallstatement
abortstatement

| code_statement

Syntax Summary

E-7

::= <<label_simplename>>

nullstatement

::= null;

9.2
assignmentstatement ::=
variablename := expression;

9.3
ifstatement ::=
if condition then
sequenceofstatements
{elsif condition then
sequenceofstatements}
[else

sequenceofstatements]
end if;

condition ::= booleanexpression

9.4
casestatement ::=
case expression is
casestatementalternative
{casestatementalternative}
end case;
casestatement alternative ::=
when choice

choice

}

sequenceofstatements

5.5
loopstatement ::=
[loopsimplename: ]
[iterationscheme]

loop

sequenceofstatements

end loop [loopsimplename];
iterationscheme ::= while condition
| for loopparameterspecification

E-8

Syntax Summary

loopparameterspecification ::=
identifier in [reverse] discreterange

5.6
blockstatement ::=
[blocksimplename: ]
[declare
declarativepart]
begin
sequenceofstatements
[exception
exceptionhandler
{exceptionhandler} ]
end

[blocksimplename];

5.7
exit statement

exit

::=

[loopname]

[when condition];

5.8
returnstatement

::= return

[expression];

5.9
gotostatement

::= goto labelname;

6.1
subprogramdeclaration ::= subprogram_specification;
subprogramspecification ::=
procedure identifier [formalpart]
| function designator
[formal_part]
designator ::= identifier
operatorsymbol
formal part

return typemark

operatorsymbol

::= stringliteral

::=

(parameterspecification {; parameterspecification})

parameterspecification ::=
identifierlist : mode typemark
mode

::=

[in]

in out

[:= expression]

out

Syntax Summary

E-9

6.3
subprogrambody

::=

subprogramspecification is
[declarativepart]
begin
sequenceofstatements
[exception
_

exceptionHandler

{exceptionhandler}]
end [designator];

6.4
procedurecallstatement

procedurename

::=

[actualparameterpart];

functioncall ::=
functionname factualparameterpart]
actualparameterpart ::=
(parameterassociation
parameterassociation

::=

[formalparameter =>]

parameterassociation})

actualparameter

formalparameter ::= parametersimplename
actualparameter ::=
expression | variablename

| type_mark(variable_name)

7.1
packagedeclaration ::= packagespecification;
packagespecification ::=
package identifier is
{basicdeclarativeitem}
[private

{basicdeclarativeitem}]

end [packagesimplename]

E-10

Syntax Summary

packagebody

::=

package body packagesimplename is
[declarativepart]
[begin
sequenceofstatements
[exception

exceptionhandler
{exceptionhandler}]]
end [packagesimplename];

1.4
privatetypedeclaration ::=

private;
type identifier [discriminant_part] is [limited]

deferredconstantdeclaration ::=
identifierlist : constant typemark;

8.4
useclause

::= use packagename

packagename};

8.5
renamingdeclaration ::=
identifier : typemark

| identifier : exception

renames objectname;

renames exceptionname;

| package identifier
renames packagename;
| subprogram_specification renames subprogramor_entry_name;

9.1
taskdeclaration ::= task_specification;
taskspecification ::=
task [type] identifier [is
{entrydeclaration}
{representationclause}

end [tasksimplename] ]

taskbody ::=
task body tasksimplename is
[declarativepart]
begin
sequenceofstatements
[exception
exceptionhandler
{exceptionhandler} ]

end [tasksimplename];

9.5
entrydeclaration ::=
entry identifier

[(discreterange)]

[formalpart];

Syntax Summary

E-11

entrycallstatement ::=
entryname [actual_parameter_part];
acceptstatement ::=
accept entrysimplename [(entryindex)]
sequenceofstatements
end [entrysimplename]];

[formalpart]

entryindex ::= expression

9.6
delaystatement

::= delay simpleexpression;

9.7
selectstatement ::= selectivewait
| conditionalentrycall | timed_entrycall

9.7.1:
selectivewait

::=

select

selectalternative

{or
select alternative}
[else

sequenceofstatements]
end select;

selectalternative ::=
[when condition =>]

selectivewaitalternative

selectivewaitalternative ::= acceptalternative
| delayalternative | terminatealternative
acceptalternative
acceptstatement

::=
[sequenceofstatements]

delayalternative
delaystatement

::=
[sequenceofstatements]

terminatealternative ::= terminate;

9.7.2:
conditionalentrycall
select

::=

entrycallstatement

[sequenceofstatements]
else
sequenceofstatements
end select;
:

E-12

Syntax Summary

[do

9.7.3:
timedentrycall ::=
select
entrycallstatement
[sequenceofstatements]
or
delayalternative
end select;

9.10
abortstatement

::= abort task_name {,

task_name};

10.1
compilation ::= {compilationunit}
compilationunit
contextclause libraryunit

| contextclause secondaryunit

libraryunit ::=

subprogramdeclaration

| genericdeclaration
|

subprogram_body

packagedeclaration

| generic_instantiation

secondaryunit ::= libraryunit_body | subunit
libraryunit_body ::= subprogram_body

| package_body

10.1.1:
contextclause ::= {withclause {useclause}}
withclause ::=
with unitsimplename

unitsimplename};

1 0.2

bodystub ::=
subprogramspecification is separate;
| package body package_simplename is separate;
| task body task_simplename is separate;
subunit

::= separate

(parent_unit_name)

properbody

11.1
exceptiondeclaration ::= identifierlist : exception;

11.2
exceptionhandler ::=

when exceptionchoice

exception_choice}

sequenceofstatements
exceptionchoice ::= exception_name

others

Syntax Summary

E-13

11.3
raisestatement

::= raise

[exceptionname];

genericdeclaration ::= genericspecification;
genericspecification ::=
genericformalpart subprogram_specification
| genericformalpart packagespecification
genericformalpart

::=

generic {genericparameterdeclaration}

genericparameterdeclaration ::=
identifierlist

[in

[out]]

typemark

[:= expression];

| type identifier is generictypedefinition;
| privatetypedeclaration
| with subprogramspecification [is name];
|

with subprogramspecification

[is <>];

12.3
genericinstantiation ::=

package identifier is
new genericpackagename [genericactualpart];
| procedure identifier is
new genericprocedurename [generic_actual_part];
| function designator is
new generic_function_name [genericactualpart];

genericactualpart ::=

(genericassociation {,

genericassociation})

genericassociation ::=
[genericformalparameter =>]

genericactualparameter

genericformalparameter ::=
parametersimplename

operatorsymbol

genericactualparameter ::= expression | variablename
| subprogramname | entry_name | typemark

13.1
representationclause ::=

typerepresentationclause

E-14

Syntax Summary

addressclause

typerepresentationclause ::= length_clause
| enumerationrepresentationclause
| record_representation_clause

13.2
lengthclause ::= for attribute use simpleexpression;

13.2b
mainstorageoption ::
[WORKINGSTORAGE =>] static_simpleexpression
| [TOP_GUARD =>] static_simpleexpression

13.3
enumerationrepresentationclause ::=
for typesimplename use aggregate;

13.4
recordrepresentationclause ::=
for typesimplename use
record [alignmentclause]
{componentclause}
end record;
alignmentclause ::= at mod staticsimpleexpression;
componentclause ::=

component_name at staticsimpleexpression
range staticrange;

13.5
addressclause

::=

for simplename use at simpleexpression;

13.8
codestatement

::= typemark’ record_aggregate;

13.9a
externaldesignator ::= [EXTERNAL =>] external_symbol
externalsymbol ::= identifier

internalname ::=
|

[INTERNAL =>]

stringliteral

simplename

operationsymbol -- Can be used only for
-- IMPORTFUNCTION

Syntax Summary

E-15

13.9a.1.1
classname ::= UBS | UBSB | UBA | S | SB | A | NCA
mechanism ::= mechanism_name | (mechanism_name {, mechanism_name})

mechanismname ::=

VALUE
| REFERENCE
| DESCRIPTOR [(([CLASS =>]

parametertypes ::= null

class_name) ]

| typemark {, typemark}

B (pragma TITLE)
titlingoption ::=

[TITLE =>]

stringliteral

(SUBTITLE =>] stringliteral

Syntax Cross Reference
In the list given below each syntactic category is followed by the section
number whereit is defined. For example:
addingoperator

4.5

In addition, each syntactic category is followed by the namesof other
categories in whose definition it appears. For example, adding_operator
appearsin the definition of simple_expression:
adding_operator
simple_expression

4.5
4.4

An ellipsis (... ) is used when the syntactic category is not defined by a
syntax rule. For example:
lower_case_letter

All uses of parentheses are combined in the term “()”. The italicized prefixes
used with some terms have been deleted here.
abort

abort_statement

9.10

abs

Lae
4.4
4.5

simple_statement

factor
highest_precedence_operator

E-16

a
9.10
5.1

accept_statement

9.5

accept_alternative
selective_wait_alternative

9.7.1
9.7.1

Syntax Summary

accept_statement

accept_alternative
compound_statement

9.5
9.7.1
5.1

access
access_type_definition

3.8

access_type_definition
generic_type_definition
type_definition

3.8
12.1
3.3.1

actual_parameter
parameter_association

6.4
6.4

actual_parameter_part

6.4
9.5
6.4
6.4

entry_call_statement

function_call
procedure_call_statement
address_clause

representation_clause

aggregate
code_statement
enumeration_representation_clause

primary

qualified_expression

alignment_clause
record_representation_clause
all
selector

allocator
primary
and

13.5
13.1

4.3
13.8
13.3
4.4
4.7
13.4
13.4
4.1.3
4.8
4.4

expression
logical_operator

4.4
4.5

argument_association

pragma

2.8
2.8

constrained_array_definition
unconstrained_array_definition

3.6
3.6

array

array_type_definition

3.6
12.1
3.3.1

assignment_statement
simple_statement

5.2
5.1

generic_type_definition
type_definition

Syntax Summary

E-17

at
address_clause

tae
13.5

attribute
length_clause

4.1.4
13.2

attribute_designator
attribute

4.1.4
4.1.4

base

2.4.2
2.4.2

alignment_clause
component_clause

name
range

based_literal

4.1
3.5

based_integer

2.4.2

based_literal
numeric_literal

2.4.2
2.4

basic_character

2.1

basic_declaration
basic_declarative_item

3.1
3.9

basic_declarative_item

3.9

basic_graphic_character
basic_character
graphic_character

2.1
2.1
2.1

based_literal

declarative_part
package_specification

begin

block_statement

package_body
subprogram_body
task_body

2.4.2

3.9
7.1

5.6

7.1
6.3
9.1

binary_adding_operator
simple_expression

4.5
4.4

block_statement

5.6

body

3.9

compound_statement

body

E-18

13.4
13.4

later_declarative_item

body_stub
package_body
task_body

Syntax Summary

5.1

3.9

ae
10.2
7.1
9.1

10.2
3.9

body_stub
body
case

variant_part

case_statement

5.4
3.7.3

case-statement
compound_statement

5.4
5.1

case_statement_alternative

case_statement

5.4
5.4

character_literal
enumeration_literal
name
selector

2.5
3.5.1
4.1
4.1.3

choice

3.7.3
5.4
4.3
3.7.3

case_statement_alternative

component_association

variant
class_name

13.9a.1.1

code_statement

13.8
5.1

compilation

10.1

compilation_unit

10.1
10.1

component_association

4.3
4.3

component_clause
record_representation_clause

13.4
13.4

component_declaration
component_list

3.7
3.7

component_list

3.7
3.7
3.7.3

simple_statement

compilation
aggregate

record_type_definition

variant

component_subtype_definition

3.7
3.7

compound_statement

5.1
o.1

component_declaration
statement

Syntax Summary

E-19

condition
exit_statement
if_statement
iteration_scheme
select_alternative

5.3
5.7
5.3
5.5
9.7.1

conditional_entry_call
select_statement

9.7.2
9.7

constant
deferred_constant_declaration
number_declaration

Lae
7.4
3.2

constrained_array_definition

3.6

object_declaration

3.2

object_declaration

array_type_definition

3.6

constraint

3.3.2

context_clause

10.1.1

decimal_literal
numeric_literal

2.4.1
2.4

declarative_part

3.9

subtype_indication

compilation_unit

block_statement

package_body
subprogram_body

task_body

3.3.2
10.1

5.6

7.1
6.3
9.1

declare
block_statement

Lae
5.6

deferred_constant_declaration
basic_declaration

7.4
3.1

delay

delay_statement

delay_alternative

selective_wait_alternative

timed_entry_call

delay_statement
delay_alternative
simple_statement
delta

E-20

3.2

fixed_accuracy_definition
generic_type_definition

Syntax Summary

9.6

9.7.1
9.7.1

9.7.3

9.6
9.7.1
5.1
Lae

3.5.9
12.1

derived_type_definition
type_definition

3.4
3.3.1

designator
generic_instantiation
subprogram_body
subprogram_specification

6.1
12.3
6.3
6.1

digit

letter_or_digit

2.1
2.4.2
2.4.1
2.3

floating_accuracy_definition
generic_type_definition

3.5.7
12.1

basic_graphic_character
extended_digit

integer
digits

discrete_range
choice

entry_declaration

index_constraint
loop_parameter_specification
slice

3.6
3.7.3
9.5
3.6
5.5
4.1.2

discriminant_association
discriminant_constraint

3.7.2
3.7.2

discriminant_constraint
constraint

3.7.2
3.3.2

discriminant_part

3.7.1
3.3.1
3.8.1
7.4

full_type_declaration
incomplete_type_declaration
private_type_declaration

discriminant_part

3.7.1
3.7.1

accept_statement

9.5

exponent

2.4.1

conditional_entry_call
expression
selective_wait

9.7.2
4.4
5.3
9.7.1

if_statement

5.3

discriminant_specification

do
E
else

if_statement

elsif

Syntax Summary

E-21

end
accept_statement

9.5

if_statement

5.3

block_statement
case_statement
conditional_entry_call

5.6
5.4
9.7.2

loop_statement
package_body
package_specification
record_representation_clause
record_type_definition
selective_wait
subprogram_body
task_body

3.0
7.1
7.1
13.4
3.7
9.7.1
6.3
9.1

task_specification

9.7.3
3.7.3

entry_declaration

9.5

entry_call_statement
conditional_entry_call
simple_statement
timed_entry_call

9.5
9.7.2
5.1
9.7.3

entry_declaration
task_specification

9.5
9.1

entry_index
accept_statement

9.5
9.5

enumeration_literal
enumeration_literal_specification

3.5.1
3.5.1

entry

enumeration_literal_specification

enumeration_type_definition

bee

3.5.1

enumeration_representation_clause

13.3

enumeration_type_definition
type_definition

3.5.1
3.3.1

type_representation_clause

exception

13.1

Lae

block_statement
exception_declaration

5.6
11.1

task_body

9.1

package_body
renamingdeclaration
subprogram_body

E-22

9.1

timed_entry_call
variant_part

Syntax Summary

7.1
8.5
6.3

exception_choice
exception_handler

11.2
11.2

exception_declaration
basic_declaration

11.1
3.1

exception_handler
block_statement

package_body
subprogram_body
task_body

11.2
5.6
7.1
6.3
9.1

exit_statement

5.1

exit

exit_statement

5.7
5.1

exponent
based_literal
decimal_literal

2.4.1
2.4.2
2.4.1

expression

4.4
6.4
2.8
5.2
4.1.4
5.4
4.3
3.7
5.3
3.7.2
3.7.1
9.5
12.3
12.1
4.1.1
3.2
3.2
6.1
4.4
4.7
5.8
4.6

simple_statement

actual_parameter

argument_association

assignment_statement
attribute_designator
case_statement

component_association
component_declaration
condition
discriminant_association
discriminant_specification
entry_index
generic_actual_parameter

generic_parameter_declaration

indexed_component
number_declaration
object_declaration
parameter_specification
primary
qualified_expression
return_statement
type_conversion

extended_digit

based_integer

2.4.2
2.4.2

external_designator

13.9a

external_symbol

13.9a

Syntax Summary

E-23

factor
term

fixed_accuracy_definition
fixed_point_constraint
fixed_point_constraint
constraint

real_type_definition

3.5.9
3.5.9
3.5.9

3.3.2

3.5.6

floating_accuracy_definition

3.5.7

floating_point_constraint
constraint
real_type_definition

3.5.7
3.3.2
3.5.6

for

ae
13.5
13.3

floating_point_constraint

address_clause
enumeration_representation_clause

iteration_scheme
length_clause
record_representation_clause

3.5.7

5.5
13.2
13.4

formal_parameter

6.4

formal_part
accept_statement
entry_declaration
subprogram_specification

6.1
9.5
9.5
6.1

format_effector
basic_character

wae
2.1

full_type_declaration
type_declaration

3.3.1
3.3.1

parameter_association

function

generic_instantiation
subprogram_specification

function_call
prefix
primary
generic

6.4

Lae

12.3
6.1
6.4
4.1
4.4
ae

generic_formal_part

12.1

generic_actual_parameter

12.3

generic_actual_part
|
generic_instantiation

12.3
12.3

generic_association

E-~24

4.4
4.4

Syntax Summary

12.3

generic_association
generic_actual_part

12.3
12.3

generic_declaration
library_unit

12.1
3.1
3.9
10.1

generic_formal_parameter
generic_association

12.3
12.3

generic_formal_part

12.1
12.1

generic_instantiation

12.3
3.1
3.9
10.1

basic_declaration
later_declarative_item

generic_specification

basic_declaration
later_declarative_item

library_unit

generic_parameter_declaration
generic_formal_part

12.1
12.1

generic_specification
generic_declaration

12.1
12.1

generic_type_definition

generic_parameter_declaration

12.1
12.1

goto_statement

5.9

goto
goto_statement

simple_statement

5.9
5.1

graphic_character
character_literal
string_literal

2.1
2.5
2.6

highest_precedence_operator

4.5

Syntax Summary

E-25

identifier
argument_association

designator
entry_declaration

enumeration_literal

full_type_declaration

generic_instantiation

generic_parameter_declaration

identifier_list

incomplete_type_declaration
loop_parameter_specification
package_specification
pragma
private_type_declaration
renamingdeclaration
simple_name
subprogram_specification
subtype_declaration
task_specification

6.1
9.5

3.5.1

3.3.1
12.3

12.1

3.2

3.8.1
5.5
7.1
2.8
7.4
8.5
4.1
6.1
3.3.2
9.1

identifier_list
component_declaration
deferred_constant_declaration
discriminant_specification
exception_declaration
generic_parameter_declaration
number_declaration
object_declaration
parameter_specification

3.2
3.7
7.4
3.7.1
11.1
12.1
3.2
3.2
6.1

if_statement

Lae
5.3

if_statement
compound_statement

5.3
5.1

import_export_pragma_name

13.9a

generic_parameter_declaration
loop_parameter_specification
mode
relation

wee

12.1
5.5
6.1
4.4

incomplete_type_declaration
type_declaration

3.8.1
3.3.1

index_constraint

3.6

constrained_array_definition
constraint

E-26

2.3
2.8

Syntax Summary

3.6
3.3.2

index_subtype_definition
unconstrained_array_definition

3.6
3.6

indexed_component
name

4.1.1
4.1

integer

2.4.1
2.4.2
2.4.1
2.4.1

base

decimal_literal
exponent

integer_type_definition

3.5.4
3.3.1

internal_name

13.9a

type_definition

body_stub

case_statement
full_type_declaration
generic_instantiation

generic_parameter_declaration
package_body
package_specification
private_type_declaration

subprogram_body
subtype_declaration
task_body
task_specification

variant_part

10.2
5.4
3.3.1
12.3
12.1
7.1
7.1
7.4
6.3
3.3.2
9.1
9.1
3.7.3

iteration_scheme

loop_statement

5.5
0.0

label
statement

5.1
5.1

later_declarative_item
declarative_part

3.9
3.9

length_clause

13.2
13.1

letter

2.3
2.4.2
2.3
2.3

type_representation_clause
extended_digit
identifier

letter_or_digit
letter_or_digit
identifier

2.3
2.3

library_unit
compilation_unit

10.1
10.1

Syntax Summary

E-27

library_unit_body

10.1

limited
private_type_declaration

wee
7.4

logical_operator

4.5

loop

loop_statement

wae
5.5

loop_parameter_specification
iteration_scheme

5.5
5.5

loop_statement
compound_statement

5.5
5.1

lower_case_letter
graphic_character
letter

a
2.1
2.3

main_storage_option

13.2b

mechanism

13.9a.1.1

mechanism_name
mod
alignment_clause
multiplying_operator

13.9a.1.1
oe
13.4
4.5

mode

6.1
6.1

secondary_unit

parameter_specification

multiplyingoperator
term

E-28

Syntax Summary

10.1

4.5
4.4

use_clause

4.1
9.10
6.4
2.8
5.2
13.4
9.5
11.2
5.7
6.4
12.3
12.3
12.1
5.9
4.1
4.4
6.4
11.3
8.5
10.2
3.3.2
8.4

allocator
derived_type_definition
generic_instantiation

4.8
3.4
12.3

factor
highest_precedence_operator

4.4
4.5
4.4

component_list
null_statement

3.7
5.1
4.4

name

abort_statement

actual_parameter

argument_association
assignment_statement

component_clause
entry_call_statement
exception_choice

exit_statement
function_call
generic_actual_parameter
generic_instantiation

generic_parameter_declaration

goto_statement

prefix
primary
procedure_call_statement
raise_statement
renamingdeclaration
subunit
type_mark
new

not

relation
null

primary

null_statement

simple_statement

5.1
5.1

number_declaration
basic_declaration

3.2
3.1

numeric_literal
primary

2.4
4.4

object_declaration

3.2
3.1

basic_declaration

Syntax Summary

E-29

constrained_array_definition
unconstrained_array_definition

operator_symbol
designator
generic_formal_parameter
name
selector
or

expression
logical_operator
selective_wait
timed_entry_call

other_special_character

graphic_character

others
choice
exception_choice
out

generic_parameter_declaration
mode

package
body_stub

generic_instantiation

package_body
package_specification
renaming declaration

3.6
3.6
6.1
6.1
12.3
4.1.3
4.4
4.5
9.7.1
9.7.3
2.1
3.7.3
11.2
12.1
6.1
- 10.2
12.3
7.1
7.1
8.5

package_body
library_unit_body
proper_body

7.1
10.1
3.9

package_declaration
basic_declaration
later_declarative_item
library_unit

V7.1
3.1
3.9
10.1

package_specification
generic_specification
package_declaration

7.1
12.1
7.1

parameter_association

6.4
6.4

parameter_types

13.9a.1.1

actual_parameter_part

Syntax Summary

parameter_specification

6.1
6.1

pragma

2.8

pragma
pragma

2.8

formal_part

prefix

attribute
indexed_component
selected_component
slice

primary
factor

private
package_specification

private_type_declaration

generic_parameter_declaration

type_declaration
procedure

generic_instantiation

subprogram_specification

4.1
4.1.4
4.1.1
4.1.3
4.1.2
4.4
4.4
7.1
7.4
7.4
12.1
3.3.1
12.3
6.1

procedure_call_statement
simple_statement

6.4
o.1

proper_body
body
subunit

3.9
3.9
10.2

qualified_expression
allocator
primary

4.7
4.8
4,4

raise
raise_statement

11.3

raise_statement

11.3
5.1

range

3.5
13.4
3.6
3.5
4.4

simple_statement
component_clause
discrete_range

range_constraint
relation

Syntax Summary

E-31

range

component_clause
generic_type_definition

index_subtype_definition

range_constraint
range_constraint

constraint
fixed_point_constraint

floating_point_constraint

integer_type_definition

3.6

3.5
3.5

3.3.2
3.5.9
3.5.7

3.5.4

real_type_definition
type_definition

3.5.6
3.3.1

record
record_representation_clause
record_type_definition

Lae
13.4
3.7

record_representation_clause
type_representation_clause

13.4
13.1

record_type_definition
type_definition

3.7
3.3.1

relation

4.4

expression

4.4

relational_operator
relation

4.5
4.4

rem

_
4.5

multiplyingoperator

renames
renamingdeclaration |

..
8.5

renamingdeclaration
basic_declaration

8.5
3.1

representation_clause

basic_declarative_item
task_specification

return

return_statement
subprogram_specification

E-~32

13.4
12.1

13.1

3.9
9.1
we

5.8
6.1

return_statement
simple_statement

5.8
5.1

reverse
loop_parameter_specification

..
5.5

Syntax Summary

secondary_unit
compilation_unit
select
conditional_entry_call
selective_wait
timed_entry_call

10.1
10.1
9.7.2
9.7.1
9.7.3

select_alternative
selective_wait

9.7.1
9.7.1

select_statement
compound_statement

9.7
5.1

selected_component
name

4.1.3
4.1

selective_wait
select_statement

9.7.1
9.7

selective_wait_alternative
select_alternative

9.7.1
9.7.1

selector
selected_component

4.1.3
4.1.3

separate

body_stub
subunit

10.2
10.2

sequence_of_statements

5.1
9.7.1
9.5
5.6
5.4
9.7.2
9.7.1
11.2
5.3
5.5
7.1
9.7.1
6.3
9.1
9.7.3

accept_alternative
accept_statement

block_statement

case_statement_alternative

conditional_entry_call
delay_alternative
exception_handler
if_statement
loop_statement
package_body
selective_wait

subprogram_body
task_body
timed_entry_call

Syntax Summary

E-33

simple_expression

address_clause

alignment_clause
choice

component_clause
delay_statement

fixed_accuracy_definition
floating_accuracy_definition
length_clause
range
relation
simple_name
accept_statement

address_clause
attribute_designator

block_statement
body_stub

choice
discriminant_association
enumeration_representation_clause
formal_parameter
generic_formal_parameter

label
loop_statement
name
package_body
package_specification
record_representation_clause
selector
task_body
task_specification

variant_part
with_clause

simple_statement

4.4
13.5
13.4
3.7.3
13.4
9.6
3.5.9
3.5.7
13.2
3.5
4.1
9.5
13.5
4.1.4
5.6
10.2
3.7.3
3.7.2
13.3
6.4
12.3
5.1
5.5
4.1
7.1
7.1
13.4
4.1.3
9.1
9.1
3.7.3
10.1.1

statement

5.1
5.1

name

4.1.2
4.1

space_character

basic_graphic_character

2.1

special_character
basic_graphic_character

2.1

statement

sequence_of_statements

Syntax Summary

5.1
o.1

string_literal
operator_symbol
primary

2.6
6.1
4.4

subprogram_body
library_unit
library_unit_body
proper_body

6.3
10.1
10.1
3.9

subprogram_declaration
basic_declaration
later_declarative_item

6.1
3.1
3.9
10.1

subprogram_specification
body_stub
generic_parameter_declaration
generic_specification
renaming_declaration
subprogram_body

6.1
10.2
12.1
12.1
8.5
6.3
6.1

library_unit

subprogram_declaration

subtype
subtype_declaration

3.3.2

subtype_declaration
basic_declaration

3.3.2
3.1

subtype_indication

3.3.2
3.8
4.8
3.7
3.6
3.4
3.6
3.2
3.3.2
3.6

access_type_definition

allocator
component_subtype_definition
constrained_array_definition
derived_type_definition
discrete_range

object_declaration
subtype_declaration

unconstrained_array_definition
subunit
secondary_unit

task

body_stub
task_body

task_specification
task_body
proper_body

10.2
10.1
10.2
9.1
9.1
9.1
3.9

Syntax Summary

E-35

task_declaration
basic_declaration
later_declarative_item

9.1
3.1
3.9

task_specification

9.1

term

4.4

task_declaration

simple_expression

4.4

terminate
terminate_alternative

Lee
9.7.1

terminate_alternative
selective_wait_alternative

9.7.1
9.7.1

then

expression

if_statement

4.4
5.3

timed_entry_call

9.7.3

titling_option

B (pragma TITLE)

select_statement

type

9.7

wee

full_type_declaration

3.3.1

task_specification

9.1

generic_parameter_declaration
incomplete_type_declaration
private_type_declaration

12.1
3.8.1
1.4

type_conversion
primary

4.6
4.4

type_declaration

3.3.1

type_definition
full_type_declaration

3.3.1
3.3.1

basic_declaration

E-36

9.1

Syntax Summary

3.1

type_mark
actual_parameter
code_statement
deferred_constant_declaration
discriminant_specification
generic_actual_parameter
generic_parameter_declaration
index_subtype_definition
parameter_specification
qualified_expression
relation
renamingdeclaration

subprogram_specification
subtype_indication

type_conversion

3.3.2
6.4
13.8
TA
3.7.1
12.3
12.1
3.6
6.1
4.7
4.4
8.5
6.1
3.3.2
4.6

type_representation_clause

13.1
13.1

unary_adding_operator
simple_expression

4.5
4.4

unconstrained_array_definition

3.6
3.6

representation_clause

array_type_definition

underline
based_integer
identifier
integer

upper_case_letter
basic_graphic_character
letter
use
address_clause

enumeration_representation_clause
length_clause
record_representation_clause
use_clause

2.4.2
2.3
2.4.1
2.1
2.3
13.5
13.3
13.2
13.4
8.4

use_clause
basic_declarative_item
context_clause

8.4
3.9
10.1.1
3.9

variant
variant_part

3.7.3
3.7.3

variant_part

3.7.3
3.7

later_declarative_item

component_list

Syntax Summary

E-37

when

exit_statement
select_alternative
variant

5.4
11.2
5.7
9.7.1
3.7.3

iteration_scheme

5.9

generic_parameter_declaration

12.1
10.1.1

case_statement_alternative

exception_handler

while
with

with_clause
with_clause
context_clause

xor

#
&

expression
logical_operator

4.4
4.5

string_literal

2.6

based_literal

2.4.2

binary_adding_operator

4.5

attribute
character_literal
code_statement

4.1.4
2.5
13.8
4.7

qualified_expression

E-38

10.1.1
10.1.1

Syntax Summary

()

unconstrained_array_definition

9.5
6.4
6.4
4.3
4.1.4
3.7.2
3.7.1
9.5
3.5.1
6.1
12.3
12.1
3.6
4.1.1
2.8
4.4
4.7
4.1.2
10.2
4.6
3.6

multiplyingoperator

4.5

factor
highest_precedence_operator

4.4
4.5

binary_adding_operator

4.5
2.4.1
4.5

accept_statement

actual_parameter
actual_parameter_part

aggregate

attribute_designator

discriminant_constraint

discriminant_part
entry_declaration
enumeration_type_definition
formal_part
generic_actual_part
generic_type_definition

index_constraint

indexed_component

pragma
primary
qualified_expression
slice
subunit
type_conversion

exponent

unary_adding_operator

Syntax Summary

E-39

abort_statement

actual_parameter_part

aggregate
discriminant_constraint
enumeration_type_definition

generic_actual_part

identifier_list
index_constraint
indexed_component
pragma

unconstrained_array_definition

use_clause
with_clause

binary_adding_operator

9.10
6.4
4.3
3.7.2
3.5.1
12.3
3.2
3.6
4.1.1
2.8
3.6
8.4
10.1.1

exponent

unary_adding_operator

4.5
2.4.1
4.5

based_literal
decimal_literal
selected_component

2.4.2
2.4.1
4.1.3

range

3.5

multiplyingoperator

4.5

relational_operator

4.5

block_statement

5.6
3.7
TA
3.7.1
11.1
12.1
5.5
3.2
3.2
6.1
8.5

component_declaration
deferred_constant_declaration
discriminant_specification
exception_declaration
generic_parameter_declaration
loop_statement
number_declaration
object_declaration
parameter_specification
renamingdeclaration

Syntax Summary

assignment_statement

component_declaration

discriminant_specification

generic_parameter_declaration
number_declaration
object_declaration
parameter_specification
abort_statement
accept_statement

address_clause

alignment_clause
assignment_statement

block_statement

body_stub

case_statement
code_statement
component_clause

component_declaration

component_list
conditional_entry_call
deferred_constant_declaration

delay_statement
discriminant_part

entry_call_statement

entry_declaration

enumeration_representation_clause
exception_declaration

exit_statement
formal_part

full_type_declaration

generic_declaration
generic_instantiation
generic_parameter_declaration
goto_statement
if_statement

incomplete_type_declaration

5.2
3.7
3.7.1
12.1
3.2
3.2
6.1
9.10
9.5
13.5
13.4
5.2
5.6
10.2
5.4
13.8
13.4
3.7
3.7
9.7.2
7.4
9.6
3.7.1
9.5
9.5
13.3
11.1
5.7
6.1
3.3.1
12.1
12.3
12.1
5.9
5.3
3.8.1

Syntax Summary

E-41

length_clause
loop_statement
null_statement
number_declaration
object_declaration
package_body
package_declaration
pragma
private_type_declaration
procedure_call_statement

13.2
5.5
5.1
3.2
3.2
7.1
7.1
2.8
7.4
6.4

raise_statement
record_representation_clause
renamingdeclaration

task_body
task_declaration
terminate_alternative
timed_entry_call
use_clause
variant_part
with_clause

11.3
13.4
8.5
5.8
9.7.1
6.3
6.1
3.3.2
9.1
9.1
9.7.1
9.7.3
8.4
3.7.3
10.1.1

relational_operator

45,

label

5.1

relational_operator

45,

generic_parameter_declaration

12.1
12.1

return_statement

selective_wait

subprogram_body
subprogram_declaration
subtype_declaration

generic_type_definition

E-42

index_subtype_definition

3.6

relational_operator

4.5

Syntax Summary

argument_association

component_association
discriminant_association
exception_handler
generic_association
parameter_association

select_alternative
variant

2.8
5.4
4.3
3.7.2
11.2
12.3
6.4
9.7.1
3.7.3

relational_operator

4.5

relational_operator

4.5

label

5.1

case_statement_alternative

5.4
4.3
3.7.2
11.2
3.7.3

case_statement_alternative

component_association

discriminant_association
exception_handler
variant

Syntax Summary

E—43

Appendix F

Implementation-Dependent Characteristics
NOTE
This appendix is not part of the standard definition of the Ada
programming language.
This appendix summarizes the implementation-dependent characteristics of
VAX Ada by presenting the following:

F.1

Lists of the VAX Ada pragmasandattributes.

The specification of the package SYSTEM.

Therestrictions on representation clauses and unchecked type
conversions.
.
|

The conventions for names denoting implementation-dependent
componentsin record representation clauses.

The interpretation of expressions in addressclauses.

The implementation-dependent characteristics of the input-output
packages.

Other implementation-dependent characteristics.

Implementation-Dependent Pragmas
VAX Ada provides the following pragmas, which are defined elsewhere in
the text. In addition, VAX Ada restricts the predefined language pragmas
INLINE and INTERFACE. See Annex B for a descriptive pragma summary.
e

ASTENTRY(see 9.12a).

EXPORTEXCEPTION(see 13.9a.3.2).

EXPORT_FUNCTION(see 13.9a.1.4).
Implementation-Dependent Characteristics

F—1

EXPORT_OBJECT (see 13.9a.2.2).

EXPORT_PROCEDURE(see 13.9a.1.4).

EXPORT_VALUED_PROCEDURE(see 13.9a.1.4).

IDENT (see Annex B).

IMPORT_EXCEPTION(see 13.9a.3.1).

IMPORT_FUNCTION(see 13.9a.1.1).

IMPORT_OBJECT(see 13.9a.2.1).

IMPORT_PROCEDURE(see 13.9a.1.1).

IMPORT_VALUED_PROCEDURE(see 13.9a.1.1).

INLINE_GENERIC (see 12.1a).

LONG_FLOAT(see 3.5.7a).

MAIN_STORAGE(see 13.2b).

PSECT_OBJECT (see 13.9a.2.3).

SHARE_GENERIC (see 12.1b).

SUPPRESS_ALL(see 11.7).

TASK_STORAGE(see 13.2a).

TIME_SLICE(see 9.8a).

TITLE (see Annex B).

VOLATILE (see 9.11).

F.2 Implementation-Dependent Attributes
VAX Ada provides the following attributes, which are defined elsewhere in
the text. See Annex A for a descriptive attribute summary.

F-2

AST_ENTRY(see 9.12a).

=6BIT (see 18.7.2).

MACHINE_SIZE (see 13.7.2).

e¢

NULL_PARAMETER(see 13.9a.1-3).

TYPE_CLASS(see 13.7a.2).

Implementation-Dependent Characteristics

F.3 Specification of the Package System
package SYSTEM is
type NAME

(VAXVMS,

VAXELN) ;

for NAME use

(1,

SYSTEMNAME

: constant NAME := VAX_VMS;

STORAGEUNIT

MEMORYSIZE

2);

: constant := 8;
: constant

MAX_INT

: constant

FINEDELTA

: constant

MININT
MAXDIGITS
MAXMANTISSA
TICK

: constant
: constant
: constant

:= 2**31-1;

:= -—(2**31);
:= 33;
:= 31;

:= 2.0**(-31);

: constant := 10.0%**(-2);

subtype PRIORITY is INTEGER range 0
--

15;

Address type

type ADDRESS is private;
ADDRESS_ZERO : constant ADDRESS;
function
function
function
function

"+"
"+"
"-"
"-"

(LEFT
(LEFT
(LEFT
(LEFT

:
:
:
:

ADDRESS;
INTEGER;
ADDRESS;
ADDRESS;

RIGHT
RIGHT
RIGHT
RIGHT

:
:
:
:

INTEGER)
ADDRESS)
ADDRESS)
INTEGER)

return
return
return
return

function "="

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

function

"/="

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

function

"<"

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

function "<="
function ">"

(LEFT,
(LEFT,

RIGHT
RIGHT

:
:

ADDRESS)
ADDRESS)

return BOOLEAN;
return BOOLEAN;

function

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

----

">="

ADDRESS;
ADDRESS;
INTEGER;
ADDRESS;

Note that because ADDRESS is a private type
the functions "=" and "/=" are already available and
do not have to be explicitly defined
generic
type TARGET is private;

function FETCHFROMADDRESS (A : ADDRESS) return TARGET;

generic
type TARGET is private;

procedure ASSIGNTOADDRESS

---

ADDRESS;

TARGET);

VAX Ada floating point type declarations for the VAX
hardware floating point data types

type F_FLOAT is implementation_defined;
type DFLOAT is implementation_defined;
type GFLOAT is implementation_defined;
type HFLOAT is implementation_defined;

Implementation-Dependent Characteristics

F-3

type TYPECLASS is (TYPECLASSENUMERATION,
TYPECLASSINTEGER,
TYPECLASSFIXEDPOINT,
TYPECLASSFLOATINGPOINT,
TYPECLASSARRAY,
TYPECLASSRECORD,
TYPECLASSACCESS,
TYPECLASSTASK,
TYPECLASSADDRESS) ;
--

AST handler type

type ASTHANDLER is limitedprivate;
NOASTHANDLER

constant ASTHANDLER;

Non-Ada exception

NON_ADAERROR : exception;
--

VAX hardware-oriented types and functions

type

pragma

BITARRAY is array (INTEGER range <>) of BOOLEAN;
PACK(BITARRAY) ;

subtype BITARRAY8

is BITARRAY

type UNSIGNEDBYTE

is range 0

7);

subtype BITARRAY16 is BITARRAY (0 .. 15);
subtype BITARRAY32 is BITARRAY (0 .. 31);
subtype BITARRAY64 is BITARRAY (0 .. 63);
for

UNSIGNEDBYTE’SIZE

function
function
function
function

"not"
"and"
"or"
"xor"

(LEFT
(LEFT,
(LEFT,
(LEFT,

.. 255;

use 8;

RIGHT
RIGHT
RIGHT

: UNSIGNEDBYTE)
: UNSIGNEDBYTE)
: UNSIGNEDBYTE)
: UNSIGNEDBYTE)

return
return
return
return

UNSIGNEDBYTE;
UNSIGNEDBYTE;
UNSIGNEDBYTE;
UNSIGNEDBYTE;

function TOUNSIGNEDBYTE (X : BITARRAY8) return UNSIGNEDBYTE;
function TOBITARRAY8 (X : UNSIGNEDBYTE) return BITARRAY8;
type UNSIGNEDBYTEARRAY is array

(INTEGER range <>)

type UNSIGNEDWORD

65535;

for

is range 0

UNSIGNEDWORD’SIZE

function
function
function
function

"not"
"and"
"or"
"xor"

(LEFT
(LEFT,
(LEFT,
(LEFT,

use 16;

RIGHT
RIGHT
RIGHT

: UNSIGNEDWORD)
: UNSIGNEDWORD)
: UNSIGNEDWORD)
: UNSIGNEDWORD)

return
return
return
return

of UNSIGNEDBYTE;

UNSIGNEDWORD;
UNSIGNEDWORD;
UNSIGNEDWORD;
UNSIGNEDWORD;

function TOUNSIGNEDWORD (X : BITARRAY16) return UNSIGNEDWORD;
function TOBITARRAY16 (X : UNSIGNEDWORD) return BITARRAY16;
type UNSIGNEDWORDARRAY is array

(INTEGER range <>)

type UNSIGNEDLONGWORD is range MININT .. MAX_INT;

for UNSIGNEDLONGWORD’ SIZE use 32;

F—4

Implementation-Dependent Characteristics

of UNSIGNEDWORD;

function "not"
function "and"
function "or"

function "xor"

(LEFT
(LEFT a
(LEFT,

RIGHT
RIGHT

(LEFT, RIGHT

UNSIGNEDLONGWORD) return UNSIGNEDLONGWORD;
UNSIGNEDLONGWORD) return UNSIGNEDLONGWORD;
UNSIGNEDLONGWORD) return UNSIGNEDLONGWORD;
UNSIGNEDLONGWORD) return UNSIGNEDLONGWORD;

(xX
BITARRAY32)
return UNSIGNEDLONGWORD;
function TOBITARRAY32 (X : UNSIGNEDLONGWORD) return BITARRAY32;
function TO_UNSIGNEDLONGWORD

type UNSIGNEDLONGWORDARRAY is
array

(INTEGER range <>) of UNSIGNEDLONGWORD;

type UNSIGNEDQUADWORD is record

LO
UNSIGNED_LONGWORD;
Ll
UNSIGNEDLONGWORD;
end record;
for UNSIGNEDQUADWORD’ SIZE use 64;

function
function
function
function

"not"
"and"
"or"
"xor"

(LEFT
(LEFT,
(LEFT,
(LEFT,

RIGHT
RIGHT
RIGHT

UNSIGNEDQUADWORD)
UNSIGNEDQUADWORD)
UNSIGNEDQUADWORD)
UNSIGNEDQUADWORD)

return
return
return
return

UNSIGNEDQUADWORD;
UNSIGNEDQUADWORD;
UNSIGNEDQUADWORD;
UNSIGNEDQUADWORD;

TOUNSIGNEDQUADWORD (X : BITARRAY64)
return UNSIGNEDQUADWORD;
function TOBITARRAY64 (X : UNSIGNEDQUADWORD) return BITARRAY64;
function

type UNSIGNEDQUADWORDARRAY is

(INTEGER range <>) of UNSIGNEDQUADWORD;
function TOADDRESS
(X
INTEGER)
return ADDRESS;
function TOADDRESS
return ADDRESS;
(X
UNSIGNEDLONGWORD)
function TOADDRESS
(X
universalinteger)
return ADDRESS;
array

function TO INTEGER
function TOUNSIGNEDLONGWORD
function

(X : ADDRESS)
(X : ADDRESS)

TO_UNSIGNED_LONGWORD (X >: ASTHANDLER)

return INTEGER;
return UNSIGNEDLONGWORD;
return UNSIGNEDLONGWORD;

‘e

Qk
Qk
Qe
Qk
Qk
Qk
Dkk
Qe
Qk

PRP PRP PPP

UNSIGNED1 is UNSIGNEDLONGWORD range
UNSIGNED2 is UNSIGNED_LONGWORD range
UNSIGNED3 is UNSIGNEDLONGWORD range
UNSIGNED4 is UNSIGNEDLONGWORD range
UNSIGNED5 is UNSIGNEDLONGWORD range
UNSIGNED6 is UNSIGNEDLONGWORD range
UNSIGNED_7 is UNSIGNEDLONGWORD range
UNSIGNED8 is UNSIGNEDLONGWORD range
UNSIGNED9 is UNSIGNEDLONGWORD range
UNSIGNED10 is UNSIGNEDLONGWORD range
UNSIGNED11 is UNSIGNEDLONGWORD range
UNSIGNED12 is UNSIGNED_LONGWORD range
UNSIGNED13 is UNSIGNEDLONGWORD range
UNSIGNED14 is UNSIGNEDLONGWORD range
UNSIGNED15 is UNSIGNEDLONGWORD range

WO DMDIKHDUBWNE

subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype
subtype

OOOO OOOOoOOOMOOoOlClOUOlUlcNOCUULwO

Conventional names for static subtypes of type UNSIGNEDLONGWORD

2**10-1;

2**11-1;
2**12-1;
2**13-1;
2**14-1;
2**15-1;

Implementation-Dependent Characteristics

F—5

subtype UNSIGNED_17 is UNSIGNEDLONGWORD range
subtype UNSIGNED18 is UNSIGNEDLONGWORD range

subtype UNSIGNED19 is UNSIGNED_LONGWORD range
subtype UNSIGNED20 is UNSIGNEDLONGWORD range
subtype UNSIGNED21 is UNSIGNEDLONGWORD range
subtype UNSIGNED22 is UNSIGNEDLONGWORD range

subtype UNSIGNED23 is UNSIGNEDLONGWORD range

subtype
subtype
subtype
subtype

UNSIGNED24
UNSIGNED25
UNSIGNED26
UNSIGNED27

is
is
is
is

UNSIGNEDLONGWORD
UNSIGNEDLONGWORD
UNSIGNEDLONGWORD
UNSIGNEDLONGWORD

range
range
range
range

subtype UNSIGNED28 is UNSIGNEDLONGWORD range

subtype UNSIGNED29 is UNSIGNEDLONGWORD range

subtype UNSIGNED30 is UNSIGNEDLONGWORD range

subtype UNSIGNED31 is UNSIGNEDLONGWORD range

ooooo oo ooo o0o0o0o0 0 oO

subtype UNSIGNED16 is UNSIGNEDLONGWORD range

2**16-1;
2**17-1;
2**18-1;
2**19-1;
2**20-1;
2**21-1;
2**22-1;
2**23-1;
2**24-1;
2**25-1;
2**26-1;
2**27-1;
2**28-1;
2**29-1;
2**30-1;
2**31-1;

Function for obtaining global symbol values
function IMPORTVALUE

(SYMBOL

STRING)

return UNSIGNEDLONGWORD;

VAX device and process register operations
function
return
function
return
function
return

READREGISTER (SOURCE
UNSIGNEDBYTE;
READREGISTER (SOURCE
UNSIGNEDWORD;
READREGISTER (SOURCE
UNSIGNEDLONGWORD;

procedure WRITEREGISTER (SOURCE
TARGET
procedure WRITEREGISTER (SOURCE
TARGET
procedure WRITEREGISTER (SOURCE
TARGET

UNSIGNEDBYTE)
UNSIGNEDWORD)
UNSIGNEDLONGWORD)

UNSIGNEDBYTE;
out UNSIGNEDBYTE) ;
UNSIGNEDWORD;
out UNSIGNEDWORD) ;
UNSIGNEDLONGWORD;
out UNSIGNEDLONGWORD) ;

function MFPR (REGNUMBER : INTEGER) return UNSIGNEDLONGWORD;
procedure MTPR (REGNUMBER : INTEGER;
SOURCE

UNSIGNEDLONGWORD) ;

VAX interlocked-instruction procedures

procedure CLEAR_INTERLOCKED (BIT
in out BOOLEAN;
OLDVALUE : out BOOLEAN) ;
procedure SETINTERLOCKED
(BIT
in out BOOLEAN;
OLDVALUE

type ALIGNEDWORD is
record

VALUE

SHORTINTEGER;

end record;

for ALIGNEDWORD use
record
at mod 2;
end record;

F-6

Implementation-Dependent Characteristics

out BOOLEAN) ;

procedure ADDINTERLOCKED

(ADDEND
AUGEND
SIGN

: in
SHORTINTEGER;
: in out ALIGNEDWORD;
>: out
INTEGER) ;

type INSQSTATUS is (OKNOTFIRST, FAILNOLOCK, OKFIRST);
type REMQSTATUS is (OKNOTEMPTY, FAILNOLOCK,
OKEMPTY,

FAILWASEMPTY);

procedure INSQHI

(ITEM
HEADER
STATUS

procedure REMOQHI

(HEADER : in
ADDRESS;
ITEM
: out ADDRESS;
STATUS : out REMQSTATUS);

procedure INSQTI

(ITEM
HEADER
STATUS

procedure REMQTI

(HEADER : in
ADDRESS;
ITEM
: out ADDRESS;
STATUS : out REMQSTATUS);

:
:
:

in
ADDRESS;
in
ADDRESS;
out INSQSTATUS) ;

in
ADDRESS;
in
ADDRESS;
out INSQSTATUS);

private
-- Not shown
end SYSTEM;

F.4 Restrictions on Representation Clauses
The representation clauses allowed in VAX Ada are length, enumeration,
record representation, and address clauses.
In VAX Ada, a representation clause for a generic formal type or a type
that depends on a generic formal type is not allowed. In addition, a
representation clause for a composite type that has a component or
subcomponent of a generic formal type or a type derived from a generic
formal type is not allowed.

F.5 Restrictions on Unchecked Type Conversions
VAX Ada supports the generic function UNCHECKED_CONVERSIONwith
the following restrictions on the class of types involved:
e

The actual subtype corresponding to the formal type TARGET must not
be an unconstrained array type.

Implementation-Dependent Characteristics

F—7

The actual subtype corresponding to the formal type TARGET must not
be an unconstrained type with discriminants.

Further, when the target type is a type with discriminants, the value resulting from a call of the conversion function resulting from an instantiation of
UNCHECKED_CONVERSIONis checked to ensure that the discriminants
satisfy the constraints of the actual subtype.
If the size of the source value is greater than thesize of the target subtype,
then the high order bits of the value are ignored (truncated); if the size of
the source valueis less than the size of the target subtype, then the valueis
extended with zero bits to form the result value.

F.6 Conventions for Implementation-Generated Names
Denoting Implementation-Dependent Components in
Record Representation Clauses
VAX Ada does not allocate implementation-dependent components in
records.

F.7 Interpretation of Expressions Appearing in Address
Clauses

Expressions appearing in address clauses must be of the type ADDRESS
defined in the package SYSTEM (see 13.7a.1 and F.3). In VAX Ada, values
of type SYSTEM.ADDRESSareinterpreted as virtual addresses in the VAX
address space.
VAX Ada allows address clauses for objects (see 13.5).
VAX Ada does not support interrupts as defined in section 13.5.1. VAX Ada
does provide the pragma AST_ENTRY and the AST_ENTRYattribute as
alternative mechanismsfor handling asynchronousinterrupts from the VMS
operating system (see 9.12a).

F-8

Implementation-Dependent Characteristics

F.8 Implementation-Dependent Characteristics of
Input-Output Packages
The VAX Ada predefined packages andtheir operations are implemented
using VMS Record Management Services (RMS)file organizations and
facilities. To give users the maximum benefit of the underlying VMS RMS
input-output facilities, VAX Ada provides packages in addition to the
packages SEQUENTIAL_IO, DIRECT_IO, TEXT_IO, and IO_EXCEPTIONS,
and VAX Ada accepts VMS RMSFile Definition Language (FDL) statements
in form strings. The following sections summarize the implementationdependent characteristics of the VAX Ada input-output packages. The VAX
Ada Run-Time Reference Manual discusses these characteristics in more
detail.

F.8.1

Additional VAX Ada Input-Output Packages
In addition to the language-defined input-output packages (SEQUENTIAL_
IO, DIRECT_IO, and TEXT_IO), VAX Ada provides the following inputoutput packages:
e

RELATIVE_IO (see 14.2a.3).

INDEXED_IO (see 14.2a.5).

SEQUENTIAL_MIXED_IO(see 14.2b.4).

DIRECT_MIXED_IO (see 14.2b.6).

RELATIVE_MIXED_IO (see 14.2b.8).

e¢

INDEXEDMIXEDIO (see 14.2b.10).

VAX Ada does not provide the package LOW_LEVEL_IO.

F.8.2

Auxiliary Input-Output Exceptions
VAX Ada defines the exceptions needed by the packages RELATIVE_IO,
INDEXED_IO, RELATIVE_MIXED_IO, and INDEXED_MIXED_IOin the
package AUX_IO_EXCEPTIONS(see 14.5a).

Implementation-Dependent Characteristics

F-—-9

F.8.3

Interpretation of the FORM Parameter
The value of the FORM parameter for the OPEN and CREATEproceduresof
each input-output package may be a string whose valueis interpreted as a
sequence of statements of the VAX Record Management Services (RMS)File
Definition Language (FDL), or it may be a string whosevalueis interpreted
as the nameof an external file containing FDL statements.
The use of the FORM parameteris described for each input-output package
in chapter 14. For information on the default FORM parameters for each
VAX Ada input-output package and for information on using the FORM
parameter to specify external file attributes, see the VAX Ada Run-Time
Reference Manual. For information on FDL, see the Guide to VMS File
Applications and the VMSFile Definition Language Facility Manual.

F.8.4

Implementation-Dependent Input-Output Error Conditions
As specified in section 14.4, VAX Adaraises the following language-defined
exceptions for error conditions that occur during input-output operations:
STATUS_ERROR, MODE_ERROR, NAME_ERROR, USE_ERROR, END_
ERROR, DATA_ERROR, and LAYOUT_ERROR.In addition, VAX Ada raises
the following exceptions for relative and indexed input-output operations:
LOCK_ERROR, EXISTENCE_ERROR, and KEY_ERROR. VAX Ada does not
raise the language-defined exception DEVICE_ERROR;device-related error
conditions cause the exception USE_ERRORtoberaised.
The exception USE_ERRORis raised underthe following conditions:

F-10

Ifthe capacity of the external file has been exceeded.

In all CREATEoperations if the mode specified is IN_FILE.

In all CREATEoperationsif the file attributes specified by the FORM
parameter are not supported by the package.

In all CREATE, OPEN, DELETE, and RESEToperationsif, for the

specified mode, the environment does not support the operation for an
external file.

In all NAMEoperationsif the file has no name.

In the WRITEoperations on relative or indexedfiles if the element in
the position indicated has already been written.

Inthe DELETE_ELEMENT operations on relative and indexedfiles if
the current element is undefined at the start of the operation.

In the UPDATEoperations on indexedfiles if the current elementis
undefined or if the specified key violates the external file attributes.

Implementation-Dependent Characteristics

In the SET_LINE_LENGTH and SET_PAGE_LENGTHoperations on
text files if the lengths specified are inappropriate for the externalfile.

e¢

In text files if an operation is attempted that is not possible for reasons
that depend on characteristics of the external file.

The exception NAME_ERRORisraised as specified in section 14.4: by a
call of a CREATE or OPENprocedureif the string given for the NAME
parameter does not allow the identification of an external file. In VAX Ada,
the value of a NAME parameter can be a string that denotes a VMSfile
specification or a VMSlogical name(in either case, the string names an
externalfile). For a CREATE procedure, the value of a NAME parameter
can also be a null string, in which case it names a temporary external
file that is deleted when the main program exits. The VAX Ada Run-Time
Reference Manual explains the naming of external files in more detail.

F.9 Other Implementation Characteristics
Implementation characteristics relating to the definition of a main program,
various numeric ranges, and implementation limits are summarized in the
following sections.

F.9.1

Definition of a Main Program
A main program can be a library unit subprogram underthe following
conditions:
e

Ifit is a procedure with no formal parameters. In this case, the status
returned to the VMS environment upon normal completion of the
procedureis the value 1.

Ifitis a function with no formal parameters whose returned valueis of a
discrete type. In this case, the status returned to the VMS environment
upon normal completion of the function is the function value.

If it is a procedure declared with the pragma EXPORT_VALUED_
PROCEDURE,and it has one formal out parameter that is of a discrete
type. In this case, the status returned to the VMS environment upon
normal completion of the procedure is the value ofthe first (and only)
parameter.

Note that when a main function or a main procedure declared with the
pragma EXPORT_VALUED_PROCEDUREreturns a discrete value whose
size is less than 32 bits, the value is zero- or sign-extended as appropriate.
Implementation-Dependent Characteristics

F—11

F.9.2

Values of Integer Attributes
The ranges of values for integer types declared in the package STANDARD
are as follows:
|
|
SHORT_SHORT_INTEGER

—128 .. 127

SHORT_INTEGER

—32768 .. 32767

INTEGER

—2147483648 .. 2147483647

For the packages DIRECT_IO, RELATIVE_IO, SEQUENTIAL_MIXED_
IO, DIRECT_MIXED_IO, RELATIVE_MIXED_IO, INDEXED_MIXED_IO,
and TEXT_IO, the ranges of values for the types COUNT and POSITIVE_
COUNTareasfollows:
COUNT

0 .. 2147483647

POSITIVE_COUNT

1 .. 2147483647

For the package TEXT_IO, the range of values for the type FIELD is as
follows:
FIELD

F.9.3

0 .. 2147483647

Values of Floating Point Attributes

Attribute

F_floating value and approximate decimal equivalent
(where applicable)

DIGITS

MANTISSA

EMAX

EPSILON
approximately

16#0.1000_000#e—4
9.53674E-07

SMALL
approximately

16#0.8000_000#e-21
2.58494E—26

LARGE
approximately

16#0.FFFF_F80#e+21
1.93428E+25

SAFE_EMAX

127

SAFE_SMALL
approximately

16#0.1000_000#e—-31
2.93874E-39

SAFE_LARGE
approximately

16#0.7FFF_FC0#e+32
1.70141E+38

F-12

Implementation-Dependent Characteristics

Attribute

F_floating value and approximate decimal equivalent
(where applicable)

FIRST
approximately

—16#0.7FFF_FF8#e+32
—1.70141E+38

LAST

16#0.7FFF_FF8#e+32
1.70141E+38

approximately

MACHINE_RADIX

MACHINE_MANTISSA

MACHINE_EMAX

127

MACHINE_EMIN

—127

MACHINE_ROUNDS

True

MACHINE_OVERFLOWS

True

Attribute

D_floating value and approximate decimal equivalent
(where applicable)

DIGITS

MANTISSA

EMAX

124

EPSILON
approximately

16#0.4000_0000_0000_000#e—7
9.3132257461548E-10

SMALL
approximately

16#0.8000_0000_0000_000#e—-31
2.3509887016446E-38

LARGE
approximately

16#0.FFFF_FFFE_0000_000#e+31
2.1267647922655E+37

SAFE_EMAX

127

SAFE_SMALL
approximately

16#0.1000_0000_0000_000#e—31
2.9387358770557E-—39

SAFELARGE
approximately

16#0.7FFF_FFFF_0000_000#e+32
1.7014118338124E+38

FIRST
approximately

—16#0.7FFF_FFFF_FFFF_FF8#e+32
—1.7014118346047E+38

LAST

16#0.7FFF_FFFF_FFFF_FF8#e+32
1.7014118346047E+38

approximately

MACHINE_RADIX

MACHINE_MANTISSA

Implementation-Dependent Characteristics

F—13

Attribute

D_floating value and approximate decimal equivalent
(where applicable)

MACHINE_EMAX

127

MACHINE_EMIN

—127

MACHINE_ROUNDS

True

MACHINE_OVERFLOWS

True

Attribute

G_floating value and approximate decimal equivalent
(where applicable)

DIGITS

MANTISSA

EMAX

204

EPSILON
approximately

16#0.4000_0000_0000_00#e—12
8.881784197001E-16

SMALL
approximately

16#0.8000_0000_0000_00#e—-51
1.944692274332E-62

LARGE
approximately

16#0.FFFF_FFFF_FFFF_E0#e+51
2.571100870814E+61

SAFE_EMAX

1023

SAFE_SMALL
approximately

16#0.1000_0000_0000_00#e-—255
5.562684646268E-309

SAFE_LARGE
approximately

16#0.7FFF_FFFF_FFFF_F0#e+256
8.988465674312E+307

FIRST
approximately

—16#0.7FFF_FFFF_FFFF_FC#e+256
—8.988465674312E+307

LAST
|
approximately

16#0.7FFF_FFFF_FFFF_FC#e+256
8.988465674312E+307

MACHINE_RADIX

MACHINE_MANTISSA

MACHINE_EMAX

1023

MACHINE_EMIN

—1023

MACHINE_ROUNDS

True

MACHINE_OVERFLOWS

True

F-14

Implementation-Dependent Characteristics

Attribute

H_floating value and approximate decimal equivalent
(where applicable)

DIGITS

MANTISSA

111

EMAX

444

EPSILON
approximately

16#0.4000_0000_0000_0000_0000_0000_0000_0#e—27
7.703719777548943412223911770339 7E-34

SMALL
approximately

16#0.8000_0000_0000_0000_0000_0000_0000_0O#e-111
1.1006568214637918210934318020936E-134

LARGE
approximately

16#0.FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFE_0#e+111
4.5427420268475430659332737993000E+133

SAFE_EMAX

16383

SAFE_SMALL
approximately

16#0.1000_0000_0000_0000_0000_0000_0000_0#e—4095
8.4052578577802337656566945433044E—4933

SAFE_LARGE
approximately

16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_0#e+4096
5.9486574767861588254287966331400E+4931

FIRST
approximately

—16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_C#e+4096
—5.9486574767861588254287966331400E+4931

LAST

16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_C#e+4096
5.9486574767861588254287966331400E+4931

approximately

MACHINE_RADIX

MACHINE_MANTISSA

113

MACHINE_EMAX

16383

MACHINE_EMIN

—16383

MACHINE_ROUNDS

True

MACHINE_OVERFLOWS

True

F.9.4

Attributes of Type DURATION
The values of the significant attributes of the type DURATIONare as
follows:
DURATION’ DELTA

1.00000E-04

DURATION’ SMALL

Q-\

DURATION’ FIRST

—131072.0000

DURATION’ LAST

131071.9999

DURATION’ LARGE

1.3107199993896484375E+05

Implementation-Dependent Characteristics

F—15

F.9.5

implementation Limits
Limit

Description

Maximum numberof formal parameters in a subprogram or entry
declaration that are of an unconstrained record type

255

Maximum identifier length (number of characters)

255

Maximum numberof characters in a source line

245

Maximum numberof discriminants for a record type

246

Maximum numberof formal parameters in an entry or subprogram
declaration

255

Maximum numberof dimensions in an array type

4095

Maximum numberoflibrary units and subunits in a compilation

16383

Maximum numberof library units and subunits in an execution

32757

Maximum numberof objects declared with the pragma PSECT_
OBJECT

65535

Maximum numberof enumeration literals in an enumeration type
definition

65535

Maximum numberof characters in a value of the predefined type
STRING

65535

Maximum numberof frames that an exception can propagate

65534

Maximum number oflines in a sourcefile

27-1

Maximum numberof bits in any object

closure?

closure”

1The compilation closure of a given unit is the total set of units that the given unit depends
on, directly and indirectly.
2The execution closure of a given unit is the compilation closure plus all associated secondary
units (library bodies and subunits).

F-16

Implementation-Dependent Characteristics

Appendix G

Ada LanguageInterpretations
Underthe rules of the American National Standards Institute (ANSI),

the Ada Joint Program Office (AJPO) of the United States Department of
Defense, as the sponsor ofthe United States Ada language standard, is
responsible for the ongoing maintenance andinterpretation of that standard.
Underthe rules of the International Standards Organization (ISO),
ISO-IEC/JTC1/SC22/WG9 (WG39)is responsible for the development and
ongoing maintenance and interpretation of the international Ada language
standard, coordination with related standards, and so on. Under WG9, an

Ada Rapporteur Group (ARG) has been formed to make recommendations on
maintenance and interpretation of the standard to WG9.
Both the ANSI (AJPO) and ISO (WG9/ARG) groups coordinate their efforts,
and, in particular, seek to retain Ada’s strength as an internationally single
standard and to avoid any divergence in the interpretation of the ISO and
ANSI Ada language standards.
A numberof language interpretations (called Ada commentaries) have
been made (or recommended) between publication of the standards and the
publication of this version of the VAX Ada Language Reference Manual.
These commentaries have been coordinated between, and are endorsed by,

both the ANSI and ISO groups. The summary part of each commentary is
presented here for convenience.
For information on how to obtain the full text of the commentaries, contact

the AJPO (see the Postscript at the end of this manual for the mailing
address), the WG9, or the Ada Information Clearinghouse (AdaIC).

Ada Language Interpretations

G-—1

The Ada Information Clearinghouse is operated by the IIT Research
Institute for the AJPO. Its post office mailing addresses and phone numbers
are as follows:
AdalIC
3D139 (1211 Fern St., C-107)
The Pentagon
Washington, DC 20301-3081
(703) 685-1477

AdalIC
4600 Forbes Blvd.
Lanham, MD 20706
(301) 459-3711

Al-00001/10: Renaming and static expressions [04.09 (06), 08.05 (04)]
If the name declared by a renaming declaration denotes a constant explicitly
declared by a constant declaration having the form specified in 4.9(6), then
the name can be used as a primary in a static expression.
Al-00002/07: Deriving homographsfor an enumeration literal and a
function [08.03 (17)]
It is possible to derive both an enumeration literal and a user-defined
function that is a homographoftheliteral. In such cases, the enumeration
literal is hidden by the user-defined function.
Al-00006/05: The subtype of a loop parameter [05.05 (06)]
The subtype of a loop parameter is determined by the discrete range in the
loop parameter specification. Therefore, the loop parameter has a static
subtype if the discrete range is static.
Al-00007/19: Discriminant compatibility for incomplete, private, and
access types [03.07.02 (05), 03.08.01 (04)]
Whena subtype indication with a discriminant constraint is elaborated,
3.3.2(6-8) requires that the compatibility check defined in 3.7.2(5) be
performed. The check has two parts: first, check that the value of each
discriminant belongs to the corresponding discriminant subtype, and second,
if a discriminant is used in a subcomponentconstraint, check the constraint
for compatibility with the subcomponent’s type. If a discriminant constraint
is applied to a private type or to an incomplete type before its complete declaration, the second part of the check cannot be performed when the subtype
indication is elaborated because no subcomponent declarations exist.
The recommendedinterpretation of 3.7.2(5) in this case is that the check
for subcomponents be deferred and be performed no later than the end of
the declaration that allows the deferred check to be completely performed,
except when an incomplete type is declared in the private part of a package

G-2

Ada LanguageInterpretations

andits full declaration is given in the package body; in this case, a discrim-

inant constraint is not allowed for the type prior to the end of the package

specification.

If a discriminant constraint is given for an access type, the constraint
applies to the designated type. The second part of the compatibility check is
optional in this case (even if the designated type is completely declared, e.g.,
even if the constraint occurs in an object declaration or allocator).
Whentheinitial values of discriminants are given by theevaluation of default expressions, the corresponding constraint is checked for compatibility.
Al-00008/05: Negative exponents in based notation [02.04.02 (04)]
The exponentof a based literal must not have a minussign if the based
literal is an integer literal.
Al-00014/10: Evaluating default discriminant expressions [03.07.02 (08)]
Default discriminant expressions are not evaluated when an explicit initialization expression is provided in an object declaration or a component
declaration.
Al-00015/12: Whenthe prefix of ‘ADDRESS contains a function name
[04.01.04 (03), 13.07.02 (06)]
The nameof an attribute designator can be taken into account when deciding whetherthe prefix of an attribute is a nameor a function call, but the
attribute designator cannot be considered whenresolving identifiers that are
used in the prefix. In particular, the fact that the prefix of ADDRESS(as
well as the prefix of ‘SIZE, ‘CONSTRAINED, and ‘STORAGE_SIZE) can

be an object but not a function call does not affect the resolution of a name
that occurs in theprefix.
Al-00016/10: Using a renamed packageprefix inside a package
[04.01.03 (15), 04.01.03 (18)]
An expanded nameis legal if the prefix denotes a package and theselector
is a simple namedeclared within the visible part of the package, regardless
of whetherthe prefix is a name declared by a renaming declaration.
Al-00018/06: Checking aggregate index and subcomponent values
[04.03.02 (11)]
The check that the value of an index in an array aggregate belongsto
an index subtype can be madebefore or after all choices have been evaluated. Similarly, the check that a subcomponent value belongs to the

Ada Language Interpretations

G-—3

subcomponent’s subtype can be performedbefore or after all subcomponent

expressions have been evaluated.

Al-00019/07: Checking for too many componentsin positional aggregates
[04.03.02 (11)]
CONSTRAINT_ERRORis raised if the bounds of a positional aggregate do
not belong to the corresponding index subtype.
Al-00020/07: Real literals with fixed point multiplication and division
[04.05.05 (10)]
A realliteral is not allowed as an operand of a fixed point multiplication or
division. The possibility of adopting a more liberal rule in a future version
of the language will be studied.
Al-00023/06: Static numeric subtypes [04.09 (11), 03.05.04 (04), 3.05.07
(10), 03.05.09 (08)]
Declarations containing integer and real type definitions declare static
subtypes, e.g., given
type T is range 1..10;

T is a static subtype.
Al-00024/09: Type conversions as out parameters for non-scalar types
[06.04.01 (04)]
If an out parameter has the form of a type conversion and the type mark
denotes an array type, the type conversion is performed before the call (see
4.6(11, 13) for the semantics of such a conversion). If the type mark denotes
an access type, the value of the variable is converted before the call to the
base type of the formal parameter; the designated object need not satisfy a
constraint imposed by the formal parameter.
Al-00025/08: Checking out parameter constraints for private types
[06.04.01 (09)]
When a subprogram parameter has a private type, the constraint checks
that are performed before or after the call are those appropriate for the type
declared in the private type’s full declaration.
Al-00026/07: Effect of full type decl on CONSTRAINEDattribute
[07.04.02 (09)]
After the full declaration of a private type P, P’; CONSTRAINEDis not
allowed unless P’s full declaration derives from a private type.

G-4

Ada Language Interpretations

Al-00027/07: Visibility of type mark in explicit conversion or qualified
expression [08.03 (18)]
The type markthat occurs in an explicit conversion or in a qualified expression must denote a visible declaration.
Al-00030/07: All guards need not be evaluatedfirst [09.07.01 (05)]
In the execution of a selective wait statement, the evaluation of conditions,

delay expressions, and entry indices is performed in someorderthatis
not defined by the language, except that a delay expression or an entry
index cannot be evaluated until after the condition for the corresponding
alternative is evaluated and foundto betrue.
Al-00031/06: Out-of-range argument to pragma PRIORITY [09.08 (01)]
If the argument to pragma PRIORITY does not lie in the range of the
subtype PRIORITY, the pragmahasnoeffect.
Al-00032/09: Preemptive scheduling is required [09.08 (04)]

If an implementation supports more than onepriority level, or interrupts,
then it must also support a preemptive schedulingpolicy.
Al-00034/06: Value of COUNTin an accept statement [09.09 (06)]
In an accept statement for a member of an entry family, the member being
called (and consequently, the task calling the member) is not known until
the entry index has been evaluated. This means that if the entry index
contains a COUNTattribute, its value is not affected by what memberof the
family is eventually determinedto be called.
Al-00035/06: Body stubsare not allowed in package specifications
[10.02 (03)]
Body stubs are not allowed in package specifications.
Al-00037/12: Instantiating when discriminants have defaults [12.03.02 (04)]
An actual subtype in a generic instantiation can be an unconstrained type
with discriminants that have defaults even if an occurrence of the formal
type (as an unconstrained subtype indication) is at a place where either
a constraint or default discriminants would be required for a type with
discriminants.

Ada LanguageInterpretations

G—5

Al-00038/06: Declarations associated with default names [12.03.06 (02)]
The normal!visibility rules apply to identifiers used in default subprogram names,i.e., these identifiers are associated with declarations visible
at the point of the generic declaration, not those visible at each place of
instantiation.
Al-00039/12: Forcing occurrences and premature uses of a type
[13.01 (06), 13.01 (07), 07.04. 01 (04)]
Each operandof a relational operator (and similarly, the operand of a type
conversion or membership test) is considered to be implicitly qualified with
the nameof the corresponding operand type; such implicit occurrences are
considered to be occurrences of the type name with respect to the rules given
in 13.1(6), 13.1(7), and 7.4.1(4). This means that such occurrences can be

illegal if the implicit type nameis an incompletely declared private type
(7.4.1(4)), or they can make the subsequent occurrence of a representation
clause illegal (13.1(6, 7)).
Al-00040/07: Multiple specification of T’' SIZE, T’ STORAGE_SIZE,
T’ SMALL [13.01 (03), 13.06 (01)]
For a given type, the ‘SIZE, ‘'STORAGE_SIZE, and ‘SMALLattributes can
each be specified at most once by an explicit representation clause.

Al-00045/05: Subtype SYSTEM.PRIORITY [13.07 (02)]
The subtype SYSTEM.PRIORITY can be non-static. The subtype can have a
null range.
Al-00046/06: Lifetime of a temporary file and its name [14.02.01 (03),
14.02.01 (22)]
1) An implementation is allowed to delete a temporary file immediately after
closingit.
2) The NAMEfunction is allowed to raise USE_ERRORif its argumentis
associated with an external file that has no name,in particular, a temporary
file.
Al-00047/07: Effect of RESET online and page length [14.03.01 (04)]
Calling RESETresets the line and page lengths to UNBOUNDED.

G-6

Ada LanguageInterpretations

Al-00048/12: Default files can be closed, deleted, and re-opened [14.03.02
(01), 14.03.01 (05)]
The CLOSEoperation can be appliedto a file object that is also serving as
the default input or default output file. The effect is to close the default file.
A subsequent OPEN operation can havethe effect of opening the default file
as well. Similarly, a DELETE operation can be appliedto a file object that is
serving as the defaultfile.
The exception MODE_ERRORis raised by OPEN if the specified mode is
OUT_FILE andthefile object being opened is serving as the default input
file. Similarly, MODE_ERRORis raised if the specified mode is IN_FILE

and the file object being opened is serving as the default outputfile.

Al-00050/11: When does GET_LINE call SKIP_LINE? [14.03.06 (13)]
GET_LINE readscharacters until either the end of the string is met or until

END_OF_LINEis true. If the end of the string has been met, SKIP_LINE

is not called even if END_OF_LINEis true. In particular, no characters are
read if the string is null.
Al-00051/07: Reading “integerliterals” [14.03.07 (06)]
Integer GET reads according to the syntax of an optionally signed numeric
literal that does not contain a point. It raises DATA_ERRORif the characters read do not form a legal integer literal. For example, if integer GET
attempts to read 0.3, OE—3, or 20#0#, reading stops before the decimal point

for 0.3, after the 3 for OE-3, and after the second # for 20#0#; DATA_ERROR

is raised for OE—3 since legal integer literals are not allowed to have exponents containing minus signs. DATA_ERRORisalsoraised for 20#0#, since

20 is not an allowed base value.

Al-00099/12: ‘SMALL can be specified for a derived fixed point type
[13.02 (12)]
A representation clause specifying small for a derived fixed point type is
allowed if the resulting model numbersare (representable) values of the
parent type and the value specified for small is not greater than the delta of
the derived type.
|
Al-00103/06: Accuracy of a relation between two static universal real
operands [04.10 (04)]
The relational and membership operations for static universal real operands
must be evaluated exactly.

Ada LanguageInterpretations

G-7

Al-00113/12: A subunit’s with clause can nameits ancestorlibrary unit
[10.05 (02)]
A with clause for a subunit can name the subunit’s ancestor library name.
Al-00120/05: Overload resolution for assignment statements [08.07 (03)]

The type of the right-hand side of an assignment statement can be used to
determine an overload resolution of the left-hand side.
Al-00128/04: No membershiptests or short-circuit operations in static
expressions [04.09 (02)]
Membership tests and short-circuit control forms are not allowed in static
expressions because neither of these are operators.
Al-00132/05: Static constraints and componentclauses [13.04 (07)]
A record componentclause is only allowed for a record component having
a constraint if the constraint is static and, if the component has subcomponents that are constrained, each subcomponentconstraintis static.
Al-00137/05: Exponentiation with floating point operand [04.05.06 (06)]
Since the model interval for X*X*X*X is sometimes smaller than the interval
for (X*X)*(X*X), an implementation cannot compute X**4 as sqr(sqr(X)),
where sqr(Y) computes Y*Y. In general, exponentation to the Nth power
must be implemented using N — 1 multiplications to ensure the required
* accuracy is obtained.
Al-00138/10: Representation clauses for derived types [03.04 (10), 03.04
(22), 13.01 (03), 13.06 (01)]
If an aspect of a parent type’s representation has been specified by an
implicit or explicit representation clause and no explicit representation
clause is given for the same aspect of the derived type, the representation of
the derived and parent types are the same with respect to this aspect.
An explicit length clause for STORAGE_SIZEof a task type, for SIZE (of
any type), or for SMALLof a fixed point type, an explicit enumeration
representation clause, an explicit record representation clause, or an explicit
address clause for a task type can be given for a derived type (prior to a
forcing occurrence for the type) even if a representation clause has also
been given (explicitly or implicitly) for the same aspect of the parent type’s
representation. (But only a length clause is allowed for a derived type if the
parent type has derivable subprograms.)
An expression in an implicit representation clause is not evaluated when the
implicit clause is elaborated.
G-8

Ada LanguageInterpretations

Al-00139/04: The declaration of “additional operations” for access types
[07.04.02 (07)]
A consequenceof the rule in 7.4.2(7, 8) is that an object Al can be declared
such that the name A1(1) is illegal when A1.all(1) would be legal. Similar

examples exist for slices, for the attributes ‘FIRST, ‘LAST, ‘LENGTH, and

‘RANGE,andfor selection of a record component(e.g., R1.C1 can be illegal
when Rl.all.C1 is legal).
Al-00143/04: Model numbersfor delta 1.0 range —7.0 .. 8.0 [03.05.09 (06)]
Given
type F is delta 1.0 range -7.0

8.0;

The model numbersfor F do not include the value 8.0 and F’ MANTISSA
must be 3.

Al-00144/10: A fixed point type declaration cannot raise an exception
[03.05.09 (09)]
A fixed point type declaration cannot raise an exception. Declarations such
as:
type F is delta 2**(-15)

range -1.0

1.0;

are legal even if F’ SIZE is equal to 16 so 1.0 is not a representable value.
Al-00145/04: Dynamic computation of ‘MANTISSAfor fixed point subtypes
[03.05.09 (14)]
If F is a non-static fixed point subtype, F7 MANTISSA must, in general, be
computed at run-time.
Al-00146/10: Model numbers for a fixed point subtype with length clause
[03.05.09 (14), 03.05.09 (16)]
If a length clause specifying small has been given for a fixed point type,T,
then the value of small for any subtype of T is given by T’ SMALL.
Al-00147/05: Declaring a fixed point type that occupies one word
[03.05.09 (18)]
A fixed point type that occupies a full word can be declared as:
DEL : constant := 1.0/2** (WORDLENGTH - 1);

type FRACTION is delta DEL range -1.0

1.0 - DEL;

Ada LanguageInterpretations

G—9

Al-00148/05: Legality of —1..10 in loops [03.06.01 (02)]
The range —1..10 is illegal as the discrete range in an iteration rule, con-

strained array type definition, and entry family declaration, since —1 is an

expression having a form prohibited by 3.6.1(2), and the other rules of the
language do not determine a unique type for the bounds. Thepossibility
of adopting a more liberal rule in a future version of the language will be

studied. Note, however, that instead of writing —1..10, one can always write

INTEGERrange —1..10 or declare —1 as a constant and use the constant
namein place of the expression, —1; often it will be appropriate to use the
attribute ‘RANGEin place of an explicit range such as -1..10.
Al-00149/09: Activating a task before elaboration of its body [03.09 (06)]

If an attempt is madeto activate a task before its body has been elaborated,
PROGRAM_ERRORisraised.
If more than onetask is to be activated, the check for unelaborated bodiesis

performed before an attempt is made to activate any task. Consequently, if
PROGRAM_ERRORis raised, no tasks have been activated.

Al-00150/04: Allocated objects belong to the designated subtype
[04.08 (05)]
CONSTRAINT_ERRORisraised if an object specified by an allocator does
not belong to the designated subtype for the allocator.
Al-00151/05: Case expression of a type derived from a generic formal type
[05.04 (03)]
A type derived from a generic formal type cannot be used in the expression
of a case statement.
Al-00153/05: Membership tests cannot use an incompletely declared
private type [07.04.01 (04)]
The type mark for a private type cannot be used in a membership test before
the end of the full declaration of the type. This restriction also applies to
the use of a name that denotes a subtype of the private type and the use of
a namethat denotes any type or subtype that has a subcomponent of the
private type.
Al-00154/06: Additional operations for composite and access types
[07.04.02 (08), 07.04.02 (07)]
:
This Commentary gives details showing which operations are declared for
certain composite and access types immediately after their declaration and
which are declared later in a package body.

G-10

Ada LanguageInterpretations

Al-00155/08: Evaluation of an attribute prefix having an undefined value
[03.02.01 (18), 07.04.03 (04)]
The execution of a program is erroneousif the nameof a deferred constant
is evaluated before the full declaration of the constant has been elaborated.
Evaluation of the name of a scalar variable is not erroneous, even if the

variable has an undefined value, if the nameoccurs asthe prefix for the
attribute ADDRESS, FIRST_BIT, LAST_BIT, POSITION,or SIZE. (In these
cases, the value of the variable is not needed.)
Al-00157/05: Overloading resolution and parenthesized expressions
[08.07 (07)]
The rule requiring aggregates to be given in namednotation if they contain
a single componentassociation (4.3(4)) is to be considered a syntax rule for
purposes of overloading resolution, and in particular, can be used to help
resolve the type of a parenthesized expression.
Al-00158/05: The main program is elaborated beforeit is called [10.05 (01)]
The main program is elaborated beforeit is called.
Al-00163/05: Implicit conversion preserves staticness [04.09 (06)]
A static expression is static even if an implicit conversion is appliedto it.
Al-00167/04: It is possible to access a task from outside its master
[09.04 (00)]
A task can be accessed from outside its master, since a function can return a

task object as its value, even a task that was activated inside the function.
Al-00169/06: Legality of incomplete null multidimensional array
aggregates [04.03 (06)]

A multidimensional aggregate is illegal if a value is omitted in the specification of any dimension.

Al-00170/07: Renaming a slice [08.05 (05)]
A slice must not be renamed if renamingis prohibited for any of its
components.

Ada LanguageInterpretations

G—11

Al-00172/06: GET_LINEfor interactive devices [14.03.06 (13)]
An implementation is allowed to assume that certain external files do not
contain page terminators. Such external files might be used to represent interactive input devices. (To ensure that such files have no page terminators,
an implementation may refuse to recognize any input sequence as a page
terminator.) Under such an assumption, GET_LINE and SKIP_LINE can
return as soon as a line terminatoris read.
Al-00173/05: Completion of execution by exception propagation
[09.04 (05)]
The execution of a task, block statement, or subprogram is completed if an
exception is raised by the elaboration of its declarative part. The execution
of a task, block statement, or subprogram is completed if an exceptionis
raised before the first statement following the declarative part and there
is no corresponding handler, or if there is one, when it has finished the
execution of the corresponding handler. (TASKING_ERRORis the only
exception that can be raised under these circumstances. It can be raised
by unsuccessful attempts to activate one or more dependent tasks after
elaboration of the declarative part and before beginning execution of the
sequence of statements.)
Al-00177/04: Use of others in a multidimensional aggregate [04.03.02 (08)]
An others choice is allowed if an aggregate is not a subaggregate and
is the expression of a component association of an enclosing (array or
record) aggregate. An others choice is also allowed if an aggregate is a
subaggregate of a multidimensional array aggregate that is in one of the
contexts specified by 4.3.2(5-8).
Al-00179/08: The definition of the attribute FORE [03.05.10 (08)]
The attribute ‘FOREis defined in terms of the decimal representation of
model numbers.
Al-00180/07: Elaboration checks for INTERFACE subprograms
[03.09 (05), 13.09 (03)]
If a subprogram is named in an INTERFACE pragma, no check need be
made that the subprogram body has been elaborated beforeit is called.

G-12

Ada Language Interpretations

Al-00181/04: NUMERIC_ERRORfor nonstatic universal operands
[04.10 (05)]
Whenevaluating a nonstatic universal expression, NUMERIC_ERROR can
be raised if any operandortheresult is a real value that lies outside the
range of safe numbers of the most accurate predefined floating point type
(excluding universal_real) or an integer value that lies outside the range
SYSTEM.MIN_INT .. SYSTEM.MAX_INT.
Al-00186/08: Pragmas recognized by an impl do notforce default
representation [13.01 (06), 02.08 (09)]
The intent of 2.8(9) is that an invalid pragma have the sameeffect as if it
were absent. To ensure that this intent is realized, a pragma defined by the
Standard or by an implementation is not allowed to contain an occurrence
of a nameor expression that forces the determination of the default representation of a type, since such occurrences would make later representation
clauses for the type illegal. Consequently, a representation clause for a type
can be accepted even if the clause is given after a pragma that contains
an expression that normally would force the default representation of the
type to be determined (since such a pragma will be considered invalid, and
ignored). (See AI-00322 for a similar rule for pragmas whose identifiers are
not defined either by the Standard or by the implementation.)
Al-00187/06: Using a name deci by a renaming decl as an expanded name
selector [04.01.03 (15)]
A name declared by a renaming declaration can be used as a selector in an
expanded name.
Al-00190/05: A static expression cannot have a generic formal type
[04.09 (02), 04.03.02 (03)]
A static expression is not allowed to have a generic formal type (including a type derived from a generic formal type, directly or indirectly).
(Consequently, if an array’s index subtype is a generic formal type, aggregates for that dimension of the array can have only a single component
association and this component association must have a single choice.)
Al-00192/05: Allowed namesof library units [08.06 (02)]
The nameofa library unit cannot be a homograph of a namethatis already
declared in package STANDARD.

Ada LanguageInterpretations

G—13

Al-00193/05: The value of 'FIRST’s argumentin overloading resolution
[08.07 (08)]
Any overloaded identifiers occurring in the argument for ‘ FIRST(N),
‘LAST(N), and ’RANGE(N) must be resolved independently of the context
in which these attributes are used.
|
Al-00195/09: The intended use of CLOCK [09.06 (05)]
CLOCKreturns a valuethat reflects the time of day in the external

environment.

Al-00196/05: Use of 86_400.0 in TIME_OF [09.06 (06)]
If TIME_OFis called with a seconds value of 86_400.0, the value returnedis
equal to TIME_OFfor the next day with a seconds value of 0.0. In addition,
the SECONDSfunction always returns a value less than 86_400.0, even if
the SECONDS argument of TIME_OF was 86_400.0.

Al-00197/07: With SYSTEM clause not needed for pragma PRIORITY
[09.08 (00)]
Use of the pragma PRIORITY does not require the package SYSTEM to be
namedin a with clause for the enclosing compilation unit.
Al-00198/00: Termination of unactivated tasks [09.03 (04), 09.10 (05),
09.03 (08)]
If a task is abnormally completed, then any task it has created but not yet
activated becomes terminated and is neveractivated.

If PROGRAM_ERRORisraised before attempting to activate one or more
tasks because the body of at least one of these tasks has not yet been
elaborated (see AI-00149), all the unactivated tasks become terminated.

Al-00199/08: Implicit declaration of library subprograms [10.01 (06)]
A subprogram body given in a compilation unit (following the context clause)
is interpreted as a secondary unit if the program library already contains a
subprogram declaration or generic subprogram declaration having the same
identifier as the body. Otherwise, the subprogram bodyis interpreted as a
library unit.
Successfully compiling a subprogram body thatis a library unit means the
unit is added to the library, replacing any previously existing library unit
having the sameidentifier. (The previously existing library unit can only be
a package declaration, a generic package declaration, a generic instantiation,
or a previously compiled subprogram bodythat is a library unit.)

G-14

Ada Language Interpretations

Al-00200/08: Dependencescreated byinline of generic instantiations
[10.03 (07), 06.03.02 (03)]
If inline inclusion of a subprogram call is achieved due to pragma INLINE,
an implementation is allowed to create a dependenceof the calling unit on
the subprogram body; when such a dependenceexists, the unit containing
the call is obsolete if the subprogram body is obsolete. Such dependences
can be created even when the subprogram is created as a result of a generic
instantiation.
Ai-00201/07: The relation between TICK, CLOCK, and the delay statement

[09.06 (01), 09.06 (05), 09.06 (04), 13.07.01 (07)]

The value returned by successive calls to the CLOCK function can be
expected to change at the frequency indicated by SYSTEM.TICK.
There is no required relation between SYSTEM.TICK and
DURATION’ SMALL.
Delay statements need not be executed with an accuracy that is related
to SYSTEM.TICK or DURATION’ SMALL;in particular, delay statements
can be executed more accurately than SYSTEM.TICK implies. Execution
with less accuracy than SYSTEM.TICKrequires justification in terms of
AI-00325.
Al-00205/06: The formula for MANTISSAis correct [03.05.07 (06)]
The numberof mantissa bits for D decimal digits of accuracy is correctly
given by the formula in the Standard, namely, the integer next above
(D*log(10)/log(2)) + 1.
Al-00209/06: Exact evaluation of static universal real expressions
[04.10 (04)]
An implementation can refuse to evaluate a static universal real expression
only if there are insufficient resources to evaluate the expression exactly,
e.g., if there is insufficient memory available. Inexact results must not be
delivered.
Al-00210/04: Loop namein an exit statement as an expanded name
[05.07 (02)]
An expanded nameis allowed as the loop namein an exit statement.
Al-00215/05: Type of EXP should be FIELD [14.03.08 (20)]
The type of the EXP parameter for PUT is FIELD, not INTEGER.

Ada LanguageInterpretations

G-15

Al-00217/05: The safe numbersof a floating point subtype [03.05.07 (09)]
The safe numbersof a floating point subtype are the safe numbersofits
base type.
Al-00219/06: Use of & and ‘IMAGEin static expressions [04.09 (02)]
In a static expression, every factor, term, simple expression, and relation
must have a scalar type.
Al-00225/09: Secondary units for generic subprograms[10.01 (06)]
If a subprogram body given in a compilation unit has the sameidentifier as
a library unit and the library unit is a generic subprogram declaration, then
the subprogram bodyis interpreted as a secondary unit.

Al-00226/06: Applicability of context clauses to subunits [10.01.01 (04)]
The context clause of a library unit that is a declaration applies not only
to the secondary unit that defines the corresponding body, but also to any
subunits of the secondary unit.
Al-00231/03: Full declarations of incomplete types can have discriminants
[03.08.01 (04)]
|
The full declaration of an incomplete type can be a derived type with unconstrained discriminants when no discriminant part is given in the incomplete
type’s declaration.
Al-00232/05: Full declarations that implicitly declare unconstrained types
[07.04.01 (03)]
A full declaration of a private type can declare a constrained array subtype
or a constrained type with discriminants.
Al-00234/05: Lower bound for ‘IMAGE of enumeration values
[03.05.05 (10)]

The lower bound of the string returned by the predefined attribute IMAGE
is one.

Al-00235/05: Redundant parentheses enclosing universal_fixed
expressions [04.05.05 (11)]
An expression having type universal_fixed can be enclosed in parentheses
before being converted to some other numeric type.

G-16

Ada Language Interpretations

Al-00236/12: Pragma ELABORATEfor bodiless packages with tasks
[10.05 (04)]
If a package declares a task object but no package body is required or
provided by a programmer, 9.3(5) says an implicit body is provided. The
effect of a pragma ELABORATEthat names such a packageis to require
that the implicitly provided package body be elaborated, thereby activating
the task declared in the package.
Al-00237/06: Instances having implicit package bodies [12.03 (17),
09.03 (05)]
Given a generic package declaration that does not require a body and that
has no explicit body, when the generic package is instantiated, if the instance
specification requires a body, then an implicit instance body is created and is
elaborated whenthe instantiation is elaborated.
Al-00239/11: ENUMERATION_IO and IMAGE for non-graphic characters
[14.03.09 (06), 14.03.09 (09), 03.05.05 (11)]
If ENUM_IOis an instantiation of ENUMERATION_IO for a character type
that contains a non-graphic character, e.g.,
package ENUM_IO is new ENUMERATION_IO

(CHARACTER) ;

then for each non-graphic character (such as ASCIJ.NUL), ENUM_IO.PUT
should output the corresponding sequence of characters used in the type
definition (e.g., PUT(ASCII.NUL) should output the string “NUL”if SET has
the value UPPER_CASEand WIDTHis less than 4). Furthermore, ENUM_

IO.GET should be able to read the sequence of characters output by ENUM_
IO.PUT for a non-graphic character, returning in its ITEM parameter the
corresponding enumeration value.

Similarly, the image of a non-graphic character(i.e., the result returned for
the attribute designator IMAGE) should be the sequence of characters used
in the type definition of CHARACTER(e.g., CHARACTER’ IMAGE(ASCII.NUL
= “NUL”), and ‘VALUE should accept such a string as representing the
corresponding enumeration value.
An implementation conforms to the Standard in this respect if the result
produced by ‘IMAGEfor a non-graphic character is accepted by ‘ VALUE,
and if the result (if any) produced by PUT can be read by GET; GET is
also allowed to raise DATA_ERROR whenattempting to read any string
produced by PUT for a non-graphic character.
This interpretation is non-binding, i.e., implementers are encouraged to
conform to it but are not required to do so by the validation tests. A future
version of the Standard mayincorporate this interpretation.
Ada Language Interpretations

G-17

Al-00240/05: Integer type definitions cannot contain a RANGEattribute
[03.05.04 (03)]
A rangeattribute is not allowed in an integer type definition.
Al-00242/09: Subprogram namesallowed in pragma INLINE [06.03.02 (03),
02.08 (09)]
If the pragma INLINE appearsat the place of a declarative item, every
name in the pragma must denote at least one subprogram or generic subprogram declared explicitly earlier in the same declarative part or package
specification. If the pragma appearsafter a given library unit, the pragma
must contain just the nameof the library unit, and the library unit must
be a subprogram or a generic subprogram. If a pragma INLINE appears
at the place of a declarative item and a namein the pragmais overloaded,
the pragma applies just to those subprograms whose declarations occur
(explicitly) earlier in the same declarative part or packagespecification. If a
name in a pragma INLINEis declared by a renaming declaration, and the
denoted subprogram is explicitly declared earlier in the same declarative
part or package specification, inline expansion is desired for every call of
the denoted subprogram (whetherthe call uses the new or the old name). If
a pragma INLINE applies to a subprogram,inline expansion is desired for
every call of the subprogram, whether or not the call uses a name declared
by a renamingdeclaration.
Al-00243/05: Overriding width format in TEXT_IO [14.03.05 (07)]
If the specification of WIDTH or FOREin call of PUT is insufficiently
large, the output is given with no leading spaces.
Al-00244/04: Record aggregates with multiple choices in a component
association [04.03.01 (01)]
In a record aggregate, a componentassociation having multiple choices
denoting components of the sametype is considered equivalent to a sequence
of single choice component associations representing the same components.
Al-00245/08: Type conversion conformance for renamed subprogram/entry
calls [06.04.01 (03), 08.05 (08)]
Whena type conversion is used as an actual parameter corresponding to
an in out or out formal parameter and the subprogram being called was
declared by a renaming declaration (renaming either a subprogram or entry),
the namegiven as the type mark (in the type conversion) must conform to
the namegiven for the corresponding parameter of the denoted subprogram
or entry (not the name given in the renaming declaration).

G-18

Ada LanguageInterpretations

Al-00247/05: A non-null FORM argument can be required by an
implementation [14.02.01 (03)]
An implementation can require that a non-null FORM argumentbe given to
CREATE and/or OPENby raising USE_ERRORif one is not provided.
Al-00251/05: Are types derived from generic formal types static subtypes?
[04.09 (11)]
Types derived from generic formal types are not static subtypes.
Al-00257/04: Restricting generic unit bodies to compilations [10.03 (09)]
10.3(9) allows an implementation to require that bodies and subunits of
a generic unit appear in the same compilation. An implementation is
allowed to apply this rule selectively, i.e., the conditions under which an
implementation requires placement in a single compilation may depend on
characteristics of the generic specification, body, or subunit.
Al-00258/06: ‘POSITIONetc. for renamed components [13.07.02 (07),

A (34)]

The prefix for ‘POSITION, 'FIRST_BIT, and ‘LAST_BIT must have the

form R.C, where R is a name denoting a record and C is the name of a
componentof the record.
Al-00260/06: Limited “full types” [07.04.04 (04)]

A full type declaration declares a limited type if an assignment operation is
not visible for the type of some subcomponentat the place of the full type
declaration.
A formal parameter whose type mark denotes an incompletely declared
private type cannot have mode OUT if the parameter’s full type declaration
declares a limited type.
Al-00261/03: “any error” —> “any illegal construct” [10.03 (03)]
An attempt to compile an illegal compilation unit has no effect on the
program library (see also AI-00255).
Al-00263/06: A named numberis not an object [03.02 (08), 13.05 (04),
13.07.03 (03), 13.07.03 (05)]
A numberdeclaration declares a named number, which is not an object.
The elaboration of a number declaration proceeds by evaluating the initialization expression and creating a named number. The value of the
initialization expression then becomesthe value of the named number.

Ada LanguageInterpretations

G-—19

Al-00265/05: Index subtype of an array aggregate [04.03.02 (11)]
The index subtype of an array type declared by a constrained array definition is the subtype defined by the corresponding discrete range.
Al-00266/09: A body cannot be compiled for a library unit instantiation
[10.01 (06)]
If a generic package is instantiated as a library unit, it is illegal to attempt to compile a package body having the sameidentifier as that of the
instantiation.
After instantiating a generic subprogram asa library unit, any attempt to
compile a subprogram body having the sameidentifier as that of the library
unit instantiation causes the instantiation to be deleted from the library and
replaced with the new library unit subprogram.
Al-00267/06: Evaluating expressions in case statements [03.05.04 (10),
05.04 (06), 11.06 (06)]
An exception is raised if the value of the expression in a case statement does
not belong to the base type of the expression.
Al-00268/06: Activation of already abnormal tasks [09.03 (03)]
If a task is aborted before it is activated, no exception is raised when an
attempt is madeto activate the task.
Al-00276/07: Rendezvousthat are “immediately possible” vs. timed entry
calls [09.07.03 (04), 09.07.02 (01)]
A timed entry call with a zero or negative delay issues an entry call that is
canceled only if a rendezvous is not immediately possible. 9.7.2(4) specifies
the conditions under which an entry call is immediately possible. In a
distributed implementation of Ada, it may take a non-negligible amount of
time to determine whether an entry call is “immediately”possible.
Al-00279/09: Exceptions raised by calls of I/O subprograms [14.01 (11)]
Any exception can be raised when evaluating the actual parameters of a
call of an input-output subprogram. In addition, STORAGE_ERRORcan
be raised by the call itself before execution of the body has begun. But
once execution of the body of an input-output subprogram has beenstarted,
the only exceptions that can be propagated to the caller are the exceptions
defined in the package IO_EXCEPTIONSandthe exceptions PROGRAM_
ERROR and STORAGE_ERROR.In particular, if CONSTRAINT_ERROR,
NUMERIC_ERROR, or TASKING_ERRORis not raised by the evaluation

of any argument, then none of these exceptions will be raised by thecall.

G-20

Ada Language Interpretations

Furthermore, PROGRAM_ERRORcan only be raised due to errors made by

the user of the input-output subprogram.

Al-00282/06: Compatibility of constraint defined by discrete range
[03.06.01 (04)]
The constraint defined by a discrete range is compatible with a subtypeif
each bound of the discrete range belongs to the subtype,or if the discrete
range defines a null range; otherwise the constraint is not compatible with
the subtype.
Al-00286/11: Declarations visible in a generic subprogram deci and body
[12.01 (05), 08.04 (05), 08.03 (15)]
Except within the body of a generic subprogram, the declaration of a generic
unit is not a declaration for which overloading is allowed. In particular, any
declarations occurring in an outer declarative region or made potentially
visible by a use clause are not directly visible in the generic formal part if
they have the sameidentifier as the subprogram.
Within the body of a generic subprogram, overloading is defined for the
generic subprogram declaration in the same wayas for a nongeneric subprogram. In particular, overloadable declarations occurring in an outer
declarative region or madepotentially visible by a use clause can be directly
visible in the body even though they are not directly visible in the generic
formal part.
Al-00287/05: Resolving overloaded entry calls [09.05 (05), 08.07 (13)]
A call to an overloaded entry is resolved using the same kind of information
as is used for resolving overloaded procedurecalls (the nameof the entry,
the numberof parameters, the types and the order of the actual parameters,
and the namesof the formal parameters).
Al-00288/06: Effect of priorities during activation [09.08 (04)]
A task activation should be performed with the priority of the task being
activated or the priority of the task causing the activation, whicheveris
higher.
Al-00289/05: Ancestor unit names in separate clauses must be simple
names[10.02 (05)]
If P is a library unit, then the namein a “separate” clause for a subunit of P
must be P and not STANDARD.P.

Ada LanguageInterpretations

G-—21

Al-00292/05: Derived types with address clausesfor entries [03.04 (10),
13.05 (08)]
An address clause applied to an entry of a task type also applies to a type
derived (directly or indirectly) from the task type.
Al-00293/05: Null others choice for array aggregates [04.03 (06)]
The others choice in an array aggregate can specify no components.
Al-00294/05: The name given in pragma CONTROLLED[04.08 (11)]
The type name given in a pragma CONTROLLEDcannot be declared by a
subtype declaration nor can it be a first named subtype since a derived type
is not allowed.

Al-00295/05: Evaluating the variable in an actual parameter type
conversion [06.04.01 (04)]
For an actual parameter (of any type) of mode in out or out that is a type
conversion, the variable name is evaluated before the call and therefore

determines the denoted entity.

Al-00298/05: Interaction between pragmas ELABORATEand INTERFACE
[10.05 (04), 13.09 (03)]
A pragma ELABORATEcan be applied to a library unit whose bodyis
supplied by a pragma INTERFACE.
Al-00300/07: Prefixes of attributes in length clauses [13.02 (02)]
The prefix of the attribute that appears in a length clause must be a simple
name. An expanded name, or the name T’ BASE, is not allowed.

Al-00305/05: T’ ADDRESS whenT is a task type yields the task object
address [13.07.02 (03)]
If T denotes a task type, then within the body of task unit T, the T in
T’ ADDRESSis considered to refer to the nameof the task object that
designates the task currently executing the body, i.e., T’ ADDRESSreturns
the address of the object.
Al-00306/15: Pragma INTERFACE; allowed namesandillegalities
[02.08 (09), 13.09 (03)]
If a pragma INTERFACE namesa languagethat is acceptable to an implementation, the subprogram name must denote one or more subprograms
declared explicitly earlier in the same declarative part or package specification. (The pragmahasnoeffect if no named subprogram satisfies the
G-22

Ada LanguageInterpretations

requirements.) The pragmais applied to all such subprogramsother than
enumeration literals and subprogramsdeclared by generic instantiation.
If a subprogram named in the pragma wasdeclared by a renaming declaration, the pragma applies to the denoted subprogram,but only if the denoted
subprogram otherwise satisfies the above requirements.
It is illegal to apply a pragma INTERFACEto a subprogram for which a
pragma INTERFACEhas already been applied.
If a pragma INTERFACEapplies to a subprogram,it is illegal to provide a
body for the subprogram.
Al-00307/04: GET at end of file and from a null string [14.03.07 (06),
14.03.07 (14), 14.03.08 (09), 14.03.08 (18), 14.03.09 (06), 14.03.09 (11)]
END_ERRORis raised (not DATA_ERROR) when attempting to read in-

teger, real, or enumeration values from a string that is null or that only
contains blanks. END_ERROR (not DATA_ERROR)is raised when attempting to read integer, real, or enumeration values from file that has
no remaining elements or whose only remaining elements are blanks, line
terminators, or page terminators.
Al-00308/05: Checking default initialization of discriminants for
compatibility [03.02.01 (16)]
When an object of a type with discriminantsis created either by an object
declaration or an allocator, and the values of the object’s discriminants are
determined by default, each discriminant value is checked for compatibility,
as defined in 3.7.2(5). CONSTRAINT_ERRORisraisedif this check fails.

Al-00310/04: OTHERS choices and static index constraints [04.03.02 (03)]
An others choice is static if the corresponding index subtypeis static and if
the corresponding index bounds werespecified with a static discrete range
in the applicable index constraint.
Al-00311/06: No NUMERIC_ERRORfornull strings [11.01 (06)]
When computing the upper boundof a null string literal, NUMERIC_
ERROR mustnot be raised, even if the lower bound has no predecessor (but
see AI-00325).

Ada Language Interpretations

G—23

Al-00312/04: NUMERIC_ERROR whenevaluating null aggregates and
slices [11.01 (06)]
When determining the length of a null aggregate orslice, it is usually easy
for an implementation to avoid raising NUMERIC_ERROR.This exception
should be raised in these circumstances only whenrelevant restrictions in
the execution or compilation environment makeit impractical or impossible
to avoid raising the exception (see AI-00325).
Al-00313/03: Non-null bounds belong to the index subtype [04.03.02 (11),
04.06 (13)]
CONSTRAINT_ERRORisraised if a non-null choice of an aggregate does
not belong to the corresponding index subtype.
For conversion to an unconstrained array type, CONSTRAINT_ERRORis
raised if a non-null dimension of the operand has bounds that do not belong
to the corresponding index subtype of the target type.
Al-00314/05: The safe numbers for IBM-370 floating point [03.05.07 (09)]
The safe and model numbers for IBM-370 32-bit floating point have the
following characteristics:

DIGITS
=
6
MANTISSA = 21
EMAX
= 84
SAFEEMAX = 252
Al-00316/05: Definition of blank, inclusion of horizontal tab [14.03.09 (06)]
A blank is defined as a space or a horizontal tabulation character.
Al-00319/09: Checking for subtype incompatibility [03.07.02 (05),
03.08.01 (04)]
No object can have a subcomponent with an incompatible discriminant
or index constraint. In particular, even when a discriminant constraint
is applied to a private type before its full declaration or to an incomplete
type (before its full declaration) and a discriminant is used to constrain
a subcomponent, no object of the type can be created if it would have a
subcomponent with an incompatible discriminant or index constraint.

G-24

Ada LanguageInterpretations

Al-00320/06: Sharing externalfiles [14.03.05 (03), 14.02.04 (00),
14.03.04 (00), 14.02.02 (00)]
If several file objects are associated with the same external file, some effects
are implementation dependent. For example, if two sequential file objects
are associated with the same external file, applying a read or write operation
to one file object can changethe effect of applying these operations (or the
endof file operation) to the other file object. Other effects are specified by
the language. In particular, if two text file objects are associated with a
single external file (e.g., a terminal), the page, line, and column numbers

for the output file object cannot be updated implicitly after reading from the
input file object, and vice versa.
Al-00321/02: Forcing occurrence of index subtype [13.01 (06)]
A forcing occurrence of the name of an array type or subtype forces the
default determination of each index subtype, and similarly, for forcing
occurrences of any type or subtype having a subcomponentof such an array
type.

Al-00322/02: Forcing occurrences in unknown pragmas[13.01 (06),
02.08 (09)]
An occurrence of a name within an expression is not a forcing occurrence if
the expression occurs in a pragma whoseidentifier is not defined either by
the Standard or by the implementation.
Al-00324/06: Checking the subtype of a non-null access value [03.08 (06)]
An access value of type T belongs to every subtype of T if T’s designated type
is neither an array type nor a type with discriminants.
Al-00325/04: Implementation-dependentlimitations [01.01.02 (00)]
Implementation-dependent limitations must be justified. An implementationdependentlimitation is justified if it is impossible or impractical to remove
it, given an implementation’s execution environment.
Al-00328/08: Legality of uninstantiated generic units [12.02 (01)]
The legality of a generic unit must be checked even if the generic unit is
never instantiated.

Ada Language Interpretations

G—25

Al-00330/12: Explicit declaration of enumeration literals [08.03 (17),
03.05.01 (03), 03.03. 03 (01)]
If an enumeration literal is declared with an enumeration type definition,
then a function having the sameidentifier as the enumeration literal and
the same parameterandresult type profile cannot also be declared immediately within the same declarative region. Similarly, a non-overloadable
declaration of the enumerationliteral’s identifier is not allowed immediately
within the declarative region containing the enumeration type definition.
Al-00331/07: The effect of a constraint in an allocator [04.08 (05)]
Whena discriminant or index constraint is imposed on the type mark in an
allocator and the type mark denotes an access type, the constraint does not
affect the subtype of the allocated object (which in this case has an access
value).
Similarly, when the type mark in an allocator denotes a scalar type, the
subtype denoted by the type mark doesnotaffect the subtype of the allocated
(scalar) object.
Al-00332/04: NAME_ERROR or USE_ERRORraised when I/O not
supported [14.02.01 (04), 14.02.01 (07), 14.04 (04), 14.04 (05)]
CREATE and OPEN can raise USE_ERROR or NAME_ERRORiffile
creation or openingis not allowed for anyfile.
Al-00336/05: Address clause for subprogram bodies [13.05 (05)]
An address clause cannot be given for a subprogram whose bodyactsas its
declaration.
Al-00339/04: Allow non-English characters in comments [02.07 (01),
02.01 (01)]
An implementation is allowed (but not required) to accept an extended
characterset (i.e., graphic characters whose codes do not belong to the ISO
seven-bit coded character set (ISO standard 646)) as long as the additional
characters appear only in comments.
Al-00343/05: Decimal fixed point representations [03.05.09 (10)]
An implementation can use decimal or binary representationsfor fixed point
values as long as all model numbersare represented exactly.

G-26

Ada Language Interpretations

Al-00350/04: Lexical elements not changed by allowable character
replacements [06.03.01 (05), 02.10 (05)]
Lexical elements differing only in their use of allowable replacementsof
characters (as defined in 2.10) are considered as the same. In particular,
use of the allowable replacements does not affect the conformance of formal
parts, discriminant parts, or actual parameters.

Al-00354/03: On the elaboration of library units [10.05 (02)]

There is no requirement that the body of a library unit be elaborated as soon
as possible after the library unit is elaborated. In particular, the pragma
ELABORATEshould be usedif it is important that a library package’s body
be elaborated before another package is elaborated.
Ai-00355/06: Pragma ELABORATEfor predefined library packages
[10.05 (04), 09.06 (07), 13.07 (02), 13.10.01 (01), 13.10.02 (01), 14.01 (01),
14.03 (01), 14.06 (05), C (22)]
An attempt to use an entity declared within a predefined library unit or a
unit declared within a predefined library package must raise PROGRAM_
ERRORif a required body has not been elaborated (3.9(5-8)). An implementation is not allowed to raise PROGRAM_ERRORfor this reason, however,

if a pragma ELABORATEhasbeen given for the library unit. (In particular, if the library unit body provided by the implementation depends on
other (implementation-defined) library units, the implementation must ensure prior elaboration of the required bodies, e.g., by providing appropriate
ELABORATE pragmas.)
Al-00356/08: Access values that designate deallocated objects
[03.02.01 (18), 04.08 (07), 13.10.01 (06)]
The storage occupied by a designated object can be reclaimed immediately
after applying an instance of the unchecked deallocation procedure to an
access variable that designates the object.
If two objects having non-null access values designate the same object and
an instance of the unchecked deallocation procedure is applied to one of
the objects, the other object is considered to have an undefined value; any
attempt to use such a value makes execution of the program erroneous.
Similarly, if a name declared by a renaming declaration denotes a subcomponent of an object that is later freed by calling an instance of the unchecked
deallocation procedure, the nameis considered to have an undefined value;
any attempt to evaluate the name(e.g., by assigning a value to it) makes
execution of the program erroneous.

Ada Language Interpretations

G—27

Al-00357/05: CLOSE or RESETofa sequential file from OUT_FILE mode

[14.02.01 (09), 14.02.01 (15)]

If a sequential input-output file having mode OUT_FILEis closed or reset,
the most recently written element since the last open or reset is the last

element that can be read from thefile. If no elements have been written, the

closed or reset file is empty. (As a consequence, opening a sequential inputoutput file with mode OUT_FILEorresetting a sequential input-outputfile
to mode OUT_FILE hastheeffect of deleting the previous contents of
thefile.)
Al-00358/10: Discriminant checks for non-existent subcomponents
[03.07.02 (05), 03.07 (08)]
Whenchecking the compatibility of a discriminant constraint, 3.7.2(5)
requires that a discriminant’s value be substituted in component subtype
definitions that depend on the discriminant. This substitution is performed
only for those subcomponents that exist in the subtype defined by the
constraint.
Al-00362/03: “component of a record” for representation attributes
[13.07.02 (08)]
The prefix of ‘POSITION, 'FIRST_BIT, or ‘LAST_BIT must denote a

componentof a record object.

Al-00365/05: Actual parameter names are evaluated in generic
instantiations [12.03 (17)]
In a generic instantiation, the names appearing as actual parameters are
evaluated.
Al-00366/07: The value of SYSTEM.TICKfor different execution

environments [13.07.01 (07)]

SYSTEM.TICK should have a value that reflects the precision of the clock in
the main program’s execution environment. If SYSTEM.TICK does not have
an appropriate value, the effect of executing the program is not defined.
Al-00367/06: Deriving from types declared in a generic package
[03.04 (11), 12.01 (05)]
The rules concerning derivable subprogramsin thevisible part of a nongeneric package are applicable in the visible part of a generic package.
(The effect of a derived type declaration in an instance of a generic unit is
discussed in AI-00398.)

G-28

Ada LanguageInterpretations

Al-00370/06: Visibility of subprogam nameswithin instantiations
[08.03 (16)]
Any declaration with the same designator as a subprogram instantiation is
not visible, even by selection, within the instantiation.
Al-00371/05: Representation clauses containing forcing occurrences
[13.01 (07), 02.08 (09)]
An expression in a representation clause is illegal if it contains a forcing
occurrence for the type whose representation is being specified.
Al-00374/06: An attempt to access an undefined constantis erroneous
[03.02.01 (18)]
The execution of a program is erroneousif it attempts to evaluate a scalar
constant with an undefined value.
Al-00375/05: Restricting the allowed values of a floating point subtype
[03.05.07 (17)]
If a floating point constraint in a subtype indication includes a range constraint, the range of the values that belong to the subtype(i.e., that satisfy
the constraint) is defined by the range constraint. If no range constraint is
present, the range of values that belong to the subtype is not affected, even
though the accuracy of the subtype maybe reduced.
Al-00376/04: Universal real operands with fixed point * and / [04.05.05 (10)]
An expression having type universal_real is not allowed as an operandof a
fixed point multiplication or division operation. The possibility of adopting a
moreliberal rule in a future version of the language will be studied.
This commentary extends the conclusions of AI-0020 to cover all expressions
of type universal_real, not just those having the form of a real literal.
Al-00379/03: Address clausesfor entries of task types [13.05 (08)]
If an interrupt is linked to an entry of more than one task object (of the
sametype), the program is erroneous.

Al-00384/05: Use of an incomplete private type in a formal type declaration
[07.04.01 (04)]
An incompletely declared private type cannot be used in the declaration of a
generic formal type.

Ada LanguageInterpretations

G-—29

Al-00387/05: Raising CONSTRAINT_ERRORinstead of NUMERIC_ERROR
[11.01 (06), 03.05.04 (10), 03.05.06 (06), 04.05 (07), 04.05.05 (12), 04.05.07
(07), 04.10 (05)]
Wherever the Standard requires that NUMERIC_ERRORberaised (other
than by a raise statement), CONSTRAINT_ERRORshould be raised instead.
This interpretation is non-binding.
Al-00388/06: Pragmasare allowed in a generic formal part [02.08 (04)]
Pragmasare allowed in a generic formal part.
Al-00396/03: Correction to discussion of Al-00025 [06.04.01 (09)]
The discussion section of AI-00025/07 should be corrected. Instead of saying,
“The effect of the call, CALL_QNOW.CALL_Q.Q(Y), is to assign an
invalid value to P.Z”
the discussion should say,
“The effect of elaborating CALL_QNOW is to assign an invalid value to
P.Z”.
Al-00397/04: Checking the designated subtype for an allocator [04.08 (13),
04.08 (05)]
Whenevaluating an allocator, a check is made that the designated object
belongs to the allocator’s designated subtype. CONSTRAINT_ERRORis
raised if this check fails. This check can be made anytime before evaluation
of the allocator is complete. In particular, it is not defined whether this
check is performed before creation of a designated object, evaluation of any
default initialization expressions, or evaluation of any expressions contained
in the allocator.
Al-00398/08: Operations declared for types declared in instances
[12.03 (05), 03.04 (11)]
If the parent type in a derived type definition is a generic formal type, the
operations declared for the derived type in the template are determined by
the class of the formal type. The operations declared for the derived type in
the instance are determined by the type denoted by the formal parameter.
Similarly, if the component type of an array type is a generic formal type
or if the designated type of an access type is a generic formal type, the
operations declared for the array and access type in the template depend
on the class of the formal type. If the array and access type declarations do
not occur in the generic formal part, then the operations declared for these

G-30

Ada LanguageInterpretations

types in a generic instance are determined by the type denoted by the formal
parameterin the instance.
If the designated type in an access type declaration is an incomplete type,
additional operations can be declared for the access type by the full declaration of the incomplete type (7.4.2(7-8)). If the full declaration declares a
type derived from a generic formal type, the additional operations (if any)
declared for the access type in the template are determined by the class of
the formal type. The additional operations declared for the access type in
the instance are determined by the type denoted by the formal parameter.
Similar rules apply when the parent type, component type, or designated
type is derived, directly or indirectly, from a generic formal type.
Al-00405/06: One nonstatic operand for a universal real relation
[04.10 (04)]
If the operandsof a relational operator or membership test have the type
universal_real and one or more of the operandsis nonstatic, the static
operands must be evaluated exactly. Doing so, however, does not impose a
run time overhead.
Al-00406/05: Evaluating parameters of a call before raising
PROGRAM_ERROR[03.09 (05)]
It is not defined whether the check that the body of a subprogram has been
elaborated is made before or after the actual parametersof a call have been
evaluated.
Similarly, it is not defined whether the check that the body of a generic unit
has been elaborated is made before or after the generic actual parameters of
an instantiation have been evaluated.
Al-00407/06: The operations of a subtype with reduced accuracy
[03.05.08 (16), 03.05.10 (15), 04.05.07 (00), 05.02 (03)]
Whenassigning a fixed or floating point value to a variable, the stored
value need only be represented as a model numberof the variable’s subtype.
Furthermore, if no exception is raised by the assignment, the stored value
belongs to the subtype of the variable.
If a real subtype is used as the type mark in a membershiptest, qualification, or explicit conversion, the corresponding operation is performed with
the accuracy of the base type and the range of the subtype.
For a real subtype, the value of the attributes FIRST or LASTis represented
with at least the accuracy of the base type. The values of other attributes of
a real subtype are given exactly.

Ada LanguageInterpretations

G-31

Al-00408/11: Effect of compiling generic unit bodies separately [10.03 (06)]
An implementation is allowed to create a dependence on a generic unit body
such that successfully compiling (or recompiling) the body separately makes
previously compiled units obsolete if they contain an instantiation of the
generic unit. A similar dependence can be created for separately compiled
subunits of a generic unit.
Al-00409/05: Static subtype namescreated by instantiation [12.03 (05),
04.09 (11)]
A subtype can be nonstatic in a generic template and static in a corresponding instance.

Ai-00412/06: Expanded namesfor generic formal parameters
[04.01.03 (15), 04.01.03 (18), 12.01 (05)]
A formal parameter of a generic unit can be denoted by an expanded name.
Al-00418/06: Self-referencing with clauses [10.01 (03)]
Circular dependences amonglibrary units are not allowed, i.e., the library
unit being compiled cannot have the same nameasa previously compiled
library unit if a with clause for the unit being compiled establishes a direct
or indirect dependence on the previously compiled unit.
Al-00422/06: Representation clauses for derived enumeration and record
types [13.01 (03), 13.03 (02), 13.04 (02)]
An enumeration representation clause or a record representation clause can
be given for an enumeration type or a record type declared by a derived type
declaration.
The index subtype for the aggregate used in an enumeration representation
clause is the base type of the enumeration type.
A record representation clause for a first named subtype can specify the
representation of any component that belongs to the record’s base type, even
if the subtype is constrained.
Al-00426/05: Operations on undefined array values [03.02.01 (18),
04.05.01 (03)]
If both operands of a predefined logical operator do not have the same
number of components, CONSTRAINT_ERRORis raised, even if one of the
operandshas a scalar component with an undefined value.

G-32

Ada Language Interpretations

Al-00430/05: Using an enumeration literal does not raise
PROGRAM_ERROR[03.05.01 (03), 03.09 (08)]
The use of an enumeration literal (i.e., a call of the corresponding parameterless function) does not raise PROGRAM_ERROR.
Al-00431/05: Boolean operators producing out of range results
[04.05.01 (03)]
Predefined logical operations on boolean arrays are performed on a
component-by-component basis, using the predefined logical operation for the
componenttype (even if a user-defined logical operation for the component
type is visible and hides the predefined one).
Al-00441/06: A task without dependents can be completed but not
terminated [09.04 (06)]
A task that has no dependent tasks can be completed but not yet terminated,
i.e, T7 CALLABLE can be FALSE when T’ TERMINATEDis not yet TRUE.
Al-00444/05: Conditional entry calls can be queued momentarily
[09.07.02 (01)]
A conditional entry call may (momentarily) increase the COUNTattribute of
an entry, even if the conditional call is not accepted.
Al-00446/05: Raising an exception in an abnormally completed task
[09.10 (06), 11.04 (01)]
An exception can be propagated to an abnormally completed task that is
engaged in a rendezvousor that is waiting for a task to be activated. If this
occurs, the exception has noeffect.
Al-00449/04: Evaluating default discriminant expressions [03.03.02 (06)]
Default discriminant expressions are not evaluated when a subtypeindica-

tion is elaborated.

Al-00455/05: Raising an exception before the sequence of statements
[11.04.01 (03)]
If an exception is raised due to the attempt to activate a task and the
exception is raised after elaboration of a declarative part and just before
execution of a sequence of statements, the sequence of statements is not
executed and control is transferred in the same manneras for an exception
raised in the sequence of statements.

Ada LanguageInterpretations

G-—33

Al-00464/05: Delay statements executed by the environment task
[09.06 (01)]
Delay statements can be executed by the environment task whena library
package is elaborated. Such statements delay the environmenttask.
Al-00466/04: I/O performed bylibrary tasks [14.01 (07)]
The language does not define what happensto external files after the
completion of the main program and before completion of all the library
tasks.
Al-00475/05: Multiplication of fixed point values by negative integers
[04.05.05 (08)]
If the integer in an integer multiplication of a fixed point value is negative,
the multiplication is equivalent to changing thesign of the fixed point value
followed by repeated addition.
Al-00493/05: Operator symbols that represent the same operator
[06.03.01 (04)]
Twostring literals serving as operator symbols represent the same operator
if the string literals are identical or if the only difference is that some letters
appear in uppercase rather than lowercase.
Al-00508/03: The safe numbers of a fixed point subtype [03.05.09 (11)]
The safe numbersof a fixed point subtype are the safe numbersofits
base type.
Al-00516/05: The safe interval for a fixed/integer result [04.05.07 (04)]
Whena fixed point value is divided by an integer value, the result model interval is determined by considering the integer value to be a model interval
consisting of a single integer value.

G-34

Ada LanguageInterpretations

Index
An entry exists in this index for each technical term or phrase that is defined in the
reference manual. The term or phrase is in boldface and is followed by the section
number whereit is defined, also in boldface, for example:
Record aggregate 4.3.1

References to other sections that provide additional information are shown after a
semicolon, for example:
Record aggregate 4.3.1; 4.3
References to other related entries in the index follow in brackets, and a line thatis
indented below a boldface entry gives the section numbers where particular uses of the

term or phrase can be found; for example:
Record aggregate 4.3.1; 4.3

[see also: aggregate]

as a basic operation 3.3.3; 3.7.4

in a code statement 13.8

The index also contains entries for different parts of a phrase, entries that correct
alternative terminology, and entries directing the reader to information otherwise hard
to find, for example:

Check

[see: suppress pragma]

The entries for the VAX Ada technical terms, phrases, references, and so on have been

incorporated into the index following the established conventions. Additions to an
existing entry have been added to the end ofthe entry; additional main entries have
been inserted directly into the existing index. All VAX Ada additions are distinguished
by colored print.

Index—1

Abandonelaboration or evaluation (of
declarations or statements)
[see: exception, raise statement]
Abnormaltask 9.10; 9.9
[see also: abort statement]
as recipient of an entry call 9.7.2, 9.7.3,
11.5; 9.5
raising tasking_error in a calling task
11.5; 9.5

Accesstype 3.8; 3.3, D
[see also: allocator, appropriate for a type,
class of type, collection, derived type of
an access type, null access value, object
designated by ... ]
as a derived type 3.4
as a generic formal type 12.1.2, 12.3.5
deallocation [see: unchecked_

deallocation]
designating a limited type 7.4.4
designating a task type determining task
dependence 9.4
formal parameter 6.2
namein a controlled pragma 4.8
objectinitialization 3.2.1
operation 3.8.2
prefix 4.1
value designating an object 3.2, 4.8
value designating an object with
discriminants 5.2
with a discriminant constraint 3.7.2

Abort statement 9.10
[see also: abnormal task, statement, task]
as a simple statement 5.1
Abs unary operator 4.5.6; 4.5
[see also: highest precedence operator]
as an operation of a fixed point type
3.5.10
as an operation of a floating point type
3.5.8
as an operation of an integer type 3.5.5
in a factor 4.4
Absolute global symbol D; 13.9a.2.1, 13.9a.2.2,
13.9a.2.3
Absolute value operation 4.5.6
Acceptalternative (of a selective wait) 9.7.1
for an interrupt entry 13.5.1
Accept statement 9.5; 9, D
[see also: entry call statement, simple name
in... , Statement, task]
accepting a conditional entry call 9.7.2
accepting a timed entry call 9.7.3
and optimization with exceptions 11.6
as a compound statement 5.1
as part of a declarative region 8.1
entity denoted by an expanded name
4.1.3
in an abnormal task 9.10
in a select alternative 9.7.1
including an exit statement 5.7
including a goto statement 5.9
including a return statement 5.8
raising an exception 11.5
to communicate values 9.11
Access to external files 14.2

Index—2

with an index constraint 3.6.1

input-output of 14.1

Accesstype definition 3.8; 3.3.1, 12.1.2
as a generic type definition 12.1
Access_check
[see: constraint_error, suppress] _
[see also: address (predefined attribute); bit
(VAX Ada predefinedattribute)]
Accuracy

of a numeric operation 4.5.7
of a numeric operation of a universal type
4.10

Activation
[see: task activation]
Actual object
[see: generic actual object]
Actual parameter6.4.1; D; (of an operator) 6.7; (of
a subprogram) 6.4; 6.2, 6.3
[see also: entry call, formal parameter,
function call, procedure call statement,
subprogram call]
characteristics and overload resolution
6.6
in a generic instantiation
[see: generic actual parameter]
of an array type 3.6.1
of a record type 3.7.2

of a task type 9.2
that is an array aggregate 4.3.2
that is a loop parameter 5.5
Actual parameterpart 6.4
in a conditional entry call 9.7.2
in an entry call statement 9.5
in a function call 6.4
in a procedurecall statement 6.4
in a timed entry call 9.7.3
Actualpart
[see: actual parameter part, generic actual
part]
|
Actual subprogram
[see: generic actual subprogram]
Actual type
[see: generic actual type]
Adding operator
[see: binary adding operator, unary adding
operator]
ADD_INTERLOCKED (VAX Adapredefined
procedure)
[see:system.add_interlocked]
Addition operation 4.5.3
accuracy for a real type 4.5.7
ADDRESS(predefinedattribute) 13.7.2; 3.5.5,

3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2, 9.9, 13.7, A
[see also: address clause, system.address]
ADDRESS(predefined type)
[see: system.address]
Address clause 13.5; 13.1, 13.7
[see also: storage address, system.address]
as a representation clause 13.1
for an entry 13.5.1
ADDRESS_ZERO(VAX Adapredefined constant)
[see: system.address_zero]
AFT (predefined attribute) for a fixed point type
3.5.10; A
Aft field of text_io output 14.3.8, 14.3.10

Aggregate 4.3, D
[see also: array aggregate, overloading
of... , record aggregate]
as a basic operation 3.3.3; 3.6.2, 3.7.4
as a primary 4.4
in an allocator 4.8
in a code statement 13.8
in an enumeration representation clause
13.3
in a qualified expression 4.7
must not be the argumentof a conversion
4.6
of a derived type 3.4
ALIGNED_WORD(VAX Adapredefined type)
[see: system.aligned_word]
Alignment clause (in a record representation
clause) 13.4
All in a selected component 4.1.3
Allocation
of array and record components 13.1,
13.4
of variables forced to memory with
representation attribute address 13.7.2
Allocation of processing
resources 9.8
Allocator 4.8; 3.8, D
[see also: access type, collection, exception
raised during ... , initial value, object,
overloading of ... ]
as a basic operation 3.3.3; 3.8.2
as a primary 4.4
creating an object with a discriminant 4.8;
5.2
for an array type 3.6.1
for a generic formal access type 12.1.2
for a private type 7.4.1
for a record type 3.7.2
for a task type 9.2; 9.3
must not be the argument of a conversion
4.6
raising storage_error dueto the size of
the collection being exceeded 11.1
setting a task value 9.2
without storage check 11.7
Allowed 1.6

Alternate key in an indexed accessfile 14.2a
Index—3

Alternative
[see: accept alternative, case statement
alternative, closed alternative, delay
alternative, open alternative, select alternative,
selective wait, terminate alternative]
Ambiguity
[see: overloading]
Ampersand
[see: catenation]
character 2.1
delimiter 2.2
Ancestor library unit 10.2
And operator
[see: logical operator]
And then control form
[see: short circuit control form]
Anonymous type 3.3.1; 3.5.4, 3.5.7, 3.5.9, 3.6, 9.1
Anonymousbasetype
[see: first named subtype]
ANSI (american national standardsinstitute) 2.1
Apostrophecharacter2.1
in a character literal 2.5

Apostrophe delimiter 2.2
in an attribute 4.1.4
of a qualified expression 4.7
Apply 10.1.1
Appropriate for a type 4.1
for an array type 4.1.1, 4.1.2
for a record type 4.1.3
for a task type 4.1.3
Arbitrary selection of select alternatives 9.7.1
Argument association in a pragma 2.8
Argumentidentifier in a pragma 2.8
Arithmetic operator 4.5
[see also: binary adding operator,
exponentiating operator, multiplying operator,
predefined operator, unary adding operator]
as an operation of a fixed point type
3.5.10

Index—4

as an operation of a floating point type
3.5.8
as an operation of an integer type 3.5.5
rounding for real types 13.7.3
Array aggregate 4.3.2; 4.3
[see also: aggregate]
as a basic operation 3.3.3; 3.6.2
in an enumeration representation clause
13.3
Array assignment5.2.1
Array bounds
[see: bound of an array]
Array component
[see: array type, component, indexed
component]
[see also: allocation]
Array type 3.6; 3.3, D
[see also: component, composite type,
constrained array, constrained ... , index,
matching components, null slice, slice,
unconstrained ... ]
as a full type 7.4.1
as a generic formal type 12.1.2
as a generic parameter 12.3.4
as the type of a formal parameter 6.2
conversion 4.6
for a prefix of an indexed component
4.1.1
for a prefix of a slice 4.1.2
operation 3.6.2; 4.5.2, 4.5.3
operation on an array of boolean
components 4.5.1, 4.5.6
with a componenttype with discriminants
3.7.2
with a limited componenttype 7.4.4
maximum number of dimensions in VAX
Ada F
Array type definition 3.6; 3.3.1, 12.1.2, 12.3.4
[see also: constrained array definition,
elaboration of ... , unconstrained array
definition]
as a generic type definition 12.1
Arrow compounddelimiter 2.2
ASCII (american standard code for information
interchange) 2.1

as a primary 4.4
in a length clause 13.2
in a static expression in a generic unit
12.1
of an access type 3.5.8
of an array type 3.6.2
of a derived type 3.4
of a discrete type or subtype 3.5.5
of an entry 9.9
of a fixed point type 3.5.10
of a floating point type 3.5.8
of an object of a task type 9.9
of a private type 7.4.2; 3.7.4
of a record type 3.7.4
of a static subtype in a static expression
4.9
of a task type 9.9
of a type 3.3
of a type as a generic actual function
12.3.6
of a type with discriminants 3.7.4
renamed as a function 8.5
that is a function 3.5.5

ASCIl (predefined library package) 3.5.2; 2.6, C
[see also: graphical symbol]
Assignment compound delimiter 2.2; 5.2
in an object declaration 3.2.1
Assignmentoperation 5.2; D
[see also: initial value, limited type]
as a basic operation 3.3, 3.3.3; 3.5.5,
3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2,
12.1.2
for a generic formal type 12.1.2
not available for a limited type 7.4.4
of an array aggregate 4.3.2
of aninitial value to an object 3.2.1
to an array variable 5.2.1; 5.2
to a loop parameter 5.5
to an object designated by an access
value 3.8
to a shared variable 9.11
Assignment statement 5.2; D
[see also: statement]
as a simple statement 5.1
ASSIGN_TO_ADDRESS(VAX Ada generic
procedure)
[see: system.assign_to_address]
Associated declarative region of a declaration or
statement 8.1
Association
[see: Component association, discriminant
association,
generic association, parameter
association]
AST_ENTRY(VAX Adapredefined attribute)
9.12a; A

AST_ENTRY(VAX Ada predefined pragma)
9.12a; B
AST_HANDLER(VAX Adapredefined type)
[see: system.ast_handler]
Asynchronous system trap (AST) handled by
tasks 9.12a; D
Attribute 4.1.4; D
[see also: predefined attribute, representation
attribute]
as a basic operation 3.3.3
as aname 4.1

Attribute designator 4.1.4
AUX_lO_EXCEPTIONS(VAX Adapredefined inputoutput package) 14.4; 14.2a.3, 14.2a.5, 14.2b.8,
14.2b.10
specification 14.5a

Bar

[see: vertical bar]

BASE (predefined attribute) 3.3.3; A
for an access type 3.8.2
for an array type 3.6.2
for a discrete type 3.5.5
for a fixed point type 3.5.10
for a floating point type 3.5.8
for a private type 7.4.2
for a record type 3.7.4
Base type (of a subtype) 3.3
as a Static subtype 4.9
as target type of a conversion 4.6
due to elaboration of a type definition
3.3.1

Index—5

name [see: nameof a basetype]
of an array type 3.6; 4.1.2
of a derived subtype 3.4
of a discriminant determining the set of
choices of a variant part 3.7.3
of a fixed point type 3.5.9
of a floating point type 3.5.7
of a formal parameterof a generic formal
subprogram 12.1.3
of an integer type 3.5.4
of a parent subtype 3.4
of a qualified expression 4.7
of a type mark 3.3.2
of a type mark in a membershiptest 4.5.2
of the discrete range in a loop parameter
specification 5.5
of the expression in a case statement 5.4
of the result of a generic formal function
12.1.3
of the result subtype of a function 5.8
of the subtypeindication in an access
type definition 3.8
of the type in the declaration of a generic
formal object 12.1.1
of the type mark in a renaming
declaration 8.5
Basedliteral 2.4.2; 14.3.7
[see also: colon character, sharp character]
as a numericliteral 2.4
Basic character 2.1
[see also: basic graphic character, character]
Basic characterset 2.1
is sufficient for a program text 2.10

of an array type 3.6.2
of a derived type 3.4
of a discrete type 3.5.5
of a fixed point type 3.5.10
of a floating point type 3.5.8
of a limited type 7.4.4
of a private type 7.4.2
of a record type 3.7.4
of a task type 9.9
propagating an exception 11.6
raising an exception 11.4.1
that is an attribute 4.1.4
Belong

to a range 3.5
to a subtype 3.3
to a subtype of an access type 3.8

Binary adding operator 4.5; 4.5.3, C
[see also: arithmetic operator, overloading of
an operator]
for time predefined type 9.6
in a simple expression 4.4
overloaded 6.7
Binary operation 4.5
Bit

[see: storage bits]

BIT (VAX Ada predefinedattribute) 13.7.2; A
Bit array D; 13.9a.1.2
BIT_ARRAY (VAX Adapredefined type)
[see: system.bit_array]
Bit string 13.9a.1.2; D

Basic declaration 3.1
as a basic declarative item 3.9

Blank skipped by a text_io procedure 14.3.5

Basic declarative item 3.9
in a package specification 7.1; 7.2

Block name 5.6
declaration 5.1

Basic graphic character 2.1
[see also: basic character, digit, graphic
character, space character, special character,
upper caseletter]
Basic operation 3.3.3
[see also: operation, scope of... ,
visibility .. . ]
accuracy for a real type 4.5.7
implicitly declared 3.1, 3.3.3
of an accesstype 3.8.2
Index—6

implicitly declared 3.1

Block statement5.6; D
[see also: completed block statement,
statement]
as a compound statement5.1
as a declarative region 8.1
entity denoted by an expanded name
4.1.3
having dependent tasks 9.4
including an exception handler 11.2; 11
including an implicit declaration 5.1

including a suppress pragma 11.7
raising an exception 11.4.1, 11.4.2

Body 3.9; D
[see also: declaration, generic body, generic
package body, generic subprogram body,
library unit, package body, proper body,
subprogram body, task body]
as a later declarative item 3.9

Boundof a scalar type 3.5
Boundof a slice 4.1.2
Box compounddelimiter 2.2
in a generic parameter declaration 12.1,

12.1.2, 12.1.3; 12.3.3
in an index subtype definition 3.6
Bracket
[see: label bracket, left parenthesis,

Body stub 10.2; D
acting as a subprogram declaration 6.3
as a body 3.9
as a portion of a declarative region 8.1
must be in the same declarative region
as the declaration 3.9, 7.1
BOOLEAN(predefined type) 3.5.3; C
derived 3.4; 3.5.3
result of a condition 5.3
result of an explicitly declared equality
operator 6.7

Boolean expression
[see: condition, expression]
Boolean operator
[see: logical operator]
Boolean type 3.5.3
[see also: derived type of a booleantype,
predefined type]
operation 3.5.5; 4.5.1, 4.5.2, 4.5.6
operation comparing real operands 4.5.7
Bound
[see: error bound, first attribute, last attribute]
Boundofan array 3.6, 3.6.1
[see also: index range, slice]
aggregate 4.3.2
ignored due to index_check suppression
11.7
initialization in an allocator constrains the
allocated object 4.8
that is a formal parameter 6.2
that is the result of an operation 4.5.1,
4.5.3, 4.5.6
Bound of a range 3.5; 3.5.4
of a discrete rangein a slice 4.1.2
of a discrete rangeis of universal_integer
type 3.6.1

of a static discrete range 4.9

parenthesized expression, right parenthesis,
string bracket]

CALENDAR(predefinedlibrary package) 9.6; C
Call

[see: conditional entry call, entry call
statement, function call, procedure call
statement, subprogram cail, timed entry call]

CALLABLE(predefined attribute)
for an abnormal task 9.10
for a task object 9.9; A
Calling conventions
[see: subprogram declaration]
of a subprogram written in another
language 13.9
Cancelation of an entry call statement 9.7.2, 9.7.3
Carriage return format effector 2.1
Caseof a letter
[see: letter, lower case letter, upper case
letter]
Case statement 5.4
[see also: statement]
as a compoundstatement 5.1
Case statementalternative 5.4

Catenation operation 4.5.3
for an array type 3.6.2
in a replacementof a string literal 2.10
Catenation operator 4.5; 2.6, 3.6.3, 4.5.3, C

[see also: predefined operator]

index—7

Cell in a relative accessfile 14.2a

Character 2.1
[see also: ampersand, apostrophe, basic
character, colon, divide, dot, equal,
exclamation mark character, graphic character,
greater than, hyphen, less than, minus, other
special character, parenthesis, percent, period,
plus, point character, pound sterling, quotation,
semicolon, sharp, space, special character,
star, underline, vertical bar]
in a lexical element 2, 2.2

namesof characters 2.1
replacementin program text 2.10
image of a nongraphic 3.5.5
CHARACTER(predefined type) 3.5.2; C
as the componenttype of the type string
3.6.3

Class of type 3.3; 12.1.2
[see also: access type, composite type,
private type, scalar type, task type]
of a derived type 3.4
Clause
[see: address clause, alignment clause,
component clause, context clause,
enumeration representation clause, length
clause, record representation clause,
representation clause, use clause, with
clause]
CLEAR_INTERLOCKED(VAX Adapredefined
procedure)
[see: system.clear_interlocked]
CLOCK(predefined function) 9.6
[see also: system.tick]

Characterliteral 2.5; 3.5.2, 4.2
[see also: scope of ... , space character
literal, visibility of ... ]
as a basic operation 3.3.3
as an enumerationliteral 3.5.1
as a name 4.1
as a selector 4.1.3
declared by an enumerationliteral
specification 3.1
in a static expression 4.9
in homograph declarations 8.3
must bevisible at the place of a string
literal 4.2

CLOSE(input-output procedure)
in an instance of direct_io 14.2.1; 14.2.5

Character type 3.5.2; 2.5
operation 3.5.5

Closed alternative (of a selective wait) 9.7.1; 11.1
[see also: alternative]

Check
[see: suppress pragma]

Closed file 14.1

Choice 3.7.3
[see also: exception choice]
in an aggregate 4.3
in an array aggregate 4.3.2
in a case statement alternative 5.4
in a componentassociation 4.3, 4.3.1,
4.3.2
in a record aggregate 4.3.1
in a variant of a record type definition
3.7.3
Circularity in dependences
between compilation units 10.5

Index—8

in an instance of sequential_io 14.2.1;
14.2.3

in text_io 14.2.1; 14.3.10
in an instance of indexed_io 14.2.1;
14.2a.5
in an instance of relative_io 14.2.1;
14.2a.3
in direct_mixed_io 14.2.1; 14.2b.6
in indexed_mixed_io 14.2.1; 14.2b.10
in relative_mixed_io 14.2.1; 14.2b.8
in sequential_mixed_io 14.2.1; 14.2b.4

Code statement 13.8
[see also: statement]
as a simple statement 5.1
COL (text_io function) 14.3.4; 14.3.10
raising an exception 14.4
Collection (of an access type) 3.8; 4.8, D
[see also: access type, allocator, length
clause, object, storage units allocated,
storage_size attribute]

of a derived access type 13.2; 3.4

Colon character 2.1
[see also: basedliteral]
replacing sharp character 2.10

Colon delimiter 2.2

Completed block statement 9.4

Column 14.3.4

Completed subprogram 9.4

Comma

Completed task 9.4; 9.9
[see also: tasking_error, terminated task]
as recipient of an entry call 9.5, 9.7.2,
9.7.3
becoming abnormal 9.10
completion during activation 9.3
due to an exception in the task body
11.4.1, 11.4.2

character2.1
delimiter 2.2

Comment2.7; 2.2
in a conforming construct 6.3.1
Communication
between tasks [see: accept statement,
entry, rendezvous]
of values betweentasks 9.5, 9.11
Comparison
[see: relational operator]
Compatibility (of constraints) 3.3.2
[see also: constraint]
failure not causing constraint_error 11.7
of a discrete range with an index subtype
3.6.1
of discriminant constraints 3.7.2
of fixed point constraints 3.5.9
of floating point constraints 3.5.7
of index constraints 3.6.1
of range constraints 3.5
Compilation 10.1; 10, 10.4
as a sequenceof lexical elements 2
including an inline pragma 6.3.2
Compilation order
[see: order of compilation]
Compilation unit 10.1; 10, 10.4, D
{see also: library unit, secondary unit]
compiled afterlibrary units namedin its
context clause 10.3
followed by an inline pragma 6.3.2
with a context clause 10.1.1
with a use clause 8.4
Compile time evaluation of expressions 10.6; 4.9
Compiler 10.4
Compilerlisting
[see: list pragma, page pragma]

Component(of a composite type) 3.3; 3.6, 3.7, D
[see also: component association, component
clause, componentlist, composite type,
default expression, dependence on a
discriminant, discriminant, indexed component,
object, record type, selected component,
subcomponent]
combined by aggregate 4.3
depending on a discriminant 3.7.1; 11.1
namestarting with a prefix 4.1
of an array 3.6 [see also: array type]
of a constant 3.2.1
of a derived type 3.4
of an object 3.2
of a private type 7.4.2
of a record 3.7 [see also: record type]
of a variable 3.2.1
simple name as a choice 3.7.3
subtype 3.7
subtypeitself a composite type 3.6.1,
3.7.2
that is a task object 9.3
whosetypeis a limited type 7.4.4
biasing of 13.4
Componentassociation 4.3
in an aggregate 4.3
including an expression that is an array
aggregate 4.3.2
named componentassociation 4.3
named component association for
selective visibility 8.3
positional component association 4.3
Componentclause (in a record representation
clause) 13.4

Compiler optimization
[see: optimization, optimize pragma]

Index—9

Component declaration 3.7
[see also: declaration, record type definition]
as part of a basic declaration 3.1
having an extended scope 8.2
in a componentlist 3.7
of an array object 3.6.1
of a record object 3.7.2
visibility 8.3
Componentlist 3.7
in a record type definition 3.7
in a variant 3.7.3
Componentsubtype definition 3.7
[see also: dependence on a discriminant]
in a component declaration 3.7
Componenttype
catenation with an array type 4.5.3
object initialization [see: initial value]
of an expression in an array aggregate
4.3.2
of an expression in a record aggregate
4.3.1
of a generic formal array type 12.3.4
operation determining a composite type
operation 4.5.1, 4.5.2
Composite type 3.3; 3.6, 3.7, D
[see also: array type, class of type,
component, discriminant, record type,
subcomponent]
including a limited subcomponent 7.4.4
including a task subcomponent9.2
object initialization 3.2.1 [see also:
initial value]
of an aggregate 4.3
with a private type component 7.4.2
Compounddelimiter 2.2
[see also: arrow, assignment, box, delimiter,
double dot, double star, exponentiation,
greater than or equal, inequality, left label
bracket, less than or equal, right label bracket]
namesof delimiters 2.2
Compoundstatement5.1
[see also: statement]
including the destination of a goto
statement 5.9
Concatenation

[see: catenation]

Index—10

Condition 5.3
[see also: expression]
determining an open alternative of a
selective wait 9.7.1
in an exit statement 5.7
in an if statement 5.3

in a while iteration scheme 5.5
Condition (VAX) handling in an Ada program
11.2, D
Condition Handling Facility (VAX) 11
Condition value (VAX) D; 13.9a.3.1, 13.9a.3.2
Conditional compilation 10.6
Conditional entry call 9.7.2; 9.7
and renamed entries 8.5

subject to an address clause 13.5.1

Conforming 6.3.1
discriminant parts 6.3.1; 3.8.1, 7.4.1

formal parts 6.3.1
formal parts in entry declarations and
accept statements 9.5
subprogram specifications 6.3.1; 6.3

subprogram specifications in body stub
and subunit 10.2
type marks 6.3.1; 7.4.3
Conjunction
[see: logical operator]
Constant 3.2.1; D
{see also: deferred constant, loop parameter,
object]
access object 3.8
formal parameter 6.2
generic formal object 12.1.1, 12.3
in a static expression 4.9
renamed 8.5
that is a slice 4.1.2
Constant declaration 3.2.1
[see also: deferred constant declaration]
as a full declaration 7.4.3
with an array type 3.6.1
with a record type 3.7.2
CONSTRAINED (predefined attribute)
for an object of a type with discriminants
3.7.4; A
for a private type 7.4.2, A

Constrained array definition 3.6
in an object declaration 3.2, 3.2.1
Constrained array type 3.6
[see also: array type, constraint]
Constrained subtype 3.3; 3.2.1, 3.6, 3.6.1, 3.7,
3.7.2, 6.4.1, 12.3.4
[see also: constraint, subtype, type,
unconstrained subtype]
due to elaboration of a type definition
3.3.1
due to the elaboration of a derived type
definition 3.4
object declarations 3.2.1
of a subtypeindication in an allocator 4.8
Constraint (on an object of a type) 3.3, 3.3.2; D
[see also: accuracy constraint, compatibility,
constrained subtype, dependence on
a discriminant, discriminant constraint,

elaboration of ... , fixed point constraint,
floating point constraint, index constraint,
range constraint, satisfy, subtype,
unconstrained subtype]
explicitly specified by use of a
qualification 4.7
in a subtypeindication in an allocator 4.8
not considered in overload resolution 8.7
on a derived subtype 3.4
on a formal parameter6.2
on a formal parameter of a generic formal
subprogram 12.1.3
on a generic actual parameter 12.3.1
on a generic formal object 12.1.1
on a generic formal parameter 12.1;
12.3.1
on an object designated by an access
value 3.8
on a renamedobject 8.5
on a subcomponentsubject to a
componentclause must bestatic 13.4
on a subtype of a generic formal type
12.1.2
on a type mark in a generic parameter
declaration 12.3.1
on a variable 3.2.1, 3.3, 3.6
on the result of a generic formal function
12.1.3

CONSTRAINT_ERROR(predefined exception) 11.1
[see also: suppress pragma]
raised by an accept statement 9.5
raised by an actual parameternotin the
subtype of the formal parameter 6.4.1
raised by an allocator 4.8
raised by an assignment5.2; 3.5.4
raised by an attribute 3.5.5
raised by a componentof an array
aggregate 4.3.2
raised by a componentof a record
aggregate 4.3.1
raised by an entry call statement 9.5
raised by a formal parameter not in the
subtype of the actual parameter6.4.1
raised by an index value out of bounds
4.1.1, 4.1.2
raised by a logical operation on arraysof
different lengths 4.5.1
raised by a name with a prefix evaluated
to a null access value 4.1
raised by a qualification 4.7
raised by a result of a conversion 4.6
raised by a return statement 5.8
raised by incompatible constraints 3.3.2
raised by integer exponentiation with a
negative exponent 4.5.6
raised by matching failure in an array
assignment 5.2.1
raised by naming of a variant not present
in a record 4.1.3
raised by the elaboration of a generic
‘instantiation 12.3.1, 12.3.2, 12.3.4, 12.3.5

raised by theinitialization of an object
3.2.1
raised by the result of a catenation 4.5.3
raised by a negative value of the
storage_size attribute in a length clause
13.2
Context clause 10.1.1; D
[see also: use clause, with clause]
determining order of elaboration of
compilation units 10.5
in a compilation unit 10.1
including a use clause 8.4
inserted by the environment 10.4
of a subunit 10.2
Context of overload resolution 8.7

[see also: overloading]

Contiguousarray D; 13.9a.1.2

Index—11

Control form
[see: short circuit control form]

Current elementof a relative or indexed access

file 14.2

CONTROLLED (predefined pragma) 4.8; B
Conversion operation 4.6
[see also: explicit conversion, implicit
conversion, numeric type, subtype conversion,
type conversion, unchecked conversion]
applied to an undefined value 3.2.1
as a basic operation 3.3.3; 3.3, 3.5.5,
3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2
between array types 4.6
between numeric types 3.3.3, 3.5.5, 4.6
from universal_fixed type 4.5.5
in a static expression 4.9
of a universal type expression 5.2
of the bounds of a loop parameter5.5
to a derived type 3.4
to a real type 4.5.7
Convertible universal operand 4.6

defined and undefined 14.2

locking of 14.2

Current index of a direct accessfile 14.2, 14.2.1;
14.2.4
Current index of a relative accessfile 14.2a
Current line number 14.3; 14.3.1, 14.3.4, 14.3.5
Current mode of a file 14.1, 14.2.1; 14.2.2, 14.2.4,
14.3, 14.3.5, 14.4

Current page number14.3; 14.3.1, 14.3.4, 14.3.5
Current size of a direct accessfile 14.2
CURRENTINPUT (text_io function) 14.3.2; 14.38.10

CURRENT_OUTPUT(text_io function) 14.3.2;
14.3.10

Copy (parameter passing) 6.2
COUNT(predefined attribute) for an entry 9.9; A
COUNT(predefined integer type) 14.2, 14.2.5,
14.3.10; 14.2.4, 14.3, 14.3.3, 14.3.4, 14.4
COUNT(VAX Adainput-output type) 14.2a
in an instance of relative_io 14.2a.3
in relative_mixed_io 14.2b.8

DATA_ERROR (input-output exception) 14.4;
14.2.2, 14.2.3, 14.2.4, 14.2.5, 14.3.5, 14.3.7,
14.3.8, 14.3.9, 14.3.10, 14.5,14.2a.3, 14.2a.5,
14.2b.4, 14.2b.6, 14.2b.8, 14.2b.10

CREATE(input-output procedure)

Date

in an instance of direct_io 14.2.1; 14.2.5

in an instance of sequential_io 14.2.1;
14.2.3
in text_io 14.2.1, 14.3.1; 14.3.10

raising an exception 14.4
in an instance of indexed_io 14.2.1;
14.2a.1, 14.2a.5
in an instance of relative_io 14.2.1;
14.2a.1, 14.2a.3
in direct_mixed_io 14.2.1; 14.2b.1,
14.2b.6
in indexed_mixed_io 14.2.1; 14.2b.1,
14.2b.10
in relative_mixed_io 14.2.1; 14.2b.1,
14.2b.8
in sequential_mixed_io 14.2.1; 14.2b.4
Current column number14.3; 14.3.1, 14.3.4,
14.3.5, 14.3.6

Index—12

[see: day, month, time, year]

DAY (predefined function) 9.6
Dead codeelimination
[see: conditional compilation]
Deallocation
[see: access type, unchecked_deallocation]
Decimal literal 2.4.1; 14.3.7, 14.3.8 as a numeric
literal 2.4

Decimal number(in text_io) 14.3.7
Decimal point
[see: fixed point, floating point, point
character]

Declaration 3.1; D

[see also: basic declaration, block name
declaration, body, component declaration,
constant declaration, deferred constant
declaration, denote, discriminant specification,
entry declaration, enumerationliteral
specification, exception declaration, exception
raised during ... , generic declaration, generic
formal part, generic instantiation, generic
parameterdeclaration, generic specification,
hiding, implicit declaration, incomplete type
declaration, label declaration, local declaration,
loop name declaration, loop parameter
specification, number declaration, object
declaration, package declaration, package
specification, parameter specification, private
type declaration, renaming declaration,
representation clause, scope of... ,

specification, subprogram declaration,
subprogram specification, subtype declaration,
task declaration, task specification, type
declaration, visibility]
as an overload resolution context 8.7
determinedbyvisibility from an identifier
8.3
madedirectly visible by a use clause 8.4
of an enumerationliteral 3.5.1
of a formal parameter6.1
of a loop parameter5.5
overloaded 6.6
raising an exception 11.4.2; 11.4
to which a representation clause applies
13.1
Declarative item 3.9

[see also: basic declarative item, later
declarative item]
in a code procedure body 13.8
in a declarative part 3.9; 6.3.2
in a package specification 6.3.2
in a visible part 7.4
that is a use clause 8.4

Declarative part 3.9; D
[see also: elaboration of ... ]
in a block statement 5.6
in a package body7.1; 7.3
in a subprogram body 6.3
in a task body 9.1; 9.3
including a generic declaration 12.2
including an inline pragma 6.3.2
including an interface pragma 13.9
including a representation clause 13.1

including a suppress pragma 11.7
including a task declaration 9.3
with implicit declarations 5.1
Declarative region 8.1; 8.2, 8.4
[see also: scope of... ]
determining the visibility of a declaration
8.3
formed by the predefined package
standard 8.6
in which a declaration is hidden 8.3
including a full type definition 7.4.2
including a subprogram declaration 6.3
Declared immediately within
[see: occur immediately within]
Default determination of a representation for an
entity 13.1
Default expression
[see: default initial value, default initialization,
discriminant specification, formal parameter,
generic formal object, initial value]
cannotinclude a forcing occurrence 13.1
for a component3.3; 7.4.3, 7.4.4
for a componentof a derived type object
3.4
for a discriminant 3.7.1; 3.2.1, 3.7.2,
12.3.2
for a formal parameter 6.1, 6.4.2; 6.4,
6.7, 7.4.3
for a formal parameter of a generic formal
subprogram 12.1; 7.4.3
for a formal parameter of a renamed
subprogram or entry 8.5
for a generic formal object 12.1, 12.1.1;
12.3
for the discriminants of an allocated
object 4.8
in a componentdeclaration 3.7
in a discriminant specification 3.7.1
including the name of a private type 7.4.1
Default file 14.3.2; 14.3

Default generic formal
subprogram 12.1; 12.1.3, 12.3.6
Default initial value (of a type) 3.3
[see also: default expression, initial value]
for an access type object 3.8; 3.2.1 [see
also: null access value]
for a record type object 3.7; 3.2.1
Index—13

Default initialization (for an object) 3.2.1, 3.3
[see also: default expression, defaultinitial
value, initial value]
Default mode (of a file) 14.2.1; 14.2.3, 14.2.5,
14.3.10
Default_aft (field length) of fixed_io or float_io
14.3.8; 14.3.10
Default_base of integer_io 14.3.7; 14.3.10

Default_exp (field length) of fixed_io or float_io
14.3.8; 14.3.10
Default_fore (field length) of fixed_io or float_io
14.3.8; 14.3.10
Default_setting (letter case) of enumeration_io
14.3.9; 14.3.10
Default_width (field length)
of enumeration_io 14.3.9; 14.3.10

of integer_io 14.3.7; 14.3.10
Deferred constant 7.4.3

of a limited type 7.4.4

Deferred constant declaration 7.4; 7.4.3
[see also: private part (of a package), visible
part (of a package)]
as a basic declaration 3.1
is not a forcing occurrence 13.1
Definition
[see: access type definition, array type
definition, component subtype definition,
constrained array definition, derived type
definition, enumeration type definition, generic
type definition, index subtype definition, integer
type definition, real type definition, record type
definition, type definition, unconstrained array
definition]
Delay alternative (of a selective wait) 9.7.1
Delay expression 9.6; 9.7.1
[see also: duration]
in a timed entry call 9.7.3
Delay statement 9.6
[see also: statement, task]
as a simple statement5.1
in an abnormal task 9.10
in a select alternative 9.7.1
in a timed entry call 9.7.3
Index—14

DELETE(input-output procedure)
in an instanceof direct_io 14.2.1; 14.2.5
in an instance of sequential_io 14.2.1;
14.2.3
in text_io 14.2.1; 14.3.10
in an instance of indexed_io 14.2.1;

14.2a.5
in an instance of relative_io 14.2.1;
14.2a.3
in direct_mixed_io 14.2.1; 14.2b.6
in indexed_mixed_io 14.2.1; 14.2b.10
in relative_mixed_io 14.2.1; 14.2b.8
in sequential_mixed_io 14.2.1; 14.2b.4
DELETE_ELEMENT(VAX Adainput-output
procedure)
in an instance of indexed_io 14.2a.4,
14.2a.5
in an instance of relative_io 14.2a.2,
14.2a.3
in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8
Delimiter 2.2
[see also: ampersand, apostrophe,arrow,
assignment, colon, compound delimiter, divide,
dot, double dot, equal, exclamation mark,
exponentiation, greater than or equal, greater
than, inequality, label bracket, less than or
equal, less than, minus, parenthesis, period,
plus, point, semicolon, star, vertical bar]
Delta (of a fixed point type) 3.5.9
[see also: fixed point type]
of universal_fixed 4.5.5
DELTA (predefined attribute) 3.5.10; 4.1.4, A
Denote an entity 3.1, 4.1; D
[see also: declaration, entity, name]
Dependence between compilation units 10.3;
10.5
[see also: with clause]
circularity implying illegality 10.5
Dependence on a discriminant 3.7.1; 3.7

[see also: component subtype definition,
component, constraint, discriminant constraint,
discriminant, index constraint, subcomponent,
subtype definition, variant part]
affecting renaming 8.5

by a subcomponentthat is an actual
parameter 6.2
effect on compatibility 3.7.2
effect on matching of components 4.5.2
for an assignment 5.2
Dependenttask 9.4
delaying exception propagation 11.4.1
of an abnormal task 9.10
Derivable subprogram 3.4
prohibiting representation clauses 13.1
Derived subprogram 3.4
as an operation 3.3.3
implicitly declared 3.3.3
Derived type 3.4; D
[see also: parent type]
conversion to or from a parent type or
related type 4.6
of an access type [see: accesstype,
collection]
of an access type designating a task type
determining task dependence9.4
of a booleantype 3.4, 3.5.3
of a limited type 7.4.4
of a private type 7.4.1
subject to a representation clause 13.1,
13.6
Derived type definition 3.4; 3.3.1
[see also: elaboration of ... ]
Descriptor (VAX) D; 13.9a.1.2
Descriptor parameter passing mechanism
13.9a.1.2
Designate 3.8, 9.1; D
[see also: access type, allocator, object
designated by ... , task designated by ...,
task object designated by ... ]
Designated subtype (of an access type) 3.8
Designated type (of an accesstype) 3.8
Designator (of a function) 6.1
[see also: attribute designator, operator,
overloading of ... ]
in a function declaration 4.5
in a subprogram body 6.3
in a subprogram specification 6.1; 6.3

of a generic formal subprogram 12.3.6;
12.1, 12.1.3
of a library unit 10.1
overloaded 6.6
DEVICEERROR (input-output exception) 14.4;
14.2.3, 14.2.5, 14.3.10, 14.5, 14.2a.3, 14.2a.5,
14.2b.4, 14.2b.6, 14.2b.8, 14.2b.10
D_FLOAT (VAX Adapredefined type)
[see system.d_float]
D_floating (VAX floating point type representation)
3.5.7; 3.5.7a
values of for machine-dependent
attributes F
Digit 2.1
[see also: basic graphic character, extended
digit, letter or digit]
in a basedliteral 2.4.2
in a decimalliteral 2.4.1
in an identifier 2.3
Digits (of a floating point type) 3.5.7
[see also: floating point type]
DIGITS (predefined attribute) 3.5.8; 4.1.4, A
Dimensionality of an array 3.6
Direct accessfile 14.2; 14.1, 14.2.1
Direct input-output 14.2.4; 14.2.1
Direct visibility 8.3; D
[see also: basic operation, character
literal, operation, operator symbol, selected
component,visibility]
due to a use clause 8.4
of a library unit due to a with clause
10.1.1
within a subunit 10.2
DIRECT_IO (predefined input-output generic
package) 14.2, 14.2.4; 14, 14.1, 14.2.5, C
exceptions 14.4; 14.5
specification 14.2.5
requisite specification of FORM
parameterwith 14.1b
DIRECT_MIXED_IO (VAX Ada predefined inputoutput package) 14.2b.5; 14.2b.6
requisite specification of FORM
parameter with 14.1b
index—15

Discrete range 3.6, 3.6.1
[see also: range, static discrete range]
as a choice 3.7.3
as a choice in an aggregate 4.3
for a loop parameter 5.5
in a choice in a case statement 5.4
in a generic formal array type declaration
12.1.2; 12.3.4
in an index constraint 3.6
in a loop parameterspecification 5.5
in a slice 4.1.2
of entry indices in an entry declaration
9.5
Discrete type 3.5; D
[see also: basic operation of... ,

enumeration type, index, integer type, iteration
scheme, operation of ... , scalar type]
as a generic actual parameter 12.3.3

Discriminant association 3.7.2
in a discriminant constraint 3.7.2

named discriminant association 3.7.2
named discriminant association for
selective visibility 8.3
positional discriminant association 3.7.2

Discriminant constraint 3.7.2; 3.3.2, D
[see also: dependence on discriminant]
ignored due to access_check suppression
11.7
in an allocator 4.8
on an access type 3.8

violated 11.1

Discriminant part 3.7.1; 3.7
[see also: elaboration of ... ]
absent from a record type declaration 3.7
as a portion of a declarative region 8.1
conforming to another 3.8.1, 6.3.1, 7.4.1
in a generic formal type declaration 3.7.1;

as a generic formal type 12.1.2
expression in a case statement 5.4
of a discriminant 3.7.1
of a loop parameter 5.5
of index valuesof an array 3.6
operation 3.5.5; 4.5.2

Discriminant 3.3, 3.7.1; 3.7, D
[see also: component clause, component,
composite type, default expression,
dependence on... , record type, selected
component, subcomponent]
in a record aggregate 4.3.1
initialization in an allocator constrains the
allocated object 4.8
of a derived type 3.4
of a formal parameter 6.2
of a generic actual type 12.3.2
of a generic formal type 12.3, 12.3.2
of an implicitly initialized object 3.2.1
of an object designated by an access
value 3.7.2; 5.2
of a private type 7.4.2; 3.3
of a variant part must not be of a generic
formal type 3.7.3
simple name in a variant part 3.7.3
subcomponentof an object 3.2.1
with a default expression 3.7.1; 3.2.1
maximum numberin record type F

12.1
in an incomplete type declaration 3.8.1
in a private type declaration 7.4, 7.4.1
in a type declaration 3.3, 3.3.1
must not include a pragma 2.8
_ of a full type declaration is not elaborated
3.3.1
Discriminant specification 3.7.1
[see also: default expression]
as part of a basic declaration 3.1
declaring a component3.7
having an extended scope 8.2
in a discriminant part 3.7.1
visibility 8.3
Discriminant_check
[see: constraint_error, suppress]
[see also: address (predefined attribute),
bit (VAX Ada predefined attribute), size
(predefined attribute)]
Disjunction
[see: logical operator]
Divide

character 2.1
delimiter 2.2

Division operation 4.5.5
accuracy for a real type 4.5.7

Index—16

Division operator
[see: multiplying operator]
Division_check
[see: numeric_error, Suppress]
Dot

[see: double dot]
character 2.1 [see also: double dot, point
character]
delimiter 2.2
delimiter of a selected component 8.3;
4.1.3

Double dot compound delimiter 2.2
Double hyphen starting a comment 2.7
Double star compounddelimiter 2.2
[see also: exponentiation compound delimiter]
DURATION(predefined type) 9.6; C
[see also: delay expression, fixed point type]
of alternative delay statements 9.7.1
VAX Ada values for F

Effect
[see: elaboration has no othereffect]
ELABORATE(predefined pragma) 10.5; B
Elaborated 3.9
Elaboration 3.9; 3.1, 3.3, 10.1, D

[see also: exception raised during ... , order
of elaboration]
optimized 10.6

Elaboration has no other effect 3.1

Elaboration of
an accesstype definition 3.8
an array type definition 3.6
a body stub 10.2
a componentdeclaration 3.7
a component subtype definition 3.7
a constrained array definition 3.6
a declaration 3.1
a declarative item 3.9
a declarative part 3.9

a deferred constant declaration 7.4.3
a derived type definition 3.4
a discriminant constraint 3.7.2
a discriminant part 3.7.1
a discriminant specification 3.7.1
an entry declaration 9.5
an enumeration literal specification 3.5.1
an enumeration type definition 3.5.1
a fixed point type declaration 3.5.9
a floating point type declaration 3.5.7
a formal part 6.1
a full type declaration 3.3.1
a generic body 12.2
a generic declaration 12.1
a generic instantiation 12.3
an incomplete type declaration 3.8.1
an index constraint 3.6.1
an integer type definition 3.5.4
a library unit 10.5
a loop parameterspecification 5.5
an object declaration 3.2.1
a package body 7.3
a package declaration 7.2
a parameterspecification 6.1
a private type declaration 7.4.1
a range constraint 3.5
a real type definition 3.5.6
a record type definition 3.7
a renaming declaration 8.5
a representation clause 13.1
a subprogram body 6.3
a subprogram declaration 6.1
a subtype declaration 3.3.2
a subtype indication 3.3.2
a task body 9.1
a task declaration 9.1
a task specification 9.1
a type declaration 3.3.1, 3.8.1, 7.4.1
a type definition 3.3.1
an unconstrained array definition 3.6
a use Clause 8.4
Elaboration_check
[see: program_error exception, suppress]
Elementin a file 14, 14.1; 14.2
in a direct accessfile 14.2.4

in a sequential accessfile 14.2.2
VAX Ada implementation of 14.1a

index—17

ELEMENT_SIZE (VAX Ada mixed-type input-output
function)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 4.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
ELEMENT_TYPE (generic formal type of direct_io)
14.2.5; 14.1, 14.2.4
ELEMENT_TYPE (generic formal type of
indexed_io) 14.2a.5; 14.2a.4
ELEMENT_TYPE (generic formal type of
relative_io) 14.2a.3; 14.2a.2
ELEMENT_TYPE (generic formal type of
sequential_io) 14.2.3; 14.1, 14.2.2
Else part

of a conditional entry call 9.7.2
of an if statement 5.3
of a selective wait 9.7.1; 11.1

EMAX(predefined attribute) 3.5.8; A
[see also: machine_emax]
VAX Adafloating point values for F
Emin
[see: machine_emin]
Empty string literal 2.6
Endofline 2.2
as a separator 2.2

due to a format effector 2.2
terminating a comment 2.7
END_ERROR(input-output exception) 14.4; 14.2.2,
14.2.3, 14.2.4, 14.2.5, 14.3.4, 14.3.5, 14.3.6,
14.3.10, 14.5,

14.2a.3, 14.2a.4, 14.2a.5, 14.2b.3,

14.2b.4, 14.2b.5, 14.2b.6, 14.2b.8, 14.2b.9,
14.2b.10

END_OF_BUFFER (VAX Ada mixed-type inputoutput function)
in direct_mixed_io 14.2b.2; 14.2b.6
in indexed_mixed_io 14.2b.2; 14.2b.10
in relative_mixed_io 14.2b.2; 14.2b.8
in sequential_mixed_io 14.2b.2; 14.2b.4

index—18

END_OF_FILE(input-output function)
in an instance of direct_io 14.2.4; 14.2.5
in an instance of sequential_io 14.2.2;

14.2.3
in text_io 14.3.1, 14.3.10
in an instance of indexed_io 14.2a.4,
14.2a.5

in an instance of relative_io 14.2a.2,
14.2a.3
in direct_mixed_io 14.2b.5, 14.2b.6
in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8
in sequential_mixed_io 14.2b.3, 14.2b.4
END_OF_LINE (text_io function) 14.3.4; 14.3.10
raising an exception 14.4
END_OF_PAGE (text_io function) 14.3.4; 14.3.10,
14.4
Entry (of a task) 9.5; 9, 9.2, D
[see also: actual parameter, address attribute,
attribute of ... , formal parameter, interrupt
entry, overloading of ... , parameter and
result type profile, parameter, subprogram]
declared by instantiation of a generic
formal parameter 12.3
denoted by an indexed component 4.1.1
denoted by a selected component 4.1.3
name [see: name of an entry]
namestarting with a prefix 4.1
of a derived task type 3.4
of a task designated by an object of a
task type 9.5
renamed 8.5
‘subject to an address clause 13.5, 13.5.1
subject to a representation clause 13.1
[see also: ast_entry]
Entry call 9.5; 9, 9.7.1, 9.7.2, 9.7.3
[see also: actual parameter, conditional entry
call, subprogram call, timed entry call]
to an abnormaltask 9.5, 9.10, 11.5; 9.5
to communicate values 9.11
Entry call statement 9.5
[see also: accept statement, actual parameter,
statement, task declaration, task]
as a simple statement 5.1
in an abnormal task 9.10
in a conditional entry call 9.7.2; 9.5
in a timed entry call 9.7.3; 9.5

Entry declaration 9.5
[see also: elaboration of ... ]
as an overloaded declaration 8.3
as part of a basic declaration 3.1
cannotinclude a forcing occurrence 13.1
having an extended scope 8.2
in a task specification 9.1
including the nameof a private type 7.4.1
visibility 8.3
Entry family 9.5
denoted by a selected component4.1.3
name starting with a prefix 4.1
Entry index (in the name of an entry of a family)
9.5
for an open acceptalternative 9.7.1
in a conditional entry call 9.7.2
in a timed entry call 9.7.3
Entry queue(of calls awaiting acceptance) 9.5
countof calls in the queue 9.9
due to queuedinterrupts 13.5.1
of an abnormal task 9.10
Enumeration literal 3.5.1, 4.2
[see also: overloading of ... , predefined
function]
as an operation 3.3.3
as an operator 3.5.5
as result for imageattribute 3.5.5
as the parameterfor value attribute 3.5.5
implicitly declared 3.3.3
in a static expression 4.9
in pragma system_name 13.7
of a derived type 3.4
overloaded 8.3
renamedas a function 8.5
representation 13.3
maximum number in enumeration type
declaration F
Enumeration literal specification 3.5.1
as part of a basic declaration 3.1
madedirectly visible by a use clause 8.4
Enumeration representation clause
13.3 as a representation clause 13.1
range of possible VAX Ada enumeration
codesfor 13.3
use for achieving signed representation
of enumeration codes 13.3

Enumeration type 3.5.1; 3.3, 3.5, D
[see also: discrete type, scalar type]
as a character type 3.5.2
as a generic formal type 12.1.2
as a generic parameter 12.3.3
boolean 3.5.3
operation 3.5.5
Enumeration type definition 3.5.1; 3.3.1
[see also: elaboration of ... ]
ENUMERATION_IO(text_io inner generic package)
14.3.9; 14.3.10
Environmentof a program 10.4
environmenttask calling the main
program 10.1
EPSILON (predefined attribute) 3.5.8; A
VAX Adafloating point values for F
Equal
character 2.1
delimiter 2.2

Equality operator 4.5; 4.5.2
[see also: limited type, relational operator]
explicitly declared 4.5.2, 6.7; 7.4.4

for an access type 3.8.2
for an array type 3.6.2
for a generic formal type 12.1.2
for a limited type 4.5.2, 7.4.4
for a real type 4.5.7
for a record type 3.7.4

Erroneous execution 1.6
[see also: program_error]
due to an access to a deallocated object
13.10.1
due to an unchecked conversion violating
properties of objects of the result type
13.10.2
due to assignment to a shared variable
9.11
due to changing of a discriminant value
5.2, 6.2
due to dependence on parameter passing
mechanism 6.2
due to multiple address clauses for
overlaid entities 13.5
due to suppression of an exception check
11.7
due to use of an undefined value 3.2.1

Index—19

due to an AST occurrence for an entry of
a terminated task 9.12a
Error boundsof a predefined operation of a real
type 3.5.9, 4.5.7; 3.5.6, 3.5.7
Error detected at

compilation time 1.6
run time 1.6

Error situation 1.6, 11, 11.1; 11.6
Error that may not be detected 1.6
Evaluation (of an expression) 4.5; D
[see also: compile time evaluation,
expression]
at compile time 4.9, 10.6
of an actual parameter6.4.1
of an aggregate 4.3; 3.3.3
of an allocator 4.8
of an array aggregate 4.3.2
of a condition 5.3, 5.5, 5.7, 9.7.1
of a default expression 3.7.2
of a default expression for a formal
parameter6.4.2; 6.1
of a discrete range 3.5; 9.5
of a discrete range used in an index
constraint 3.6.1
of an entry index 9.5
of an expression in an assignment
statement 5.2
of an expression in a constraint 3.3.2
of an expression in a generic actual
parameter 12.3
of an indexed component 4.1.1
of an initial value [see: default
expression]
of a literal 4.2; 3.3.3
of a logical operation 4.5.1
of a name 4.1; 4.1.1, 4.1.2, 4.1.3, 4.1.4
of a name in an abort statement 9.10
of a name in a renaming declaration 8.5
of a nameof a variable 5.2, 6.4.1, 12.3
of a primary 4.4
of a qualified expression 4.7; 4.8
of a range 3.5
of a record aggregate 4.3.1
of a short circuit control form 4.5.1
of a static expression 4.9
of a type conversion 4.6
of a universal expression 4.10
of the boundsof a loop parameter 5.5
of the conditions of a selective wait 9.7.1
Index—20

Evaluation order

[see: order of evaluation]

Exception 11; 1.6, D
[see also: constraint_error, numeric_error,

predefined ... , program_error, raise
statement, raising of ... , storage_error,
tasking_error, time_error]
causing a loop to be exited 5.5
causing a transfer of control 5.1
due to an expression evaluated at
compile time 10.6
implicitly declared in a generic
instantiation 11.1
in input-output 14.4; 14.5
renamed 8.5
suppress pragma 11.7
exporting to a non-Ada program 13.9a.3,
13.9a.3.2
importing from a non-Ada program
13.9a.3, 13.9a.3.1
Exception choice 11.2
Exception declaration 11.1; 11
as a basic declaration 3.1
Exception handler 11.2; D

in an abnormal task 9.10
in a block statement 5.6
in a package body 7.1; 7.3
in a subprogram body 6.3
in a task body 9.1
including a raise statement 11.3
including the destination of a goto

statement 5.9

including the name of an exception 11.1
not allowed in a code procedure body

13.8
|
raising an exception 11.4.1
selected to handle an exception 11.4.1;
11.6
Exception handling 11.4; 11.4.1, 11.4.2, 11.5

Exception propagation 11
delayed by a dependenttask 11.4.1
from a declaration 11.4.2
from a predefined operation 11.6
from a statement 11.4.1
to a communicating task 11.5
maximum numberof frames for F

Exception raised during execution or
elaboration of
an accept statement 11.5
an allocator of a task 9.3
a conditional entry 9.7.2
a declaration 11.4.2; 11.4
a declarative part that declares tasks 9.3
a generic instantiation 12.3.1, 12.3.2,
12.3.4, 12.3.5
a selective wait 9.7.1
a statement 11.4.1; 11.4
a subprogram call 6.3; 6.2, 6.5
a task 11.5
a timed entry call 9.7.3
task activation 9.3
Exceptions and optimization 11.6
Exclamation character2.1

replacing vertical bar 2.10

Exclusive disjunction
[see: logical operator]
Execution
[see: sequence of statements, statement, task

body, task]

EXISTENCE_ERROR(VAX Adainput-output

exception) 14.4; 14.2a.2, 14.2a.3, 14.2a.4, 14.2a.5,

14.2b.7, 14.2b.8, 14.2b.9, 14.2b.10, 14.5a

Exit statement 5.7
[see also: statement]
as a simple statement 5.1
Causing a loop to be exited 5.5
causing a transfer of control 5.1
completing block statement execution 9.4
Expanded name4.1.3; D
denoting a loop 5.5
in a static expression 4.9
of a parent unit 10.2
replacing a simple name 6.3.1
Explicit conversion 4.6
[see also: conversion operation, implicit
conversion, subtype conversion, type
conversion]
from universal_fixed type 4.5.5
to a real type 4.5.7
Explicit declaration 3.1; 4.1

[see also: declaration]

Explicit initialization
[see: allocator, object declaration, qualified
expression]
Exponentof a floating point number 3.5.7; 13.7.3
Exponentpart
in output of real values 14.3.8
of a basedliteral 2.4.1, 2.4.2
of a decimalliteral 2.4.1
Exponentiating operator 4.5; 4.5.6
[see also: highest precedence operator]
in a factor 4.4
overloaded 6.7
Exponentiation compounddelimiter 2.2
[see also: double star compound delimiter]
Exponentiation operation 4.5.6
Export pragmas 13.9a
EXPORT_EXCEPTION (VAX Ada predefined
pragma) 13.9a.3.2; 13.9a, 13.9a.3, B
EXPORT_FUNCTION(VAX Ada predefined
pragma) 13.9a.1.4; 13.9a, 13.9a.1, B
EXPORT_OBJECT (VAX Ada predefined pragma)
13.9a.2.2; 13.9a, 13.9a.2, B
EXPORT_PROCEDURE(VAX Adapredefined
pragma) 13.9a.1.4; 13.9a, 13.9a.1, B
EXPORT_VALUED_PROCEDURE(VAX Ada
predefined pragma) 13.9a.1.4; 13.9a, 13.9a.1, B
Expression 4.4; D
[see also: compile time evaluation, default
expression, delay expression, evaluation,
qualified expression, simple expression, static
expression, universal type expression]
as an actual parameter6.4, 6.4.1
as a condition 5.3
as a generic actual parameter 12.3;
12.3.1
as the argumentof a pragma 2.8
in an actual parameter of a conditional
entry call 9.7.2
in an actual parameter of an entry call
statement 9.5
in an actual parameterof a timed entry
call 9.7.3
in an allocator 4.8
Index—21

in an assignment statement 5.2
in an attribute designator 4.1.4
in a case statement 5.4
in a choice in a case statement 5.4
in a componentassociation 4.3
in a component declaration 3.7
in a constraint 3.3.2
in a conversion 4.6
in a discriminant association 3.7.2
in a discriminant specification 3.7.1
in a generic formal part 12.1
in an indexed component 4.1.1
in a length clause 13.2
in a name of a variable 5.2, 6.4.1
in a numberdeclaration 3.2
in an object declaration 3.2, 3.2.1
in a parameter specification 6.1
in a primary 4.4
in a qualified expression 4.7
in a representation clause 13.1
in a return statement 5.8
in a specification of a derived subprogram
3.4
in a type conversion 8.7
including the nameof a private type 7.4.1
specifying an entry in a family 4.1.1
specifying the value of an index 4.1.1
with a boolean result 4.5.1, 4.5.2, 4.5.6
Extended_digit in a basedliteral 2.4.2
External file 14.1
[see also: file]

Factor 4.4
in aterm 4.4
FALSE boolean enumerationliteral 3.5.3; C

Family of entries
[see: entry family]
FETCH_FROM_ADDRESS(VAX Ada generic
function)
[see: system.fetch_from_address]
F_FLOAT (VAX Adapredefined type)
[see: system.f_float]

Index—22

F_floating (VAX Ada floating point type
representation) 3.5.7, 3.5.7a
values of for machine-dependent
attributes F
FIELD (predefined integer subtype) 14.3.5; 14.3.7,
14.3.10
File (object of a file type) 14.1
[see also: externalfile]
arrangementof values in 14.1a
mixed-type elements in 14.1a, 14.2a
File Definition Language (FDL) 14.1b
File management14.2.1 in text_io 14.3.1
File terminator 14.3; 14.3.1, 14.3.4, 14.3.5, 14.3.6,
14.3.7, 14.3.8, 14.3.9

FILEMODE(input-output type)
in an instance of direct_io 14.1, 14.2.1;
14.2.5
in an instance of sequential_io 14.1,
14.2.1; 14.2.3
in text_io 14.1, 14.2.1; 14.3.10
in an instance of indexed_io 14.2;
14.2a.1, 14.2.1; 14.2a.5
in an instanceof relative_io 14.2; 14.2a.1,
14.2.1; 14.2a.3
in direct_mixed_io 14.2b.1, 14.2.1;
14.2b.6
in indexed_mixed_io 14.2b.1, 14.2.1;
14.2b.10
in relative_mixed_io 14.2b.1, 14.2.1;
14.2b.8
in sequential_mixed_io 14.2b.1, 14.2.1;
14.2b.4
FILETYPE (input-output type)
in an instance of direct_io 14.1, 14.2.1;
14.2, 14.2.4, 14.2.5
in an instance of sequential_io 14.1,
14.2.1; 14.2, 14.2.2, 14.2.3
in text_io 14.1, 14.2.1; 14.2, 14.3.3,
14.3.4, 14.3.6, 14.3.7, 14.3.8, 14.3.9,
14.3.10
in an instance of indexed_io 14.2a.1,
14.2a.4, 14.2a.5
in an instanceof relative_io 14.2a.1,
14.2a.2, 14.2a.3
in direct_mixed_io 14.2b.1, 14.2b.2,
14.2b.5, 14.2b.6

in indexed_mixed_io 14.2b.1, 14.2b.2,
14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.1, 14.2b.2,
14.2b.7, 14.2b.8
in sequential_mixed_io 14.2b.1, 14.2b.2,
14.2b.3, 14.2b.4
FINEDELTA
[see: system.fine_delta]
FIRST (predefined attribute) A
[see also: bound]
for an access value 3.8.2
for an array type 3.6.2
for a scalar type 3.5
VAX Adafloating point values for F
First named subtype 13.1
[see also: anonymous basetype,
representation clause]
FIRST_BIT (predefined attribute) 13.7.2; A
[see also: record representation clause]

Floating point constraint 3.5.7; 3.5.6
on a derived subtype 3.4
Floating point predefined type
[see: FLOAT, LONG_FLOAT, SHORT_FLOAT]
Floating point type 3.5.7; D
[see also: numeric type, real type, scalar type,
system.max_digits]
accuracy of an operation 4.5.7
as a generic actual type 12.3.3

as a generic formal type 12.1.2

error bounds 4.5.7; 3.5.6
operation 3.5.8; 4.5.3, 4.5.4, 4.5.5, 4.5.6
result of an operation out of range of the
type 4.5.7
representation of 3.5.7, 3.5.7a
Font design of graphical symbols 2.1
For loop
[see: loop statement]

Fixed accuracydefinition 3.5.9

Forcing occurrence (of a name leading to default
determination of representation) 13.1

Fixed point constraint 3.5.9; 3.5.6
on a derived subtype 3.4

FORE (predefined attribute) for a fixed point type
3.5.10; A

Fixed point predefined type 3.5.9

Fore field of text_io input or output 14.3.8, 14.3.10;
14.3.5

Fixed point type 3.5.9; D
[see also: basic operation of ... , duration,
numeric type, operation of ... , real type,
scalar type, small, system.fine_delta,
system.max_mantissa]
accuracy of an operation 4.5.7
as a generic actual type 12.3.3
as a generic formal type 12.1.2
error bounds 4.5.7; 3.5.6
operation 3.5.10; 4.5.3, 4.5.4, 4.5.5
result of an operation out of range of the
type 4.5.7
FIXED_IO (text_io inner generic package) 14.3.8;
14.3.10

FORM (input-output function)
in an instance of direct_io 14.2.1; 14.2.5

in an instance of sequential_io 14.2.1,
14.2.3
in text_io 14.2.1; 14.3.10
raising an exception 14.4
in an instance of indexed_io 14.2.1,
14.2a.5
in an instance of relative_io 14.2.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.4
in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.8
in sequential_mixed_io 14.2.1, 14.2b.4

FLOAT(predefined type) 3.5.7; C

Form feed formateffector 2.1

FLOAT_IO (text_io inner generic package) 14.3.8;
14.3.10

Form string of a file 14.1; 14.2.1, 14.2.3, 14.2.5,
14.3.10
VAX Adainterpretation of 14.1b

Floating accuracy definition 3.5.7

Formal object
[see: generic formal object]
Index—23

Formal parameter 6.1; D; (of an entry) 9.5; 3.2,
3.2.1; (of a function) 6.5; (of an operator) 6.7; (of a
subprogram) 6.1, 6.2, 6.4; 3.2, 3.2.1, 6.3
[see also: actual parameter, default
expression, entry, generic formal parameter,
mode, object, subprogram]
as a constant3.2.1
as an object 3.2
as a variable 3.2.1
names and overload resolution 6.6
of a derived subprogram 3.4
of a generic formal subprogram 12.1,
12.1.3
of a main program 10.1
of an operation 3.3.3
of a renamed entry or subprogram 8.5
whosetypeis an array type 3.6.1
whosetype is a limited type 7.4.4
whosetype is a record type 3.7.2
whosetypeis a task type 9.2
maximum numberin a VAX Ada
subprogram or entry declaration F
Formalpart 6.1; 6.4
[see also: generic formal part, parameter type
profile]
conforming to another6.3.1
in an accept statement 9.5
in an entry declaration 9.5
in a subprogram specification 6.1
must not include a pragma 2.8

Frame 11.2
and optimization 11.6
in which an exception is raised 11.4.1,
11.4.2
Full declaration
of a deferred constant 7.4.3

Full type declaration 3.3.1
discriminant part is not elaborated 3.3.1
of an incomplete type 3.8.1
of a limited private type 7.4.4
of a private type 7.4.1; 7.4.2
Function 6.1, 6.5; 6, 12.3, D
[see also: operator, parameter and result type
profile, parameter, predefined function, result
subtype, return statement, subprogram]
as a main program 10.1
renamed 8.5
result [see: returned value]
that is an attribute 4.1.4; 12.3.6
exporting 13.9a.1.4
importing 13.9a.1.1
Function body
[see: subprogram body]

Formal subprogram
{see: generic formal subprogram]

Function call 6.4; 6
{see also: actual parameter, subprogram call]
as a prefix 4.1, 4.1.3
as a primary 4.4
in a static expression 4.9
with a parameter of a derived type 3.4
with a result of a derived type 3.4

Formal type
[see: generic formal type]

Function specification
[see: subprogram specification]

Format effector 2.1
[see also: carriage return, form feed,
horizontal tabulation, line feed, vertical
tabulation]
as a separator 2.2
in an end ofline 2.2
Format of text_io input or output 14.3.5, 14.3.7,
14.3.8, 14.3.9
Formula
[see: expression]

Index—24

Garbagecollection 4.8
Generic actual object 12.3.1; 12.1.1
[see also: generic actual parameter]
Generic actual parameter 12.3; 12
[see also: generic actual object, generic actual
subprogram, generic actual type, generic
association, generic formal parameter, generic
instantiation, matching]

cannot be a universal_fixed operation

Generic declaration 12.1; 12, 12.1.2, 12.2

that is an array aggregate 4.3.2

Generic formal object 12.1, 12.1.1; 3.2, 12.3,

that is a loop parameter 5.5

12.3.1

4.5.5
for a generic formal access type 12.3.5
for a generic formal array type 12.3.4
for a generic formal object 12.1.1
for a generic formal private type 12.3.2
for a generic formal scalar type 12.3.3
for a generic formal subprogram 12.1.3;
12.3.6
.
for a generic formal type 12.1.2
is not static 4.9
that is a task type 9.2
Generic actual part 12.3
Generic actual subprogram 12.1.3, 12.3.6
[see also: generic actual parameter]

Generic actual type
[see: generic actual parameter]

for a generic formal access type 12.3.5
for a generic formal array type 12.3.4
for a generic formal scalar type 12.3.3
for a generic formal type with
discriminants 12.3.2
for a generic private formal type 12.3.2
that is a private type 7.4.1

Generic association 12.3
[see also: generic actual parameter, generic
formal parameter]
named generic association 12.3
named generic association for selective
visibility 8.3

positional generic association 12.3

Generic body 12.2; 12.1, 12.1.2, 12.3.2
[see also: body stub, elaboration of ... ]
in a package body 7.1
including an exception handler 11.2; 11
including an exit statement 5.7
including a goto statement 5.9
including an implicit declaration 5.1
must be in the same declarative region
as the declaration 3.9, 7.1
not yet elaborated at an instantiation 3.9
inlined for each instantiation 12.1a

[see also: elaboration of ... ]
and body as a declarative region 8.1
and proper body in the same compilation
10.3
as a basic declaration 3.1
as a later declarative item 3.9
as a library unit 10.1
in a package specification 7.1
recompiled 10.3

[see also: default expression, generic formal
parameter]
of an array type 3.6.1
of a record type 3.7.2

Generic formal parameter 12.1, 12.3; 12, D
[see also: generic actual parameter, generic

association, generic formal object, generic
formal subprogram, generic formal type,
matching, object]
as a constant 3.2.1
as a variable 3.2.1
of a limited type 7.4.4
of a task type 9.2

Generic formal part 12.1; 12, D
Generic formal subprogram 12.1, 12.1.3; 12.1.2,
12.3, 12.3.6
[see also: generic formal parameter]
formal function 12.1.3
with the same nameas another 12.3

Generic formal type 12.1, 12.1.2; 12.3

[see also: constraint on... , discriminant
of ..., generic formal parameter, subtype
indication ... ]
as index or componenttype of a generic
formal array type 12.3.4
formal access type 12.1.2, 12.3.5
formal array type 12.1.2, 12.3.4
formal array type (constrained) 12.1.2
formal discrete type 12.1.2
formal enumeration type 12.1.2
formal fixed point type 12.1.2
formalfloating point type 12.1.2
formal integer type 12.1.2
formal limited private type 12.3.2
formal limited type 12.1.2
formal part 12.1.2
formal private type 12.1.2, 12.3.2
Index—25

formal private type with discriminants
12.3.2
formal scalar type 12.1.2, 12.3.3
Generic function
[see: generic subprogram]
Generic instance 12.3; 12, 12.1, 12.2, D
[see also: generic instantiation, scope of... ]
inlined in place of each call 6.3.2
of a generic package 12.3
of a generic subprogram 12.3
raising an exception 11.4.1
inlining of body for 12.1a
sharing code generated for 12.1b
Generic instantiation 12.3; 12.1, 12.1.3, 12.2, D
[see also: declaration, elaboration of... ,
generic actual parameter]
as a basic declaration 3.1
as a later declarative item 3.9
as a library unit 10.1
before elaboration of the body 3.9, 11.1
implicitly declaring an exception 11.1
invoking an operation of a generic actual
type 12.1.2
of a predefined input-output package 14.1
recompiled 10.3
with a formal access type 12.3.5
with a formal array type 12.3.4
with a formal scalar type 12.3.3
with a formal subprogram 12.3.6
Generic package 12.1; 12
for input-output 14
instantiation 12.3; 12, 12.1 [see also:
generic instantiation]
specification 12.1 [see also: generic
specification]
Generic package body 12.2; 12.1
[see also: package body]
Generic parameter declaration 12.1; 12.1.1,
12.1.2, 12.1.3, 12.3
[see also: generic formal parameter]
as a declarative region 8.1
having an extended scope 8.2
visibility 8.3
Generic procedure
[see: generic subprogram]

index—26

Generic specification 12.1; 12.3.2
[see also: generic package specification,
generic subprogram specification]
Generic subprogram 12.1; 12 body 12.2; 12.1
[see also: subprogram body]
instantiation 12.3; 12, 12.1 [see also:
generic instantiation]
interface pragma is not defined 13.9
specification 12.1 [see also: generic
specification]
Generic type definition 12.1; 12.1.2, 12.3.3,
12.3.4
Generic unit 12, 12.1; 12.2, 12.3, D

[see also: generic declaration, program unit]
including an exception declaration 11.1
including a raise statement 11.3
subject to a suppress pragma 11.7
with a separately compiled body 10.2
[see also: inline_generic pragma, share_
generic pragma]

Generic unit body
[see: generic body]
Generic unit specification
[see: generic specification]
GET (text_io procedure) 14.3.5; 14.3, 14.3.2,
14.3.4, 14.3.10
for character andstring types 14.3.6

for enumeration types 14.3.9
for integer types 14.3.7
for real types 14.3.8
raising an exception 14.4

GET_ARRAY (VAX Ada mixed-type input-output
procedure)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
GET_ITEM (VAX Ada mixed-type input-output
procedure)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
GET_LINE (text_io procedure) 14.3.6; 14.3.10

G_FLOAT (VAX Adapredefined type)
[see: system.g_float]
G_floating (VAX Ada real type representation)
3.5.7, 3.5.7a
values of for machine-dependent
attributes F
Global declaration 8.1
of a variable shared by tasks 9.11
Global symbolD; 13.9a.1.1, 13.9a.1.4, 13.9a.2.1,
13.9a.2.2, 13.9a.2.3, 13.9a.3.1, 13.9a.3.2
Goto statement 5.9
[see also: statement]
as a simple statement 5.1
causing a loop to be exited 5.5
causing a transfer of control 5.1
completing block statement execution 9.4
Graphic character 2.1
[see also: basic graphic character, character,
lower caseletter, other special character]
in a characterliteral 2.5
in a String literal 2.6
Graphical symbol 2.1
[see also: ascii]
not available 2.10
Greater than
character 2.1
delimiter 2.2
operator[see: relational operator]
Greater than or equal
compounddelimiter 2.2
operator[see: relational operator]
Guard pages for tasks 13.2a

Handler
[see: exception handler, exception handling]

H_floating (VAX Ada floating point type
representation) 3.5.7, 3.5.7a
values of for machine-dependent
attributes F
Hiding (of a declaration) 8.3
[see also: visibility]
and renaming 8.5
and use clauses 8.4
due to an implicit declaration 5.1
of a generic unit 12.1
of a library unit 10.1
of a subprogram 6.6
of or by a derived subprogram 3.4
of the package standard 10.1
within a subunit 10.2
Highest precedence operator 4.5
[see also: abs, arithmetic operator,
exponentiating operator, not unary operator,
overloading of an operator, predefined
operator]
as an operation of a discrete type 3.5.5
as an operation of a fixed point type
3.5.10
as an operation of a floating point type
3.5.8
overloaded 6.7
Homograph (declaration) 8.3
[see also: overloading]
and use clauses 8.4
Horizontal tabulation

as a separator 2.2

character in a comment2.7
format effector 2.1
in text_io input 14.3.5

Hyphen character 2.1
[see also: minus character]
starting a comment2.7

IDENT (VAX Ada predefined pragma) B

H_FLOAT (VAX Ada predefined type)
[see: system.h_float]

index—27

Identifier 2.3; 2.2
[see also: direct visibility, loop parameter,
name, overloading of ... , scope of... ,
simple name, visibility]
and an adjacent separator 2.2
as an attribute designator 4.1.4
as a designator 6.1
as a reserved word 2.9
as a simple name 4.1
can be written in the basic character set
2.10
denoting an object 3.2.1
denoting a value 3.2.2
in a deferred constant declaration 7.4.3
in an entry declaration 9.5
in an exception declaration 11.1
in a generic instantiation 12.3
|
in an incomplete type declaration 3.8.1
in a numberdeclaration 3.2.2
in an object declaration 3.2
in a package specification 7.1
in a private type declaration 7.4; 7.4.1
in a renaming declaration 8.5
in a subprogram specification 6.1
in a task specification 9.1
in a type declaration 3.3.1; 7.4.1
in its own declaration 8.3
in pragma system_name 13.7

of an argumentof a pragma 2.8
of an enumeration value 3.5.1
of a formal parameter of a generic formal
subprogram 12.1.3
of a generic formal object 12.1, 12.1.1
of a generic formal subprogram 12.1;
12.1.3
of a generic formal type 12.1; 12.1.2
of a generic unit 12.1
of a library unit 10.1
of a pragma 2.8
of a subprogram 6.1
of a subtype 3.3.2
of a subunit 10.2
of homograph declarations 8.3
overloaded 6.6
versus simple name 3.1
maximum VAX Ada length F
identifier list 3.2
in a componentdeclaration 3.7

in a deferred constant declaration 7.4

in a discriminant specification 3.7.1
in a generic parameter declaration for
generic formal objects 12.1
Index—28

in a numberdeclaration 3.2
in an object declaration 3.2
in a parameter specification 6.1
Identity operation 4.5.4
If statement 5.3
[see also: statement]
as a compound statement5.1
Illegal 1.6
IMAGE (predefinedattribute) 3.5.5; A

immediate scope 8.2; 8.3
Immediately within (a declarative region)
[see: occur immediately within]
Implementation defined
[see: system dependent]
Implementation defined pragma F
Implementation dependent
[see: system dependent]
implicit conversion 4.6
[see also: conversion operation, explicit
conversion, subtype conversion]
of an integerliteral to an integer type
3.5.4
of a real literal to a real type 3.5.6
of a universal expression 3.5.4, 3.5.6
of a universal real expression 4.5.7
Implicit declaration 3.1; 4.1
[see also: scope of... ]
by a type declaration 4.5
hidden by an explicit declaration 8.3
of a basic operation 3.1, 3.3.3
of a block name, loop name, or label 5.1;
3.1
of a derived subprogram 3.3.3, 3.4
of an enumerationliteral 3.3.3
of an equality operator 6.7
of an exception due to an instantiation
11.1
of a library unit 8.6, 10.1
of a predefined operator 4.5
of universal_fixed operators 4.5.5
Implicit initialization of an object
[see: allocator, default initial value]

default expression for a component 3.2.1
default expression for a discriminant 3.2.1
expression 4.5
index constraint 3.6
library unit 10.5
parameter association 6.4
prefix and discrete range of a slice 4.1.2

Implicit representation clause
for a derived type 3.4
import pragmas 13.9
IMPORT_EXCEPTION (VAX Ada predefined
pragma) 13.9a.3.1; 13.9a, 13.9a.3, B
IMPORT_FUNCTION (VAX Ada predefined
pragma) 13.9a.1.4; 13.9a, 13.9a.1, B
IMPORT_OBJECT (VAX Ada predefined pragma)
13.9a.2.2; 13.9a, 13.9a.2, 13.9a.2.3, B
IMPORT_PROCEDURE(VAX Ada predefined
pragma) 13.9a.1.1; 13.9a, 13.9a.1, B
IMPORT_VALUE(VAX Adapredefined function)
[see: system.import_value]
IMPORT_VALUED_PROCEDURE(VAX Ada
predefined pragma) 13.9a.1.1; 13.9a, 13.9a.1, B
in membership test
[see: membershiptest]
In mode
[see: modein]

index 3.6; D

[see also: array, discrete type, entry index]

INDEX (input-output function)
in an instance of direct_io 14.2.4; 14.2.5
in an instance of relative_io 14.2a.2,
14.2a.3
in direct_mixed_io 14.2b.5, 14.2b.6
in relative_mixed_io 14.2b.7, 14.2b.8
Index constraint 3.6, 3.6.1; D

[see also: dependence on discriminant]
ignored due to index_check suppression
11.7
in an allocator 4.8
in a constrained array definition 3.6
in a subtype indication 3.3.2
on an accesstype 3.8
violated 11.1

In out mode
[see: modein out]

Index of an element in a direct access file 14.2;

IN_FILE (input-output file mode enumerationliteral)
14.1

Index in a relative accessfile 14.2a

Inclusive disjunction
[see: logical operator]
Incompatibility (of constraints)
[see: compatibility]
Incomplete type 3.8.1
corresponding full type declaration 3.3.1
incomplete type declaration 3.8.1; 3.3.1, 7.4.1
as a portion of a declarative region 8.1
Incorrect order dependence 1.6
[see also: program error]
assignment statement 5.2
bounds of a range constraint 3.5
componentassociation of an array
aggregate 4.3.2
component association of a record
aggregate 4.3.1
componentsubtype indication 3.6

14.2.4

Index range 3.6
matching 4.5.2
Index subtype 3.6
Index subtype definition 3.6
index type
of a choice in an array aggregate 4.3.2
of a generic formal array type 12.3.4
Index_check
[see: constraint_error, suppress]
[see also: address (VAX Ada predefined
attribute), size (VAX Ada predefined attribute),
bit (VAX Ada predefined attribute)]
Indexed access file 14.2a

index—29

indexed component 4.1.1; 3.6, D
as a basic operation 3.3.3; 3.3, 3.6.2,
3.8.2
as aname 4.1
as the nameof an entry 9.5
of a value of a generic formal array type
12.1.2
INDEXED_IO (VAX Ada predefined input-output
package) 14.2a.4; 14.2a, 14.2a.5
elementlocking in 14.2a
requisite specification of FORM
parameterwith 14.1b, 14.2a.1
INDEXED_MIXED_IO (VAX Ada predefined
input-output package) 14.2b.10
requisite specification of FORM
parameterwith 14.1b
Indication
[see: subtype indication]
Indivisible access of a shared variable 9.11
Inequality compound delimiter 2.2
Inequality operator 4.5; 4.5.2
[see also: limited type, relational operator]
cannot be explicitly declared 6.7
for an accesstype 3.8.2
for an array type 3.6.2
for a generic formal type 12.1.2
for a real type 4.5.7
for a record type 3.7.4
not available for a limited type 7.4.4
Initial value (of an object) 3.2.1
[see also: allocator, composite type, default
expression, default initial value, default
initialization]
in an allocator 4.8; 3.8, 7.4.4
of an array object 3.6.1
of a constant 3.2.1
of a constant in a static expression 4.9
of a discriminant of a formal parameter
6.2
of a discriminant of an object 3.7.2
of a limited private type object 7.4.4
of an object declared in a package7.1
of an out mode formal parameter6.2
of a record object 3.7.2

Initialization
[see: assignment, default expression, default
initialization, initial value]
INLINE (predefined pragma) 6.3.2; B
creating recompilation dependence 10.3
INLINE_GENERIC (VAX Ada predefined pragma)
12.1a; B
creating recompilation dependence 10.3
INOUT_FILE (input-output file_mode enumeration
literal) 14.1
Input-output 14
[see also: direct_io, io_exceptions, low_level_

io, sequential_io, text_io]
at device level 14.6
exceptions 14.4; 14.5
with a direct accessfile 14.2.4
with a sequentialfile 14.2.2
with a text file 14.3
INSQHI (VAX Ada procedure)
[see: system.insghi]
INSQ_STATUS(VAX Adatype)
[see: system.insq_status]
INSQTI (VAX Ada procedure)
[see: system.insqti]
Instance
[see: generic instance]
instantiation
[see: generic instantiation]

INTEGER (predefined type) 3.5.4; C
as base type of a loop parameter 5.5
as default type for the bounds of a
discrete range 3.6.1; 9.5
Integerliteral 2.4
[see also: based integerliteral, universal_
integer type]
as a boundof a discrete range 9.5
as a universal_integerliteral 3.5.4
in based notation 2.4.2
in decimal notation 2.4.1
Integer part
as a base of a basedliteral 2.4.2
of a decimalliteral 2.4.1

Index—30

Integer predefined type 3.5.4
[see also: INTEGER, LONG_INTEGER,
SHORT_INTEGER]
[see also: SHORT_SHORT_INTEGER]

IS_OPEN (input-output function)
in an instance of direct_io 14.2.1; 14.2.5

in an instance of sequential_io 14.2.1,
14.2.3
in text_io 14.2.1; 14.3.10

Integer subtype
[see: priority]
due to an integer type definition 3.5.4
Integer type 3.5.4; 3.3, 3.5, D
[see also: discrete type, numeric type,
predefined type, scalar type, system.maxint,
system.min_int, universal_integer type]
as a generic formal type 12.1.2
as a generic parameter 12.3.3
operation 3.5.5; 4.5.3, 4.5.4, 4.5.5, 4.5.6
result of a conversion from a numeric
type 4.6
result of an operation out of range of the
type 4.5
Integer type declaration
[see: integer type definition]
Integer type definition 3.5.4; 3.3.1
[see also: elaboration of ... ]

in an instance of indexed_io 14.2.1,
14.2a.5
in an instance of relative_io 14.2.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.6
in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.8
in sequential_mixed_io 14.2.1, 14.2b.4

ISO (international organization for standardization)
2.1
iSO seven bit coded character set 2.1

Item

[see: basic declarative item, later declarative
item]

Iteration scheme 5.5
[see also: discrete type]

Integer type expression
in a length clause 13.2
in a record representation clause 13.4
INTEGER_IO (text_io inner generic package)
14.3.6; 14.3.10
~
INTERFACE(predefined pragma) 13.9; B
with imported subprograms 13.9a.1.1

Keyin an indexed accessfile 14.2a
exact and inexact matching of 14.2a
KEY_ERROR(VAX Ada input-output exception)
14.4; 14.2a.4, 14.2a.5, 14.2b.9, 14.2b.10, 14.5a

Interface to other languages 13.9
Interrupt 13.5
Interrupt entry 13.5.1
[see also: addressattribute]
[see also: ast_entry]
Interrupt queue
[see: entry queue]
lO_EXCEPTIONS(predefined input-output
package) 14.4; 14, 14.1, 14.2.3, 14.2.5, 14.3.10, C
specification 14.5

Label 5.1
[see also: addressattribute, name, statement]
declaration 5.1
implicitly declared 3.1
target of a goto statement 5.9

Label bracket
compound delimiter 2.2
Labeled statement 5.1
in a code statement 13.8

Index—31

LARGE (predefinedattribute) 3.5.8, 3.5.10; A
VAX Adafloating point values for F
LAST (predefined attribute) A
[see also: bound]
for an access value 3.8.2
for an array type 3.6.2
for a scalar type 3.5
VAX Adafloating point values for F
LAST_BIT (predefined attribute) 13.7.2; A
[see also: record representation clause]
Later declarative item 3.9

Layout recommended
[see: paragraphing recommended]
LAYOUT_ERROR(input-output exception) 14.4;
14.3.4, 14.3.5, 14.3.7, 14.3.8, 14.3.9, 14.3.10, 14.5,
14.2b.2
Leading zeros in a numericliteral 2.4.1
Left label bracket compounddelimiter 2.2
Left parenthesis
character2.1
delimiter 2.2

Legal 1.6
LENGTH(predefinedattribute) 3.6.2; A
for an access value 3.8.2

Length clause 13.2
as a representation clause 13.1
for an access type 4.8
specifying small of a fixed point type
13.2; 3.5.9
Lengthof a string literal 2.6
Length of the result
of an array comparison 4.5.1
of an array logical negation 4.5.6
of a catenation 4.5.3
Length_check
[see: constraint_error, suppress]
Less than
character 2.1
delimiter 2.2
operator [see: relational operator]

Iindex—32

Less than or equal
compounddelimiter 2.2
operator [see: relational operator]
Letter 2.3

{see also: lower caseletter, upper case letter]
e or E in a decimalliteral 2.4.1
in a basedliteral 2.4.2
in an identifier 2.3

Letter_or_digit 2.3
Lexical element 2, 2.2; 2.4, 2.5, 2.6, D
as a point in the program text 8.3
in a conforming construct 6.3.1
transferred by a text_io procedure 14.3,

14.3.5, 14.3.9

Lexicographic order 4.5.2
Library package
[see: library unit, package]
having dependent tasks 9.4
Library package body
[see: library unit, package body]
raising an exception 11.4.1, 11.4.2
Library unit 10.1; 10.5
[see also: compilation unit, predefined
package, predefined subprogram, program
unit, secondary unit, standard predefined
“package, subunit]
compiled before the corresponding body
10.3
followed by an inline pragma 6.3.2
included in the predefined package
standard 8.6 |
must not be subject to an address clause
13.5
named in a use clause 10.5
namedin a with clause 10.1.1; 10.3, 10.5
recompiled 10.3
scope 8.2

subject to an interface pragma 13.9
that is a package 7.1
visibility due to a with clause 8.3
whose nameis needed in a compilation
unit 10.1.1
with a body stub 10.2
maximum number in VAX Ada F

Limited private type 7.4.4
[see also: private type]
as a generic actual type 12.3.2
as a generic formal type 12.1.2
Limited type 7.4.4; 9.2, 12.3.1, D
[see also: assignment, equality operator,
inequality operator, predefined operator, task

type]

as a full type 7.4.1
componentof a record 3.7
generic formal object 12.1.1
in an object declaration 3.2.1
limited record type 3.7.4
operation 7.4.4; 4.5.2
parameters for explicitly declared equality
operators 6.7

Line 14.3, 14.3.4

Local declaration 8.1

in a generic unit 12.3

LOCK_ERROR(VAX Adainput-output exception)
14.4; 14.2a.2, 14.2a.3, 14.2a.4, 14.2a.5, 14.2b.7,
14.2b.8, 14.2b.9, 14.2b.10, 14.5a
Logical negation operation 4.5.6
Logical operation 4.5.1
Logical operator 4.5; 4.4, 4.5.1, C
[see also: overloading of an operator,
predefined operator]
as an operation of boolean type 3.5.5
for an array type 3.6.2
in an expression 4.4
overloaded 6.7
Logical processor9

LINE (text_io function) 14.3.4; 14.3.10
raising an exception 14.4

LONG_FLOAT(predefined type) 3.5.7; C

Line feed format effector 2.1

LONG_FLOAT(VAX Ada predefined pragma)
3.5.7a; B

Line length 14.3, 14.3.3; 14.3.1, 14.3.4, 14.3.5,
14.3.6
Line terminator 14.3; 14.3.4, 14.3.5, 14.3.6,
14.3.7, 14.3.8, 14.3.9
LINE_LENGTH(text_io function) 14.3.3, 14.3.4;

14.3.3, 14.3.10
raising an exception 14.4

List

[see: componentlist, identifier_list]

LIST (predefined pragma) B
Listing of program text
[see: list pragma, page pragma]
Literal 4.2; D
[see also: basedliteral, characterliteral,
decimalliteral, enumeration literal, integer
literal, null literal, numeric literal, overloading

of ..., real literal, string literal]

as a basic operation 3.3.3
of a derived type 3.4
of universal_integer type 3.5.4
of universal_real type 3.5.6
specification [see: enumerationliteral
specification]

LONG_LONG_FLOAT(VAX Ada predefined type)
3.5.7; C
LONG_INTEGER (predefined type) 3.5.4; C
Loop name5.5
declaration 5.1

implicitly declared 3.1

in an exit statement 5.7

Loop parameter5.5
[see also: constant, object]
as an object 3.2
Loop parameter specification 5.5
[see also: elaboration of ... ]
as an overload resolution context 8.7
as a declaration 3.1
Loop statement 5.5
[see also: statement]
as a compound statement 5.1
as a declarative region 8.1
denoted by an expanded name4.1.3
including an exit statement 5.7
LOW_LEVEL_!O (predefined input-output package)
14.6; 14, C

Index—33

including a priority pragma 9.8
raising an exception 11.4.1, 11.4.2
termination 9.4
VAX Ada definition of 10.1, F
stack and stack storage for 13.2b

Lower bound
[see: bound, first attribute]
Lower caseletter 2.1

[see also: graphic character]
a to f in a basedliteral 2.4.2
e in a decimalliteral 2.4.1
in an identifier 2.3

MAIN_STORAGE (VAX Ada predefined pragma)
13.2b; B

MANTISSA(predefined attribute) 3.5.8, 3.5.10; A
VAX Adafloating point values of F
Mantissa
Machine code insertion 13.8

of a fixed point number 3.5.9
of a floating point number 3.5.7; 13.7.3

Machine dependentattribute 13.7.3

Mark
[see: type_mark]

Machine representation
[see: representation]

Master (task) 9.4

MACHINE_CODE (predefined package) 13.8; C

Matching components
of arrays 4.5.2; 4.5.1, 5.2.1
of records 4.5.2

MACHINE_EMAX(predefined attribute) 13.7.3;
3.5.8, A

VAX Adafloating point values for F

MACHINE_EMIN (predefinedattribute) 13.7.3;
3.5.8, A
VAX Adafloating point values for F
MACHINE_MANTISSA (predefined attribute)
13.7.3; 3.5.8, A

VAX Adafloating point values for F

MACHINE_OVERFLOWS(predefined attribute)
13.7.3; 3.5.8, 3.5.10, A
VAX Adafloating point values for F
MACHINE_RADIX (predefined attribute) 13.7.3;
3.5.8, A
VAX Adafloating point values for F
MACHINE_ROUNDS(predefined attribute) 13.7.3;
3.5.8, 3.5.10, A
VAX Adafloating point values for F
MACHINE_SIZE (VAX Ada predefined attribute)
13.7.2; A
Main program 10.1
execution requiring elaboration oflibrary
units 10.5
included in the predefined package
standard 8.6
Index—34

Matching generic formal

and actual parameters 12.3
accesstype 12.3.5
array type 12.3.4
default subprogram 12.3.6; 12.1.3
object 12.3.1; 12.1.1
private type 12.3.2
scalar type 12.3.3
subprogram 12.3.6; 12.1.3
type 12.3.2, 12.3.3, 12.3.4, 12.3.5; 12.1.2

Mathematically correct result of a numeric
operation 4.5; 4.5.7
MAX_DIGITS
[see: system.max_digits]
MAX_ELEMENT_SIZE (VAX Ada mixed-type
input-output function)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
MAX_INT
[see: system.max_int]
MAX_MANTISSA
[fsee: system.max_mantissa]

Maximum line length 14.3
Maximum pagelength 14.3
Membershiptest 4.4, 4.5.2
cannot be overloaded 6.7

Membership test operation 4.5
[see also: overloading of ... ]
as a basic operation 3.3.3; 3.3, 3.5.5,
3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2
for a real type 4.5.7
MEMORY_SIZE (predefined named number)
[see: system.memory_size]
MEMORY_SIZE (predefined pragma) 13.7; B

Mode(of a file) 14.1; 14.2.1
of a direct accessfile 14.2; 14.2.5
of a sequential accessfile 14.2; 14.2.3
of a text_io file 14.3.1; 14.3.4

of an indexed accessfile 14.2a
of a relative accessfile 14.2a

Mode(of a formal parameter) 6.2; 6.1, D
[see also: formal parameter, generic formal
parameter]
of a formal parameter of a derived
subprogram 3.4
of a formal parameter of a renamed entry
or subprogram 8.5
of a generic formal object 12.1.1

MFPR(VAX Adapredefined function)
[see: system.mfpr]

Modein for a formal parameter6.1, 6.2; 3.2.1
of a function 6.5
of an interrupt entry 13.5.1

MIN_INT
[see: system.min_int]

Modein for a generic formal object 12.1.1; 3.2.1,
12.3, 12.3.1

Minimization of storage
[see: pack predefined pragma]

Modein out for a formal parameter 6.1, 6.2; 3.2.1
of a function is not allowed 6.5
of an interrupt entry is not allowed 13.5.1

Minus

character [see: hyphen character]
character in an exponent of a numeric
literal 2.4.1
delimiter 2.2
operator [see: binary adding operator,
unary adding operator]
unary operation 4.5.4

Mod operator4.5.5
[see also: multiplying operator]
MODE (input-output function)
in an instance of direct_io 14.2.1; 14.2.5
in an instance of sequential_io 14.2.1;
14.2.3
in text_io 14.2.1; 14.3.3, 14.3.4, 14.3.10
in an instance of indexed_io 14.2.1,
14.2a.5

in an instance of relative_io 14.2.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.6
in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.8
in sequential_mixed_io 14.2.1, 14.2b.4

Modein out for a generic formal object 12.1.1;
3.2.1, 12.3, 12.3.1
Modeoutfor a formal parameter 6.1, 6.2
of a function is not allowed 6.5
of an interrupt entry is not allowed 13.5.1
MODE_ERROR(input-output exception) 14.4;
14.2.2, 14.2.3, 14.2.4, 14.2.5, 14.3.1, 14.3.2,
14.3.3, 14.3.4, 14.3.5, 14.3.10, 14.5 , 14.2a.2,
14.2a.3, 14.2a.4, 14.2a.5, 14.2b.2, 14.2b.3,
14.2b.4, 14.2b.5, 14.2b.6, 14.2b.7, 14.2b.8,
14.2b.9, 14.2b.10
Model interval of a subtype 4.5.7
Model number(of a real type) 3.5.6; D
[see also: real type, safe number]
accuracyof a real operation 4.5.7
of a fixed point type 3.5.9; 3.5.10
of a floating point type 3.5.7; 3.5.8
Modulus operation 4.5.5
MONTH(predefined function) 9.6
MTPR (VAX Ada predefined procedure)
[see: system.mtpr]
Index—35

Multidimensional array 3.6
Multiple

componentdeclaration 3.7; 3.2
deferred constant declaration 7.4; 3.2
discriminant specification 3.7.1; 3.2
generic parameterdeclaration 12.1; 3.2
numberdeclaration 3.2.2; 3.2
object declaration 3.2
parameter specification 6.1; 3.2

Multiplication operation 4.5.5
accuracy for a real type 4.5.7
Multiplying operator 4.5; 4.5.5, C
[see also: arithmetic operator, overloading of
an operator]
ina term 4.4
overloaded 6.7
Must(legality requirement) 1.6
Mutually recursive types 3.8.1; 3.3.1

as a primary 4.4
as the argument of a pragma 2.8
as the expression in a case statement 5.4
conflicts 8.5
declared by renaming is not allowed as
prefix of certain expanded names 4.1.3
declared in a generic unit 12.3
denoting an entity 4.1
denoting an object designated by an
accessvalue 4.1
generated by an implementation 13.4
starting with a prefix 4.1; 4.1.1, 4.1.2,
4.1.3, 4.1.4
Namestring (of a file) 14.1; 14.2.1, 14.2.3, 14.2.5,
14.3, 14.3.10, 14.4
NAME_ERROR(input-output exception) 14.4;

14.2.1, 14.2.3, 14.2.5, 14.3.10, 14.5 ,14.2a.3,

14.2a.5, 14.2b.6, 14.2b.8, 14..2b.10

Named association 6.4.2, D
[see also: componentassociation, discriminant
association, generic association, parameter
association]
Namedblock statement

fsee: block name]

NAME(input-output function)
in an instance of direct_io 14.2.1
in an instance of sequential_io 14.2.1
in text_io 14.2.1
in an instance of indexed_io 14.2.1,
14.2a.5
in an instance of relative_io 14.2.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.8
in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.6
in sequential_mixed_io 14.2.1, 14.2b.4
NAME(predefined type)
[see: system.name]
Name(of an entity) 4.1; 2.3, 3.1, D
[see also: attribute, block name, denote,
designator, evaluation of ... , forcing
occurrence, function call, identifier, indexed
component, label, loop name, loop parameter,
operator symbol, renaming declaration,
selected component, simple name, slice,
type_mark,visibility]
as a prefix 4.1
index—36

Named loop statement
[see: loop name]
Named number3.2; 3.2.2
as an entity 3.1
as a primary 4.4
in a static expression 4.9
NATURAL(predefined integer subtype) C
Negation
[see: logical negation operation]
Negation operation (numeric) 4.5.4
Negative exponent
in a numericliteral 2.4.1
to an exponentiation operator 4.5.6
NEW_LINE (text_io procedure) 14.3.4; 14.3.5,
14.3.6, 14.3.10
raising an exception 14.4
NEW_PAGE (text_io procedure) 14.3.4; 14.3.10
raising an exception 14.4

Next element in an indexed accessfile 14.2a

No othereffect
[see: elaboration has no othereffect]
NO_AST_HANDLER(VAX Ada predefined
constant) 9.12a; F
[see: system.no_ast_handler]
NON_ADA_ERROR (VAX Adapredefined
exception)
[see: system.non_ada_error]
Noncontiguousarray D; 13.9a.1.2
Not equal
compounddelimiter [see: inequality
compounddelimiter]
operator[see: relational operator]
Not in membership test
[see: membership test]
Not unary operator
[see: highest precedence operator]
as an operation of an array type 3.6.2

as an operation of boolean type 3.5.5
in a factor 4.4
Not yet elaborated 3.9

Nuil access value 3.8; 3.4, 4.2, 6.2, 11.1
[see also: default initial value of an access
type object]
causing constraint_error 4.1
not causing constraint_error 11.7
Null array 3.6.1; 3.6
aggregate 4.3.2
and relational operation 4.5.2
as an operandof a catenation 4.5.3
Null componentlist 3.7
Null literal 3.8, 4.2
[see also: overloading of ... ]
as a basic operation 3.3.3; 3.8.2
as a primary 4.4
must not be the argument of a conversion
4.6
Null range 3.5
as a choice of a variant part 3.7.3
for a loop parameter 5.5

Null record 3.7
and relational operation 4.5.2
Null slice 4.1.2
[see also: array type]
Null statement 5.1
[see also: statement]
as a simple statement 5.1
Null string literal 2.6
NULL_PARAMETER(VAX Adapredefined
attribute) 13.9a.1.3; A
Number
[see: basedliteral, decimalliteral]
Numberdeclaration 3.2, 3.2.2
as a basic declaration 3.1

NUMBER_BASE (predefined integer subtype)
14.3.7; 14.3.10
Numericliteral 2.4, 4.2; 2.2, 2.4.1, 2.4.2
[see also: universal type expression]
and an adjacent separator 2.2
as a basic operation 3.3.3
as a primary 4.4
as the parameterof value attribute 3.5.5
as the result of image attribute 3.5.5
assigned 5.2
can be written in the basic character set
2.10
in a conforming construct 6.3.1
in a static expression 4.9
in pragma memory_size 13.7
in pragma storage_unit 13.7
Numeric operation of a universal type 4.10
Numeric type 3.5
[see also: conversion, fixed point type, floating
point type, integer type, real type, scalar type]
operation 4.5, 4.5.2, 4.5.3, 4.5.4, 4.5.5,
4.5.6
Numeric type expression
in a length clause 13.2
Numeric value of a named number3.2

Index—37

NUMERIC_ERROR(predefined exception) 11.1
[see also: Suppress pragma]
not raised dueto lost overflow conditions
13.7.3
not raised dueto optimization 11.6
raised by a numeric operator 4.5
raised by a predefined integer operation
3.5.4
raised by a real result out of range of the
safe numbers 4.5.7
raised by a universal expression 4.10
raised by integer division remainderor
modulus 4.5.5
raised due to a conversion out of range
3.5.4, 3.5.6
raised for values out of range for size
attribute 13.7.2

Object declaration 3.2, 3.2.1
[see also: elaboration of ... , generic
parameter declaration]
as a basic declaration 3.1
as a full declaration 7.4.3
implied by a task declaration 9.1
in a package specification 7.1
of an array object 3.6.1
of a record object 3.7.2
with a limited type 7.4.4
with a task type 9.2; 9.3

Object designated by an accessvalue 3.2, 3.8,
4.8; 4.1.3, 5.2, 9.2, 11.1)
[see also: task object designated ... ]
by an access value denoted by a name
4.1
by an access-to-array type 3.6.1

by an access-to-record type 3.7.2
by a generic formal access type value
12.3.5

Object 3.2; 3.2.1, D
[see also: address attribute, allocator,
collection, component, constant, formal
parameter, generic formal parameter,initial
value, loop parameter, size attribute, storage
bits allocated, subcomponent, variable]
as an actual parameter 6.2
as a generic formal parameter 12.1.1
created by anallocator 4.8
created by elaboration of an object
declaration 3.2.1
of an access type [see: access type
object]
of a file type [see: file]
of a task type [see: task object]
renamed 8.5
subject to an address clause 13.5
subject to a representation clause 13.1
subject to a suppress pragma 11.7
exporting to non-Ada programs 13.9a.2,
13.9a.2.2, 13.9a.2.3
importing from non-Ada programs
13.9a.2, 13.9a.2.1, 13.9a.2.3
maximum numberof bits in VAX Ada F
maximum number declared with PSECT_
OBJECT pragma F

Index—38

Object module
for a subprogram written in another
language 13.9
VMS D
Obsolete compilation unit (due to recompilation)
10.3
Occur immediately within (a declarative region)
8.1; 8.3, 8.4, 10.2
Omitted parameter association for a subprogram
call 6.4.2
OPEN(input-output procedure)
in an instance of direct_io 14.2.1; 14.1,
14.2.5
in an instance of sequential_io 14.2.1;
14.1, 14.2.3
in text_io 14.2.1; 14.1, 14.3.1, 14.3.10
raising an exception 14.4
in an instance of indexed_io 14.2.1,
14.2a.5
in an instance of relative_io 14.2.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.6
in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.8
in sequential_mixed_io 14.2.1, 14.2b.4

Openalternative 9.7.1
[see also: alternative]
accepting a conditional entry call 9.7.2
accepting a timed entry call 9.7.3
Openfile 14.1
Operation 3.3, 3.3.3; D
[see also: basic operation, direct visibility,
operator, predefined operation, visibility by
selection, visibility]
classification 3.3.3
of an accesstype 3.8.2
of an array type 3.6.2
of a discrete type 3.5.5
of a fixed point type 3.5.10
of a floating point type 3.5.8
of a generic actual type 12.1.2
of a generic formal type 12.1.2; 12.3
of a limited type 7.4.4
of a private type 7.4.2; 7.4.1
of a record type 3.7.4
of a subtype 3.3
of a subtypeof a discrete type 3.5.5
of a type 3.3
of a universal type 4.10
propagating an exception 11.6
subject to a suppress pragma 11.7
Operator 4.5; 4.4, C, D
[see also: binary adding operator, designator,
exponentiating operator, function, highest
precedence operator, logical operator,
multiplying operator, overloading of... ,
predefined operator, relational operator, unary
adding operator]
as an operation 3.3.3 [see also:
operation]
implicitly declared 3.3.3
in an expression 4.4
in a static expression 4.9
of a derived type 3.4
of a generic actual type 12.1.2
overloaded 6.7; 6.6
renamed 8.5
Operator declaration 6.1; 4.5, 6.7
Operator symbol6.1
[see also: direct visibility, overloading of ... ,
scopeof ... , visibility by selection, visibility]
as a designator 6.1
as a designator in a function declaration
4.5

as aname 4.1
before arrow compound delimiter 8.3
declared 3.1
declared in a generic unit 12.3
in a renaming declaration 8.5
in a selector 4.1.3
in a static expression 4.9
not allowed as the designatorof a library
unit 10.1
of a generic formal function 12.1.3, 12.3
of homograph declarations 8.3
overloaded 6.7; 6.6
|
Optimization 10.6
[see also: optimize pragma]
and exceptions 11.6
OPTIMIZE (predefined pragma) B
Optional parameter
in imported subprogram 13.9a.1.3
Or else control form
[see: short circuit control form]
Or operator
[see: logical operator]
Order
[see: lexicographic order]
Order not defined by the language
[see: incorrect order dependence]
Order of application of operators in an expression
4.5
Order of compilation (of compilation units) 10.1,
10.3; 10.1.1, 10.4
creating recompilation dependence 10.3
Order of copying back of out and in out formal
parameters 6.4
Order of elaboration 3.9
[see also: incorrect order dependence]; (of
compilation units) 10.5; 10.1.1
Order of evaluation 1.6
[see also: incorrect order dependence]
and exceptions 11.6
of conditions in an if statement 5.3
of default expressions for components
3.2.1

Index—39

of expressions and the namein an
assignment statement 5.2
of operands in an expression 4.5
of parameter associations in a subroutine
call 6.4
of the boundsof a range 3.5
of the conditions in a selective wait 9.7.1
Order of execution of statements 5.1
[see also: incorrect order dependence]
Ordering operator 4.5; 4.5.2
Ordering relation 4.5.2
[see also: relational operator]
for a real type 4.5.7
of an enumeration type preserved by a
representation clause 13.3
of a scalar type 3.5
Othereffect
[see: elaboration has no othereffect]
Other special character 2.1
[see also: graphic character]
Others 3.7.3
as a choice in an array aggregate 4.3.2
as a choice in a case statement
alternative 5.4
as a choice in a componentassociation
4.3
as a choice in a record aggregate 4.3.1
as a choicein a variant part 3.7.3
as an exception choice 11.2
as a choice for handling VAX conditions
signaled from non-Ada code 11.2
Out mode
[see: mode out]
OUT_FILE (input-outputfile mode enumeration
literal) 14.1
Overflow of real operations 4.5.7; 13.7.3
Overflow_check
[see: numeric_error, suppress]
Overlapping scopes
[see: hiding, overloading]
Overlapping slices in array assignment5.2.1
Overlaying of objects or program units 13.5

Index—40

Overloading 8.3; D
[see also: designator, homograph declaration,
identifier, operator symbol, scope, simple
name, subprogram, visibility]
and visibility 8.3
in an assignment statement 5.2
in an expression 4.4
resolution 6.6
resolution context 8.7
resolved by explicit qualification 4.7
Overloading of
an aggregate 3.4
an allocator 4.8
a declaration 8.3
a designator 6.6; 6.7
an entry 9.5

an enumerationliteral 3.5.1; 3.4
a generic formal subprogram 12.3
a generic unit 12.1
an identifier 6.6
a library unit by a locally declared
subprogram 10.1
a library unit by means of renaming 10.1
a literal 3.4
a membershiptest 4.5.2
an operator 4.5, 6.7; 4.4, 6.1
an operator symbol 6.6; 6.7
a subprogram 6.6; 6.7
a subprogram subject to an interface
pragma 13.9
the expression in a case statement 5.4

PACK (predefined pragma) 13.1; B
Packable D
Package 7, 7.1; D
[see also: deferred constant declaration,
library unit, predefined package, private part,
program unit, visible part]
as a generic instance 12.3; 12
including a raise statement 11.3
namedin a use clause 8.4
renamed 8.5
subject to an address clause 13.5
subject to representation clause 13.1
with a separately compiled body 10.2

Package body 7.1, 7.3; D
{see also: body stub]
as a generic body 12.2
as a proper body 3.9
as a secondary unit 10.1

as a secondary unit compiled after the
correspondinglibrary unit 10.3
in another package body7.1
including an exception handler 11.2; 11

including an exit statement 5.7
including a goto statement 5.9
including an implicit declaration 5.1
must be in the same declarative region
as the declaration 3.9
raising an exception 11.4.1, 11.4.2
recompiled 10.3
subject to a suppress pragma 11.7
Package declaration 7.1, 7.2; D

and body as a declarative region 8.1
as a basic declaration 3.1
as a later declarative item 3.9
as a library unit 10.1
determining the visibility of another
declaration 8.3
elaboration raising an exception 11.4.2
in a package specification 7.1
recompiled 10.3

Package identifier 7.1
Package specification 7.1, 7.2
in a generic declaration 12.1
including an inline pragma 6.3.2
including an interface pragma 13.9
including a representation clause 13.1
including a suppress pragma 11.7
Page 14.3, 14.3.4
PAGE (predefined pragma) B
PAGE (text_io function) 14.3.4; 14.3.10
raising an exception 14.4
Page length 14.3, 14.3.3; 14.3.1, 14.3.4, 14.4
Page terminator 14.3; 14.3.3, 14.3.4, 14.3.5

PAGE_LENGTH(text_io function) 14.3.3; 14.3.10
raising an exception 14.4
Paragraphing recommendedfor the layout of
programs 1.5

Parallel execution

[see: task]

Parameter D
[see also: actual parameter, default
expression, entry, formal parameter, formal
part, function, generic actual parameter,
generic formal parameter, loop parameter,
mode, procedure, subprogram]
of a main program 10.1
Parameter and result type profile 6.6
Parameter association 6.4, 6.4.1
for a derived subprogram 3.4
named parameterassociation 6.4
named parameter association for
selective visibility 8.3
omitted for a subprogram call 6.4.2
positional parameter association 6.4
Parameter declaration
[see: generic parameter declaration,
parameterspecification]
Parameter part
[see: actual parameterpart]
Parameter passing
overriding default mechanisms 13.9a.1.2
Parameter specification 6.1
[see also: loop parameter specification]
as part of a basic declaration 3.1
having an extended scope 8.2
in a formal part 6.1
visibility 8.3
Parametertype profile 6.6
Parent subprogram (of a derived subprogram) 3.4
Parent subtype (of a derived subtype) 3.4
Parent type (of a derived type) 3.4; D
[see also: derived type]
declared in a visible part 3.4
of a generic actual type 12.1.2
of a numeric type is predefined and
anonymous3.5.4, 3.5.7, 3.5.9
Parent unit (of a body stub) 10.2
compiled before its subunits 10.3

Index—41

Parenthesis
character 2.1
delimiter 2.2

Parenthesized expression
as a primary 4.4; 4.5
in a static expression 4.9
Part

[see: actual parameterpart, declarative part,
discriminant part, formal part, generic actual
part, generic formal part, variant part]

Partial ordering of compilation 10.3
Percent character2.1
[see also: string literal]
replacing quotation character 2.10
Period character2.1
[see also: dot character, point character]

Position number
as parameterto val attribute 3.5.5
of an enumerationliteral 3.5.1
of an integer value 3.5.4
of a value of a discrete type 3.5
returned by posattribute 3.5.5
Position of a component within a record
[see: record representation clause]
Position of an elementin a direct accessfile 14.2

Positional association 6.4; 6.4.2, D
[see also: component association, discriminant
association, generic association, parameter
association]
POSITIVE (predefined integer subtype) 3.6.3;
14.3.7, 14.3.8, 14.3.9, 14.3.10, C
as the index type of the string type 3.6.3

Physical processor9; 9.8

POSITIVECOUNT(predefined integer subtype)
14.2.5, 14.3.10; 14.2.4, 14.3, 14.3.4

Plus

Potentially visible declaration 8.4

character 2.1
delimiter 2.2
operator [see: binary adding operator,
unary adding operator]
unary operation 4.5.4

Point character 2.1
[see also: dot]
in a basedliteral 2.4.2
in a decimalliteral 2.4.1
in a numeric literal 2.4
Point delimiter 2.2

Pointer
[see: access type]
Portability 1.1
of programsusing real types 13.7.3; 3.5.6
POS(predefined attribute) 3.5.5; 13.3, A
POSITION (predefined attribute) 13.7.2; A
[see also: record representation clause]
POSITION (VAX Ada mixed-type input-output
function)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
Index—42

Pound sterling character 2.1
Power operator
[see: exponentiating operator]
Pragma2.8; 2, D

[see also: predefined pragma]
applicable to the whole of a compilation
10.1
argumentthat is an overloaded
subprogram name6.3.2, 8.7, 13.9
for the specification of a subprogram
body in another language 13.9
for the specification of program overlays
13.5
in a code procedure body 13.8
recommending the representation of an
entity 13.1
specifying implementation conventions for
code statements 13.8

Precedence4.5

Precision (numeric)
[see: delta, digits]
PRED (predefined attribute) 3.5.5; 13.3, A

Predecessor
[see: pred attribute]
Predefined attribute
[see: address, base, callable, constrained,
count,first, first_bit, image, last, last_bit, pos,
pred, range, size, small, storage_size, succ,
terminated, val, value, width]
Predefined constant 8.6; C
[see also: system.system_name]
for CHARACTER values [see: ascii]
Predefined exception 8.6, 11.1; 11.4.1, C
[see also: constraint_error, io_exceptions,
numeric_error, program_error, tasking_error,

time_error]

Predefined function 8.6; C
[see also: attribute, characterliteral,
enumeration literal, predefined generic
library function}
Predefined generic library function 8.6; C

[see also: unchecked_conversion]

Predefined generic library package 8.6; C
[see also: direct_io, input-output package,
sequential_io]
Predefined generic library procedure 8.6; C
[see also: unchecked_deallocation]

Predefined generic library subprogram 8.6; C
Predefined identifier 8.6; C
Predefined library package 8.6; C
[see also: predefined generic library package,
predefined package, ascii, calendar, inputoutput package, io_exceptions, low_level_io,

machine_code, system, text_io]

Predefined operation 3.3, 3.3.3; 8.6

[see also: operation, predefined operator]
accuracyfor a real type 4.5.7
of a discrete type 3.5.5
of a fixed point type 3.5.10
of a floating point type 3.5.8
of a universal type 4.10
propagating an exception 11.6

Predefined operator 4.5, 8.6; C
[see also: abs, arithmetic operator, binary
adding operator, catenation, equality,
exponentiating operator, highest precedence
operator, inequality, limited type, logical
operator, multiplying operator, operator,
predefined operation, relational operator, unary
adding operator]
applied to an undefined value 3.2.1
as an operation 3.3.3
for an access type 3.8.2
for an array type 3.6.2
for a record type 3.7.4
implicitly declared 3.3.3
in a static expression 4.9
of a derived type 3.4
of a fixed point type 3.5.9
of a floating point type 3.5.7
of an integer type 3.5.4
raising an exception 11.4.1
Predefined package 8.6; C
[see also: ascii, library unit, predefined library
package, standard]
for input-output 14
Predefined pragma
[see: controlled, elaborate, inline, interface,
list, memory_size, optimize, pack, page,
priority, shared, storage_unit, suppress,
system_name]

Predefined library subprogram
[see: predefined generic library subprogram]

Predefined subprogram 8.6; C
[see also: input-output subprogram, library
unit, predefined generic library subprogram]

Predefined named number
[see: system.fine_delta, system.max_digits,

Predefined subtype 8.6; C

system.max_int, system.max_mantissa,

system.memory_size, system.min_int,
system.storage_unit, system.tick]

[see also: field, natural, number_base,

positive, priority]

Predefined type 8.6; C
[see also: boolean, character, count,
duration, float, integer, long_float, long
integer, priority, short_float, short_integer,

Index—43

string, system.address, system.name, time,
universal_integer, universal_real]
Prefix 4.1; D
[see also: appropriate for a type, function call,
name, selected component, selector]
in an attribute 4.1.4
in an indexed component4.1.1
in a selected component 4.1.3
in a slice 4.1.2
that is a function call 4.1
that is a name 4.1
Primary 4.4
in a factor 4.4
in a static expression 4.9
Primary key in an indexed accessfile 14.2a
PRIORITY (predefined integer subtype) 9.8; 13.7, C
[see also: task priority]
PRIORITY (predefined pragma) 9.8; 13.7, B
[see also: task priority]
Private part (of a package) 7.2; 7.4.1, 7.4.3, D
[see also: deferred constant declaration,
private type declaration]
Private type 3.3, 7.4, 7.4.1; D
[see also: class of type, derived type of a
private type, limited private type, type with
discriminants]
as a generic actual type 12.3.2
as a generic formal type 12.1.2
as a parent type 3.4
corresponding full type declaration 3.3.1
formal parameter 6.2
of a deferred constant 7.4; 3.2.1
operation 7.4.2
Private type declaration 7.4; 7.4.1, 7.4.2
[see also: private part (of a package), visible
part (of a package)}
as a generic type declaration 12.1
as a portion of a declarative region 8.1
including the word ‘limited’ 7.4.4
Procedure 6.1; 6, D
[see also: parameter and result type profile,
parameter, subprogram]
as a main program 10.1
as a renaming of an entry 9.5
renamed 8.5
exporting 13.9a.1.4
importing 13.9a.1.1
Iindex—44

Procedure body
[see: subprogram body]
including code statements 13.8
Procedurecall 6.4; 6, D
[see also: subprogram call]
Procedurecall statement 6.4
[see also: actual parameter, statement]
as a simple statement 5.1
with a parameter of a derived type 3.4
Procedure specification
[see: subprogram specification]
Processor 9

Profile
[see: parameter and result type profile,
parametertypeprofile]
Program 10; D
[see also: main program]
Program legality 1.6
Program library 10.1, 10.4; 10.5
creation 10.4; 13.7
manipulation and status 10.4
maximum numberof units in VAX Ada F
Program optimization 11.6; 10.6
Program section (VMS) D; 13.9a.2.3
Program text 2.2, 10.1; 2.10
Program unit 6, 7, 9, 12; D
[see also: address attribute, generic unit,
library unit, package, subprogram, task unit]
body separately compiled [see: subunit]
including a declaration denoted by an
expanded name 4.1.3
including a suppress pragma 11.7
subject to an address clause 13.5
with a separately compiled body 10.2
PROGRAM_ERROR(predefined exception) 11.1
[see also: erroneous execution, suppress
pragma]
raised by an erroneous program or
incorrect order dependence 1.6; 11.1
raised by a generic instantiation before
elaboration of the body 3.9; 12.1, 12.2

raised by a selective wait 9.7.1
raised by a subprogram call before
elaboration of the body 3.9; 7.3
raised by a task activation before
elaboration of the body 3.9
raised by reaching the end of a function
body 6.5
raised for AST occurring for entry of
noncallable task 9.12a
Propagation of an exception
[see: exception propagation]

qualification of an array aggregate 4.3.2
to resolve an overloading ambiguity 6.6
Queueof entry calls
[see: entry queue]
Queueof interrupts
[see: entry queue]
Quotation character 2.1
in a String literal 2.6
replacement by percent character 2.10

Proper body 3.9
as a body 3.9
in a subunit 10.2
of a library unit separately compiled 10.1

PSECT_OBJECT (VAX Ada predefined pragma)
13.9a.2.3; B
maximum numberof objects declared

with F

PUT (text_io procedure) 14.3, 14.3.5; 14.3.2,
14.3.10
for character andstring types 14.3.6
for enumeration types 14.3.9
for integer types 14.3.7
for real types 14.3.8
raising an exception 14.4
PUT_ITEM (VAX Ada mixed-type input-output
procedure)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4

Qualification 4.7
as a basic operation 3.3.3; 3.3, 3.5.5,
3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2
using a name of an enumeration type as
qualifier 3.5.1
Qualified expression 4.7; D
as a primary 4.4
in an allocator 4.8
in a case statement 5.4
in a static expression 4.9

Radix of a floating point type 3.5.7; 13.7.3
Raise statement 11.3; 11
[see also: exception, statement]
as a simple statement 5.1
including the name of an exception 11.1
Raising of an exception 11, 11.3; D
[see also: exception]
causing a transfer of control 5.1
Range 3.5; D
[see also: discrete range, null range]
as a discrete range 3.6
in a record representation clause 13.4
in a relation 4.4
of an index subtype 3.6
of an integer type containing the result of
an operation 4.5
of a predefined integer type 3.5.4
of a real type containing the result of an
operation 4.5.7
yielded by an attribute 4.1.4
RANGE (predefined attribute) 3.6.2; 4.1.4, A
for an access value 3.8.2

Rangeconstraint 3.5; D
[see also: elaboration of ... ]
ignored due to range_check suppression
11.7
in a fixed point constraint 3.5.9
in a floating point constraint 3.5.7
in an integer type definition 3.5.4
in a subtypeindication 3.5; 3.3.2
on a derived subtype 3.4
violated 11.1
Index—45

Range_check
[see: constraint_error, suppress]
when array parameter passing involves a
VAX descriptor 11.7
READ(input-output procedure)

in an instance of direct_io 14.2.4; 14.1,

14.2, 14.2.5
in an instance of sequential_io 14.2.2;
14.1, 14.2, 14.2.3
in an instance of indexed_io 14.2a.4,
14.2a.5
in an instance of relative_io 14.2a.2,
14.2a.3

in direct_mixed_io 14.2b.5, 14.2b.6
in indexed_mixed_io 14.2b.9, 14.2b.10

in relative_mixed_io 14.2b.7, 14.2b.8
in sequential_mixed_io 14.2b.3, 14.2b.4
READ_BY_KEY(VAX Adainput-output generic
procedure)
in an instance of indexed_io 14.2a.4,
14.2a.5
in indexed_mixed_io 14.2b.9, 14.2b.10
READ_EXISTING (VAX Adainput-output
procedure)
in an instanceof relative_io 14.2a.2,
14.2a.3

in relative_mixed_io 14.2b.7, 14.2b.8
Reading the value of an object 6.2, 9.11
READ_REGISTER (VAX Adapredefined function)
[see system.read_register]
Realliteral 2.4
[see also: universal_real type]
in based notation 2.4.2
in decimal notation 2.4.1
is of type universal_real 3.5.6
{see also: D_floating, F_floating, G_floating,
H_floating]
Real type 3.5.6; 3.3, 3.5, D
[see also: fixed point type, floating point type,
model number, numeric type, safe number,
scalar type, universal_real type]
accuracy of an operation 4.5.7
representation attribute 13.7.3
result of a conversion from a numeric
type 4.5.7; 4.6

index—46

result of an operation out of range of the
type 4.5.7
Real type definition 3.5.6; 3.3.1, 3.5.7, 3.5.9
[see also: elaboration of ... ]
RECEIVECONTROL(low_level_io procedure)
14.6
Reciprocal operation in exponentiation by a
negative integer 4.5.6
Recompilation 10.3
implicit 3.5.7a
Record (VMS RMS)
[see also: element]
correspondence to file element 14.1a
correspondenceto a sourceline 2.2
determining numberofin direct inputoutputfile 14.2.4
locking in a relative or indexed accessfile
14.2a
Record aggregate 4.3.1; 4.3
[see also: aggregate]
as a basic operation 3.3.3; 3.7.4
in a code statement 13.8
Record component
[see: component, record type, selected
component]
[see also: allocation]
Record representation clause 13.4
[see also: first_bit attribute, last_bit attribute,
position attribute]
as a representation clause 13.1
VAX Ada restrictions on component
clause in 13.4
Record type 3.7; 3.3, D
[see also: component, composite type,
discriminant, matching components,
subcomponent, type with discriminants,
variant]
formal parameter 6.2
including a limited subcomponent 7.4.4
operation 3.7.4
Record type declaration
[see: record type definition, type declaration]
as a declarative region 8.1
determining the visibility of another
declaration 8.3

Record type definition 3.7; 3.3.1
[see also: component declaration]
Recursive
call of a subprogram 6.1, 12.1; 6.3.2
generic instantiation 12.1, 12.3
types 3.8.1; 3.3.1

RELATIVE_MIXED_!O (VAX Adapredefined
input-output package)14.2b.7
requisite specification of FORM
parameterwith 14.1b
Rem operator 4.5.5
[see also: multiplying operator]

Reentrant subprogram 6.1

Remainder operation 4.5.5

Reference (parameter passing) 6.2 ; 13.9a.1.2

REMQHI (VAX Ada predefined procedure)
[see: system.remghi]

Relation (in an expression) 4.4
Relational expression
[see: relation, relational operator]
Relational operation 4.5.2
of a boolean type 3.5.3
of a discrete type 3.5.5
of a fixed point type 3.5.10
of a floating point type 3.5.8
of a scalar type 3.5
result for real operands 4.5.7
Relational operator 4.5; 4.5.2, C
[see also: equality operator, inequality
operator, ordering relation, overloading of an
operator, predefined operator]
for an access type 3.8.2
for an array type 3.6.2
for a private type 7.4.2
for a record type 3.7.4
for time predefined type 9.6
in a relation 4.4
overloaded 6.7
RELATION_TYPE (VAX Adainput-output type)
14.2a
in an instance of indexed_io 14.2a.4,
14.2a.5

in indexed_mixed_io 14.2b.9, 14.2b.10
Relative access file 14.2a

Relative address of a component within a record
[see: record representation clause]
RELATIVE_!O (VAX Ada predefined input-output
package) 14.2a.2
requisite specification of FORM
parameterwith 14.1.b, 14.2a.1
element locking in 14.2a

REMQ_STATUS (VAX Adapredefined type)
[see: system.remq_status]
REMQTI (VAX Ada predefined procedure)
[see: system.remati]
Renaming declaration 8.5; 4.1, 12.1.3, D
[see also: name]
as a basic declaration 3.1
as a declarative region 8.1
cannot rename a universal_fixed

operation 4.5.5
for an array object 3.6.1
for an entry 9.5
for a record object 3.7.2
name declared is not allowed as a prefix
of certain expanded names4.1.3
to overload library unit 10.1
to overload a subunit 10.2
to resolve an overloading ambiguity 6.6
and the pragmainline 6.3.2
and the pragmainline_generic 12.1a
and the pragmainterface 13.9
for a volatile variable 9.11
for imported subprograms 13.9a.1.1
Rendezvous(of tasks) 9.5; 9, 9.7.1, 9.7.2, 9.7.3, D
during which an exception is raised 11.5
priority 9.8
prohibited for an abnormal task 9.10
Replacementof characters in program text 2.10
Representation (of a type and its objects) 13.1
recommendation by a pragma 13.1
Representation attribute 13.7.2, 13.7.3
as a forcing occurrence 13.1
with a prefix that has a null value 4.1

Index—47

Representation clause 13.1; 13.6, D
[see also: address clause, elaboration
of ... , enumeration representation clause,
first named subtype, length clause, record
representation clause, type]
an overload resolution context 8.7
as a basic declarative item 3.9
as a portion of a declarative region 8.1
cannotinclude a forcing occurrence 13.1
for a derived type 3.4
for a private type 7.4.1
implied for a derived type 3.4
in a task specification 9.1

expression that is an array aggregate
4.3.2
in a function body 6.5

Reserved word 2.9; 2.2, 2.3

Returned value
[see: function call]
of a function call 5.8, 6.5; 8.5
of an instance of a generic formal
function 12.1.3
of a main program 10.1
of an operation 3.3.3
of a predefined operator of an integer
type 3.5.4
of a predefined operator of a real type
3.5.6, 4.5.7

RESET(input-output procedure)

Right label bracket compound delimiter 2.2

in an instance of direct_io 14.2.1; 14.2.5

in an instance of sequential_io 14.2.1;
14.2.3

Right parenthesis
character 2.1
delimiter 2.2

in text_io 14.2.1; 14.3.1, 14.3.10

in an instance of indexed_io 14.2a.1,
14.2a.5
in an instance of relative_io 14.2a.1,
14.2a.3
in direct_mixed_io 14.2.1, 14.2b.6
in indexed_mixed_io 14.2a.1, 14.2b.10
in relative_mixed_io 14.2a.1, 14.2b.8
in sequential_mixed_io 14.2.1, 14.2b.4

Round-robin task scheduling 9.8a
Rounding
in a real-to-integer conversion 4.6
of results of real operations 4.5.7; 13.7.3
Run time check 11.7; 11.1

Resolution of overloading
[see: overloading]
Result subtype (of a function) 6.1
of a return expression 5.8
Result type profile
[see: parameter and ... ]
Result type and overload resolution 6.6
Result of a function
[see: returned value]
Return
[see: carriage return]
Return statement 5.8
[see also: function, statement]
as a simple statement 5.1
causing a loop to be exited 5.5
causing a transfer of control 5.1
completing block statement execution 9.4
completing subprogram execution 9.4

Index—48

Safe interval 4.5.7

Safe number(of a real type) 3.5.6; 4.5.7
[see also: model number, real type
representation attribute, real type]
limit to the result of a real operation 4.5.7
of a fixed point type 3.5.9; 3.5.10
of a floating point type 3.5.7; 3.5.8
result of universal expression too large
4.10
SAFE_EMAX(predefined attribute) 3.5.8; A
VAX Adafloating point values for F
SAFE_LARGE (predefined attribute) 3.5.8,
3.5.10; A

VAX Adafloating point values for F

SAFE_SMALL(predefined attribute) 3.5.8,
3.5.10; A

VAX Adafloating point values for F
Satisfy (a constraint) 3.3; D
[see also: constraint, subtype]
a discriminant constraint 3.7.2
an index constraint 3.6.1
a range constraint 3.5
Scalar type 3.3, 3.5; D
[see also: class of type, discrete type,
enumeration type, fixed point type, floating
point type, integer type, numeric type, real
type, static expression]
as a generic parameter 12.1.2, 12.3.3
formal parameter 6.2
of a range in a membership test 4.5.2
operation 3.5.5; 4.5.2
Scheduling 9.8; 13.5.1
Scheme
[see: iteration scheme]
Scope 8.2; 8.3, D
[see also: basic operation, characterliteral,

declaration, declarative region, generic
instance, identifier, immediate scope, implicit
declaration, operator symbol, overloading,
visibility]
of a use clause 8.4
Secondary unit 10.1
[see also: compilation unit, library unit]
compiled after the correspondinglibrary
unit or parent unit 10.3
subject to a pragma elaborate 10.5
SECONDS(predefined function) 9.6
Select alternative (of a selective wait) 9.7.1
Select statement 9.7; 9.7.1, 9.7.2, 9.7.3
[see also: statement, task, terminate
alternative]
as a compound statement 5.1
in an abnormal task 9.10
Selected component4.1.3; 8.3, D
[see also: direct visibility, prefix, selector,
visibility by selection, visibility]
as a basic operation 3.3.3; 3.3, 3.7.4,
3.8.2, 7.4.2
:
as aname 4.1

as the name of an entry or entry family
9.5
for selective visibility 8.3
in a conforming construct 6.3.1
starting with standard 8.6
using a block name 5.6
using a loop name 5.5
whoseprefix denotes a package 8.3
whoseprefix denotes a record object 8.3
whoseprefix denotes a task object 8.3
Selection of an exception handler 11.4, 11.4.1,
11.4.2; 11.6
Selective visibility
[see: visibility by selection]
Selective wait 9.7.1; 9.7
[see also: terminate alternative]
accepting a conditional entry call 9.7.2
accepting a timed entry call 9.7.3
raising program_error 11.1
Selector 4.1.3; D
[see also: prefix, selected component]
Semicolon character 2.1
Semicolon delimiter 2.2

followed by a pragma 2.8

SEND_CONTROL(low_level_io procedure) 14.6
Separate compilation 10, 10.1; 10.5
of a proper body 3.9
of a proper body declared in another
compilation unit 10.2
Separator 2.2
Sequenceof statements 5.1
in an accept statement 9.5
in a basic loop 5.5
in a block statement 5.6; 9.4
in a case statementalternative 5.4
in a conditional entry call 9.7.2
in an exception handler 11.2
in an if statement 5.3
in a package body 7.1; 7.3
in a selective wait statement 9.7.1
in a subprogram body 6.3; 9.4, 13.8
in a task body 9.1; 9.4
in a timed entry call 9.7.3
including a raise statement 11.3
of code statements 13.8

raising an exception 11.4.1
Index—49

Sequential accessfile 14.2; 14.1, 14.2.1
Sequential execution
[see: sequence of statements, statement]
Sequential input-output 14.2.2; 14.2.1
SEQUENTIAL_IO (predefined input-output generic
package) 14.2, 14.2.2; 14, 14.1, 14.2.3, C
exceptions 14.4; 14.5
specification 14.2.3
SET_COL(text_io procedure) 14.3.4; 14.3.10
SET_INDEX (input-output procedure)
in an instance of direct_io 14.2.4; 14.2.5
in an instanceof relative_io 14.2a.2,
14.2a.3
in direct_mixed_io 14.2b.5, 14.2b.6
in relative_mixed_io 14.2b.7, 14.2b.8
SET_INPUT(text_io procedure) 14.3.2; 14.3.10
raising an exception 14.4
SET_INTERLOCKED (VAX Ada predefined
procedure)
[see: system.set_interlocked]
SET_LINE (text_io procedure) 14.3.4; 14.3.10
SET_LINE_LENGTH (text_io procedure) 14.3.3;
14.3.10
raising an exception 14.4
SET_OUTPUT(text_io procedure) 14.3.2; 14.3.10
raising an exception 14.4
SET_PAGE_LENGTH(text_io procedure) 14.3.3;
14.3.10
raising an exception 14.4
SET_POSITION (VAX Ada mixed-type input-output
procedure)
in direct_mixed_io 14.2b.2, 14.2b.6
in indexed_mixed_io 14.2b.2, 14.2b.10
in relative_mixed_io 14.2b.2, 14.2b.8
in sequential_mixed_io 14.2b.2, 14.2b.4
SHARE_GENERIC (VAX Adapredefined pragma)
12.1b; B

SHARED (predefined pragma) 9.11; B
[see also: volatile]

Index—50

Shared variable (of two tasks) 9.11
[see also: task]
Sharp character 2.1
[see also: basedliteral]
replacement by colon character 2.10
Short circuit control form 4.5, 4.5.1; 4.4
as a basic operation 3.3.3; 3.5.5
in an expression 4.4
SHORT_FLOAT(predefined type) 3.5.7; C
SHORT_INTEGER (predefined type) 3.5.4; C
SHORT_SHORT_INTEGER(VAX Adapredefined
type) 3.5.4; C
Sign of a fixed point number3.5.9
Sign of a floating point number 3.5.7
Significant decimaldigits 3.5.7
Simple expression 4.4
as a choice 3.7.3
as a choice in an aggregate 4.3
as a range bound 3.5
for an entry index in an accept statement
9.5
in an address clause 13.5
in a delay statement 9.6
in a fixed accuracy definition 3.5.9
in a floating accuracy definition 3.5.7
in a record representation clause 13.4
in a relation 4.4
Simple name 4.1; 2.3, D
[see also: block name, identifier, label, loop
name, loop simple name, name, overloading,
visibility]
as a choice 3.7.3
as a formal parameter 6.4
as a label 5.1
as aname4.1
before arrow compound delimiter 8.3
in an accept statement 9.5
in an address clause 13.5
in an attribute designator 4.1.4
in a conforming construct 6.3.1
in a discriminant association 3.7.2
in an enumeration representation clause
13.3
in a package body7.1
in a package specification 7.1

in a record representation clause 13.4
in a selector 4.1.3
in a suppress pragma 11.7
in a task body 9.1
in a variant part 3.7.3
in a with clause 10.1.1
versusidentifier 3.1
Simple record (type or subtype) 13.9a.1.2; D
Simple statement 5.1
[see also: statement]
Single task 9.1
SIZE (input-output function)
in an instance of direct_io 14.2.4; 14.2.5

in direct_mixed_io 14.2b.5, 14.2b.6

SIZE (predefined attribute) 13.7.2; A
[see also: storagebits]
specified by a length clause 13.2
SKIP_LINE (text_io procedure) 14.3.4; 14.3.10
raising an exception 14.4
SKIP_PAGE (text_io procedure) 14.3.4; 14.3.10
raising an exception 14.4
Slice 4.1.2
[see also: array type]
as a basic operation 3.3.3; 3.6.2, 3.8.2
as aname 4.1
as destination of an assignment 5.2.1
of a constant 3.2.1
of a derived type 3.4
of an object as an object 3.2
of a value of a generic formal array type
12.1.2
of a variable 3.2.1
starting with a prefix 4.1, 4.1.2
SMALL(predefined attribute) 3.5.8, 3.5.10; A
[see also: fixed point type]
specified by a length clause 13.2
VAX Ada floating point values for F
Small of a fixed point model number 3.5.9
Someorder not defined by the language
[see: incorrect order dependence]
Sourcefile
for a VAX Ada program 2.2
maximum numberoflines in F

Source line

in a VAX Ada program 2.2

maximum numberof characters in F

Space character 2.1
[see also: basic graphic character]
as a separator 2.2
in a comment 2.7
not allowed in an identifier 2.3
not allowed in a numericliteral 2.4.1
Space characterliteral 2.5; 2.2
Special character 2.1
[see also: basic graphic character, other
special character]
in a delimiter 2.2
Specification
[see: declaration, discriminant specification,
enumeration literal specification, generic
specification, loop parameter specification,
package specification, parameter specification,
subprogram specification, task specification]
STANDARD (predefined package) 8.6; C
[see also: library unit]
as a declarative region 8.1
enclosing the library units of a program
10.1.1; 10.1, 10.2
including implicit declarations of fixed
point cross-multiplication and crossdivision 4.5.5
implicit recompilation of 3.5.7a
STANDARD_INPUT(text_io function) 14.3.2;
14.3.10
STANDARD_OUTPUT(text_io function) 14.3.2;
14.3.10
Star

[see: double star]
character 2.1
delimiter 2.2

Statement 5.1; 5, D
[see also: abort statement, accept statement,
addressattribute, assignment statement, block
statement, case statement, code statement,
compound statement, delay statement, entry
call statement, exit statement, goto statement,
if statement, label, loop statement, null
statement, procedure call statement, raise

index—51

statement, return statement, select statement,

sequence of statements, target statement]
allowed in an exception handler 11.2
as an overload resolution context 8.7
optimized 10.6
raising an exception 11.4.1; 11.4
that cannot be reached 10.6
Statementalternative
[see: case statement alternative]
Static constraint 4.9
on a subcomponent subject to a
componentclause 13.4
on a type 3.5.4, 3.5.7, 3.5.9, 13.2
Static discrete range 4.9
as a choice of an aggregate 4.3.2
as a choice of a case statement 5.4
as a choice of a variant part 3.7.3

Static expression 4.9; 8.7
as a bound in aninteger type definition
3.5.4
as a choice in a case statement 5.4
as a choice of a variant part 3.7.3
for a choice in a record aggregate 4.3.2
for a discriminant in a record aggregate
4.3.1
in an attribute designator 4.1.4
in an enumeration representation clause
13.3
in a fixed accuracy definition 3.5.9
in a floating accuracy definition 3.5.7
in a generic unit 12.1
in a length clause 13.2
in a numberdeclaration 3.2, 3.2.2

in a record representation clause 13.4
in priority pragma 9.8
whosetype is a universal type 4.10
Static others choice 4.3.2

Static subtype 4.9
of a discriminant 3.7.3
of the expression in a case statement 5.4
Status value D; 10.1
STATUS_ERROR(input-output exception) 14.4;
14.2.1, 14.2.2, 14.2.3, 14.2.4, 14.2.5, 14.3.2,
14.3.3, 14.3.4, 14.3.5, 14.3.10, 14.5 , 14.2a.2,
14.2a.3, 14.2a.4, 14.2a.5, 14.2b.3, 14.2b.4, 14.2b.5,
14.2b.6 14.2b.7, 14.2b.8, 14.2b.9, 14.2b.10

Index—52

Storage address of a component 13.4
[see also: address clause]
Storage bits
allocated to an object or type 13.2; 13.7.2
[see also: size]
of a record componentrelative to a
Storage unit 13.4
size of a storage unit 13.7
Storage deallocation
[see: unchecked_deallocation]
Storage minimization
[see: pack pragma]
Storage reclamation 4.8
Storage representation of a record 13.4
Storage unit 13.7
offset to the start of a record component
13.4
size of a storage unit in bits 13.7
Storage units allocated
[see: storage_size]
to a collection 13.2; 4.8, 11.1, 13.7.2
to a task activation 13.2; 9.9, 11.1, 13.7.2
Storage_check
[see: program_error exception, suppress]
STORAGE_ERROR(predefined exception) 11.1
[see also: suppress pragma]
raised by an allocator exceeding the
allocated storage 4.8; 11.1
raised by an elaboration of a declarative
item 11.1
raised by a task activation exceeding the
allocated storage 11.1
raised by the execution of a subprogram
call 11.1
STORAGE_SIZE(predefined attribute) 13.7.2; A
[see also: storage units allocated]
for an access type 3.8.2
for a task object or task type 9.9
specified by a length clause 13.2
STORAGE_UNIT (predefined named number)
[see: system.storage_unit]
STORAGE_UNIT (predefined pragma) 13.7; B
[see also: system.storage_unit]

STRING (predefined type) 3.6.3; C
[see also: predefined type]
as the parameterof value attribute 3.5.5
as the result of imageattribute 3.5.5

maximum numberof characters in value

of 3.6.3, F

String bracket 2.6; 2.10
String literal 2.6, 4.2; 2.2, 3.6.3

[see also: overloading of ... , percent mark

character, quotation character]

as a basic operation 3.3.3, 4.2; 3.6.2
as an operator symbol 6.1
as a primary 4.4
must not be the argument of a conversion
4.6
replaced by a catenation of basic
characters 2.10

Stub

[see: body stub]

Subaggregate 4.3.2
Subcomponent3.3; D
[see also: component, composite type, default
expression, discriminant, object]
depending on a discriminant 3.7.1; 5.2,
8.5
of a component for which a component
clause is given 13.4
renamed 8.5
that is a task object 9.2; 9.3
whosetypeis a limited type 7.4.4
whosetypeis a private type 7.4.1
Subprogram 6; D
[see also: actual parameter, completed
subprogram, derived subprogram, entry, formal
parameter, function, library unit, overloading
. , parameter and result type profile,
parameter, predefined subprogram, procedure,
program unit]
as a generic instance 12.3; 12
as a main program 10.1
as an operation 3.3.3; 7.4.2
including a raise statement 11.3
of a derived type 3.4
overloaded 6.6
renamed 8.5
subject to an address clause 13.5
subject to an inline pragma 6.3.2
subject to an interface pragma 13.9

subject to a representation clause 13.1
subject to a suppress pragma 11.7
with a separately compiled body 10.2
exporting Ada to non-Ada programs
13.9a.1.4
importing non-Ada from Ada programs
13.9, 13.9a.1.1, 13.9a.1.2, 13.9a.1.3
Subprogram body6.3; 6, D
[see also: body stub]
as a generic body 12.2
as a library unit 10.1
as a proper body 3.9
as a secondary unit 10.1
as a secondary unit compiled after the
correspondinglibrary unit 10.3
having dependent tasks 9.4
in a package body7.1
including an exception handler 11.2; 11
including an exit statement 5.7
including a goto statement 5.9
including an implicit declaration 5.1
including a return statement5.8
including code statements must be a
procedure body 13.8
inlined in place of each call 6.3.2
mustbe in the same declarative region
as the declaration 3.9, 7.1
not allowed for a subprogram subject to
an interface pragma 13.9
not yet elaborated at a call 3.9
raising an exception 11.4.1, 11.4.2
recompiled 10.3
Subprogram call 6.4; 6, 6.3, 12.3
[see also: actual parameter, entry call
statement, entry call, function call, procedure
call statement, procedurecall]
before elaboration of the body 3.9
statement replaced byaninlining of the
body 6.3.2
statement with a default actual parameter
6.4.2
to a derived subprogram 3.4
to a generic instance 12
Subprogram declaration 6.1; 6, D
and body as a declarative region 8.1
as a basic declaration 3.1
as a later declarative item 3.9
as library unit 10.1
as an overloaded declaration 8.3
implied by the body 6.3, 10.1

index—53

in a package specification 7.1
madedirectly visible by a use clause 8.4
of an operator 6.7
recompiled 10.3
Subprogram specification 6.1
and forcing occurrences 13.1
conforming to another 6.3.1
for a function 6.5
in a body stub 10.2
in a generic declaration 12.1; 12.1.3
in a renaming declaration 8.5
in a subprogram body 6.3
including the name of a private type 7.4.1
of a derived subprogram 3.4
Subtraction operation 4.5.3
for a real type 4.5.7
Subtype 3.3, 3.3.2; D
[see also: attribute of ... , base attribute,
constrained subtype, constraint, first named
subtype, operation of ... , result subtype,
Satisfy, size attribute, static subtype, type,
unconstrained subtype]
declared by a numeric type declaration
3.5.4, 3.5.7, 3.5.9
in a membership test 4.5.2
name [see: name of a subtype, type_
mark of a subtype]
not consideredin overload resolution 8.7
of an access type 3.8
of an actual parameter6.4.1
of an array type [see: constrained array
type, index constraint]
of a componentof an array 3.6
of a component of a record 3.7
of a constant in a static expression 4.9
of a discriminant of a generic formal type
12.3.2
of a formal parameter 6.4.1
of a formal parameteror result of a
renamed subprogram or entry 8.5
of a generic formal type 12.1.2
of an index of a generic formal array type
12.3.4
of an object [see: elaboration of ... ]
of a private type 7.4, 7.4.1
of a real type 3.5.7, 3.5.9; 3.5.6, 4.5.7
of a record type [See: constrained record
type, discriminant constraint]
of a scalar type 3.5
of a task type 9.2

Index—54

of a variable 5.2
subject to a representation clause 13.1
Subtype conversion 4.6
[see also: conversion operation, explicit
conversion, implicit conversion, type
conversion]
in an array assignment 5.2.1; 5.2
to a real type 4.5.7
Subtype declaration 3.3.2; 3.1
and forcing occurrences 13.1
as a basic declaration 3.1
including the name of a private type 7.4.1
Subtype definition
[see: component subtype definition,
dependenceon a discriminant, index subtype
definition]
Subtypeindication 3.3.2
[see also: elaboration of ... ]
as a component subtype indication 3.7
as a discrete range 3.6
for a subtype of a generic formal type
12.1.2
in an accesstype definition 3.8
in an allocator 4.8
in an array type definition 3.6
in a component declaration 3.7
in a constrained array definition 3.6
in a derived type definition 3.4
in a generic formal part 12.1
in an object declaration 3.2, 3.2.1
in an unconstrained array definition 3.6
including a fixed point constraint 3.5.9
including a floating point constraint 3.5.7
with a range constraint 3.5
Subunit 10.2; D
[see also: library unit]
as a compilation unit 10.4
as a library unit 10.4
as a secondary unit 10.1
compiled after the corresponding parent
unit 10.3
not allowed for a subprogram subject to
an interface pragma 13.9
of a compilation unit subject to a context
clause 10.1.1
raising an exception 11.4.1, 11.4.2
recompiled (does not affect other
compilation units) 10.3

SUCC(predefined attribute) 3.5.5; 13.3, A
Successor
[see: succattribute]
SUPPRESS(predefined pragma) 11.7; 11.1, B
SUPPRESS_ALL (VAX Ada predefined pragma)
11.7;B
Symbol
[see: graphical symbol, operator symbol]
Synchronization of tasks
[see: task synchronization]
Syntactic category 1.5
Syntax notation 1.5
Syntax rule 1.5; E
SYSTEM(predefined library package) 13.7; C, F
System dependent F
attribute 13.4
constant 13.7
named number13.7, 13.7.1
record component 13.4
type 13.7
System services (VMS)
asynchronous 9.12a
calling from VAX Ada 9.12a
clock interval provided by 13.7.1
using null_parameter (VAX Ada
predefined attribute) in calls to 13.9a.1.3
reading volatile variables from 9.11
SYSTEM.ADD_INTERLOCKED(VAX Ada
predefined procedure) 13.7a.10
SYSTEM.ADDRESS(predefined type) 13.7; 13.5
[see also: address attribute, address clause]
properties of 13.7a.1

SYSTEM.AST_HANDLER(VAX Ada predefined
type) 13.7a.4; 9.12a
SYSTEM.BIT_ARRAY(VAX Adapredefined type
and associated subtypes) 13.7a.6

SYSTEM.D_FLOAT(VAX Ada predefined type)
3.5.7; 13.7a.3
SYSTEM.CLEAR_INTERLOCKED (VAX Ada
predefined procedure) 13.7a.10
SYSTEM.FETCH_FROM_ADDRESS (VAX Ada
generic function) 13.7a.1

SYSTEM.F_FLOAT (VAX Adapredefined type)
3.5.7; 13.7a.3
SYSTEM.FINE_DELTA (predefined named number)
13.7.1
SYSTEM.G_FLOAT(VAX Adapredefined type)
3.5.7; 13.7a.3
SYSTEM.H_FLOAT (VAX Ada predefined type)
3.5.7; 13.7a.3
SYSTEM.IMPORT_VALUE(VAX Ada predefined
function) 13.7a.8
SYSTEM.INSQHI (VAX Ada predefined procedure)
13.7a.10
SYSTEM.INSQ_STATUS (VAX Ada predefined
type) 13.7a.10
SYSTEM.INSQTI (VAX Ada predefined procedure)
13.7a.10
SYSTEM.MAX_DIGITS (predefined named number)
13.7.1
limit on the significant digits of a floating
point type 3.5.7

SYSTEM.ADDRESS_ZERO (VAX Ada predefined
constant) 13.7a.1; 13.7.2

SYSTEM.MAX_INT (predefined named number)
13.7.1; 3.5.4
exceeded by the value of a universal
expression 4.10

SYSTEM.ALIGNED_WORD(VAX Adapredefined
type) 13.7a.10

SYSTEM.MAX_MANTISSA(predefined named
number) 13.7.1

SYSTEM.ASSIGN_TO_ADDRESS (VAX Ada
generic procedure) 13.7a.1

SYSTEM.MEMORY_SIZE (predefined named
number) 13.7

Index—55

SYSTEM.MFPR (VAX Adapredefined function)

SYSTEM.TO_BIT_ARRAY_64 (VAX Ada
predefined function) 13.7a.6

SYSTEM.MIN_INT (predefined named number)
13.7.1; 3.5.4
greater than the value of a universal
expression 4.10

SYSTEM.TO_INTEGER (VAX Ada predefined
function) 13.7a.6

13.7a.9

SYSTEM.MTPR (VAX Ada predefined procedure)
13.7a.9
SYSTEM.NAME (predefined type) 13.7
SYSTEM.NO_AST_HANDLER (VAX Ada
predefined constant) 13.7a.4; 9.12a
SYSTEM.NON_ADA_ERROR(VAX Ada predefined
exception) 13.7a.5; 11.2
SYSTEM.READ_REGISTER (VAX Ada predefined
function) 13.7a.9
SYSTEM.REMQHI(VAX Ada predefined procedure)
13.7a.10
SYSTEM.REMQ_STATUS(VAX Ada predefined
type) 13.7a.10
SYSTEM.REMQTI (VAX Ada predefined procedure)
13.7a.10

SYSTEM.TO_UNSIGNED_BYTE (VAX Ada
predefined function) 13.7a.6
SYSTEM.TO_UNSIGNED_LONGWORD(VAX Ada
predefined function) 13.7a.6

SYSTEM.TO_UNSIGNED_QUADWORD(VAX Ada
predefined function) 13.7a.6

SYSTEM.TO_UNSIGNED_WORD(VAX Ada
predefined function) 13.7a.6

SYSTEM.TYPE_CLASS(VAX Ada predefined type)
13.7a.2
SYSTEM.UNSIGNED_BYTE(VAX Adapredefined
type) 13.7a.6
SYSTEM.UNSIGNED_BYTE_ARRAY (VAX Ada
predefined type) 13.7a.6
SYSTEM.UNSIGNED_LONGWORD(VAX Ada
predefined type) 13.7a.6

SYSTEM.SET_INTERLOCKED (VAX Ada
predefined procedure) 13.7a.10

SYSTEM.UNSIGNED_LONGWORD_ARRAY(VAX
Ada predefined type) 13.7a.6
static subtypes of 13.7a.7

SYSTEM.STORAGE_UNIT (predefined named
number) 13.7; 13.4

SYSTEM.UNSIGNED_QUADWORD(VAX Ada
predefined type) 13.7a.6

SYSTEM.SYSTEM_NAME(predefined constant)
13.7
[see also: system_name]

SYSTEM.UNSIGNED_QUADWORD_ARRAY(VAX
Ada predefined type) 13.7a.6

SYSTEM.TICK (predefined named number) 13.7.1;
9.6

type) 13.7a.6

SYSTEM.TO_ADDRESS (VAX Ada predefined
function) 13.7a.6
SYSTEM.TO_BIT_ARRAY_8 (VAX Adapredefined
function) 13.7a.6
SYSTEM.TO_BIT_ARRAY_16 (VAX Ada
predefined function) 13.7a.6
SYSTEM.TO_BIT_ARRAY_32 (VAX Ada
predefined function) 13.7a.6

Index—56

SYSTEM.UNSIGNED_WORD(VAX Adapredefined
SYSTEM.UNSIGNED_WORD_ARRAY (VAX Ada
predefined type) 13.7a.6

SYSTEM.WRITE_REGISTER (VAX Ada predefined
procedure) 13.7a.9
SYSTEM_NAME(predefined pragma) 13.7; B
[see also: system.system_namepredefined
constant]

Tabulation
[see: horizontal tabulation, vertical tabulation]
Target statement (of a goto statement) 5.9
Target type of a conversion 4.6
Task 9; D

[see also: abnormal task, abort statement,
accept statement, communication
between ... , completed task, delay
statement, dependent task, entry (of a
task), entry call statement, rendezvous, select
statement, selective wait, shared variable,
single task, terminated task]
calling the main program 10.1
raising an exception 11.5
scheduling 9.8 ,9.8a
suspension awaiting a rendezvous 9.5
suspension by a delay statement 9.6
suspension by a selective wait 9.7.1
suspension of an abnormal task 9.10
[see also: main_storage pragma, task_storage
pragma,time_slice pragma]

Task activation 9.3
[see also: length clause, storage units
allocated, storage_size attribute]

before elaboration of the body 3.9
causing synchronization 9.10, 9.11
not started for an abnormal task 9.10
of a task with no task body 11.1
specification of storage for 13.2a

Task body 9.1; 9, D
[see also: body stub, elaboration of ... ]
as a proper body 3.9
in a package body 7.1
including an exception handler 11.2; 11
including an exit statement 5.7
including a goto statement 5.9
including an implicit declaration 5.1
must be in the same declarative region
as the declaration 3.9, 7.1
not yet elaborated at an activation 3.9
raising an exception 11.4.1, 11.4.2
specifying the execution of a task 9.2, 9.3
Task communication
[see: rendezvous]

Task declaration 9.1
and body as a declarative region 8.1
as a basic declaration 3.1
as a later declarative item 3.9
elaboration raising an exception 11.4.2
in a package specification 7.1
Task dependence
[see: dependent task]
Task designated
by a formal parameter 6.2
by a value of a task type 9.1; 9.2, 9.4, 9.5
Task execution 9.3
Task object 9.2; 9.1, 9.5

[see also: attribute of ... , task activation]
designated by an access value 9.2
determining task dependence 9.4
renamed 8.5

Task priority 9.8
[see also: priority pragma,priority subtype]
of a task with an interrupt entry 13.5.1
Task specification 9.1; 9, D
[see also: elaboration of ... ]
including an entry declaration 9.5
including a priority pragma 9.8
including a representation clause 13.1
Task storage
[see: main_storage pragma, task_storage
pragma]
Task synchronization 9.5; 9.11
Task termination

[see: terminated task]

Task type 9.1, 9.2; D
[see also: attribute of ... , class of type,
derived type of a task type, limited type]
completing an incomplete type definition
3.8.1
formal parameter 6.2
objectinitialization 3.2.1
value designating a task object 3.2.1, 9.1,
9.2

Task completion
[see: completed task]

Index—57

Task unit 9.1; 9
[see also: program unit]
declaration determining thevisibility of
anotherdeclaration 8.3
including a raise statement 11.3
subject to an address clause 13.5
subject to a representation clause 13.1
subject to a suppress pragma 11.7
with a separately compiled body 10.2

Text of a program 2.2, 10.1

TASKING_ERROR(predefined exception) 11.1
[see also: suppress pragma]
raised by an entry call to an abnormal
task 9.10, 11.5
raised by an entry call to a completed
task 9.5, 9.7.2, 9.7.3, 11.5
raised by an exception in the task body
11.4.2
raised byfailure of an activation 9.3;
11.4.2

TIME (predefined type) 9.6
[see also: clock, date, day, make_time, month,
system.tick, year]

TASK_STORAGE (VAX Adapredefined pragma)
13.2a; B
Template
[see: generic unit]
Term 4.4

in a simple expression 4.4

Terminate alternative (of a selective wait) 9.7.1
[see also: select statement]
causing a transfer of control 5.1
in a select statement causing a loop to
be exited 5.5
selection 9.4
selection in the presence of an accept
alternative for an interrupt entry 13.5.1
TERMINATED (predefined attribute) for a task
object 9.9; A
Terminated task 9.4; 9.3, 9.9
[see also: completed task]
not becoming abnormal 9.10
object or subcomponent of an object
designated by an access value 4.8
termination of a task during its activation
9.3
Terminator
[see: file terminator, line terminator, page
terminator]
Text input-output 14.3; 14.2.1
Index—58

TEXT_IO (predefined input-output package) 14.3;
14, 14.1, 14.3.9, 14.3.10, C
exceptions 14.4; 14.5
specification 14.3.10
TICK
[see: system.tick]

TIME_ERROR(predefined exception) 9.6
TIME_OF (predefined function) 9.6
TIME_SLICE (VAX Ada predefined pragma) 9.8a; B
Timed entry call 9.7.3; 9.7
and renamedentries 8.5
subject to an address clause 13.5.1
Times operator
[see: multiplying operator]
TITLE (VAX Ada predefined pragma) B
TO_ADDRESS (VAX Adapredefined function)
[see: system.to_address]
TO_BIT_ARRAY_8 (VAX Ada predefined function)
[see: system.to_bit_array_8]
TO_BIT_ARRAY_16 (VAX Ada predefined function)
[see: system.to_bit_array_16]
TO_BIT_ARRAY_32 (VAX Ada predefined function)
[see: system.to_bit_array_32]
TO_BIT_ARRAY_64 (VAX Adapredefined function)
[see: system.to_bit_array_64]
TO_INTEGER (VAX Adapredefined function)
[see: system.to_integer]
TO_UNSIGNED_BYTE(VAX Ada predefined
function)
[see: system.to_unsigned_byte_]
TO_UNSIGNED_LONGWORD(VAX Ada
predefined function)
[see: system.to_unsigned_longword]

TO_UNSIGNED_QUADWORD(VAX Ada
predefined function)
[see: system.to_unsigned_quadword]
TO_UNSIGNED_WORD(VAX Adapredefined
function)
|
[see: system.to_unsigned_word]
Transfer of control 5.1
[see also: exception, exit statement, goto
statement, return statement, terminate
alternative]
TRUE boolean enumeration literal 3.5.3; C

Type 3.3; D
[see also: access type, appropriate for a type,
array type, attribute of ... , base attribute,
base type, boolean type, character type,
class of type, composite type, constrained
type, derived type, discrete type, discriminant
of ... , enumeration type, fixed point type,
floating point type, forcing occurrence,
generic actual type, generic formal type,
integer type, limited private type, limited
type, numeric type, operation of ... , parent
type, predefined type, private type, real type,
record type, representation clause, scalar
type, size attribute, storage allocated, subtype,
unconstrained subtype, unconstrained type,
universal type]
name 3.3.1
of an actual parameter 6.4.1
of an aggregate 4.3.1, 4.3.2
of an array componentof a generic
formal array type 12.3.4
of an array index of a generic formal
array type 12.3.4
of a case statement expression 5.4
of a condition 5.3

of a declared object 3.2, 3.2.1

of a discriminant of a generic formal
private type 12.3.2
-of an expression 4.4
of a file 14.1
of a formal parameter of a generic formal
subprogram 12.1.3
of a generic actual object 12.3.1
of a generic formal object 12.1.1; 12.3.1
of an index 4.1.1
of a loop parameter 5.5
of a named number3.2, 3.2.2

of an object designated by a generic
formal access type 12.3.5
of a primary in an expression 4.4
of a shared variable 9.11
of a slice 4.1.2
of a string literal 4.2
of a task object 9.2
of a universal expression 4.10
of a value 3.3; 3.2
of discriminants of a generic formal object
and the matching actual object 12.3.2
of the literal null 4.2
of the result of a generic formal function
12.1.3
renamed 8.5
subject to a representation clause 13.1;
13.6
subject to a suppress pragma 11.7
yielded by an attribute 4.1.4
Type conversion 4.6
[see also: conversion operation, conversion,
explicit conversion, subtype conversion,
unchecked_conversion]
as an actual parameter6.4, 6.4.1
as a primary 4.4
in a static expression 4.9
to a real type 4.5.7
Type declaration 3.3.1
[see also: elaboration of ... , incomplete type
declaration, private type declaration]
as a basic declaration 3.1
as a full declaration 7.4.1
implicitly declaring operations 3.3.3
in a package specification 7.1
including the name of a private type 7.4.1
of a fixed point type 3.5.9
of a floating point type 3.5.7
of an integer type 3.5.4
of a subtype 13.1
Type definition 3.3.1; D
[see also: access type definition, array type
definition, derived type definition, elaboration
of ... , enumeration type definition, generic
type definition, integer type definition, real type
definition, record type definition]

Index—59

Type mark (denoting a type or subtype) 3.3.2
as a generic actual parameter 12.3
in an allocator 4.8
in a code statement 13.8
in a conversion 4.6
in a deferred constant declaration 7.4
in a discriminant specification 3.7.1
in a generic formal part 12.1, 12.3
in a generic parameterdeclaration 12.3.1
in an index subtype definition 3.6
in a parameter specification 6.1; 6.2
in a qualified expression 4.7
in a relation 4.4
in a renaming declaration 8.5

in a subprogram specification 6.1
of a formal parameter of a generic formal
subprogram 12.1.3
of a generic formal array type 12.1.2
of a static scalar subtype 4.9
of the result of a generic formal function
12.1.3
Type with discriminants 3.3; 3.3.1, 3.3.2, 3.7,
3.7.1, 7.4, 7.4.1
[see also: private type, record type]
as an actual to a formal private type
12.3.2
as the componenttype of an array that is
the operand of a conversion 4.6

UNCHECKEDCONVERSION(predefined generic
library function) 13.10.2; 13.10, C
UNCHECKED_DEALLOCATION(predefined
generic library procedure) 13.10.1; 4.8, 13.10, C
Unconditional termination of a task

[see: abnormal task, abort statement]

Unconstrained array definition 3.6
Unconstrained array type 3.6; 3.2.1
as an actual to a formal private type
12.3.2
formal parameter 6.2
subject to a length clause 13.2
Unconstrained subtype 3.3, 3.3.2
[see also: constrained subtype, constraint,
subtype, type]
indication in a generic unit 12.3.2
Unconstrained type 3.3; 3.2.1, 3.6, 3.6.1, 3.7,
3.7.2
formal parameter 6.2
with discriminants 6.4.1, 12.3.2
Unconstrained variable 3.3, 3.6, 3.7; 12.3.1
as a subcomponent[see: subcomponent]
Undefined value

of a scalar parameter6.2

TYPE_CLASS (VAX Ada predefined attribute)
13.7a.2; A
TYPE_CLASS (VAX Ada predefined type)
[see: system.type_ciass]

of a scalar variable 3.2.1

Underfiow (floating point) handling in an exception
11.1
Underline character 2.1
in a basedliteral 2.4.2
in a decimalliteral 2.4.1
in an identifier 2.3

Unary adding operator 4.4, 4.5, C; 4.5.4
[see also: arithmetic operator, overloading of
an operator, predefined operator]
as an operation of a discrete type 3.5.5
in a simple expression 4.4
overloaded 6.7
Unary operator 4.5; 3.5.5, 3.5.8, 3.5.10, 3.6.2,

4.5.4, 4.5.6, C
[see also: highest precedence operator, unary
adding operator]

Index—60

Unhandled exception 11.4.1
Unit

[see: compilation unit, generic unit, library unit,
program unit, storage unit, task unit]

Universal expression 4.10
assigned 5.2
in an attribute designator 4.1.4
of a real type implicitly converted 4.5.7
that is static 4.10

Universal type 4.10
[see also: conversion, implicit conversion]
expression [see: expression, numeric
literal]
of a named number3.2.2; 3.2
result of an attribute [see: attribute]
UNIVERSAL_FIXED (predefined type) 3.5.9
result of fixed point multiplying operators
4.5.5
UNIVERSAL_INTEGER (predefined type) 3.5.4,
4.10; C

[see also: integerliteral]
argumentof a conversion 3.3.3, 4.6
attribute 3.5.5, 13.7.1, 13.7.2, 13.7.3; 9.9
bounds of a discrete range 3.6.1
bounds of a loop parameter5.5
codes representing enumeration type

values 13.3
converted to an integer type 3.5.5
of integerliterals 2.4, 4.2
result of an operation 4.10; 4.5

UNIVERSAL_REAL(predefined type) 3.5.6, 4.10
{see also: real literal]
argument of a conversion 3.3.3, 4.6
attribute 13.7.1
converted to a fixed point type 3.5.10
converted to a floating point type 3.5.8
of realliterals 2.4, 4.2
result of an operation 4.10; 4.5
UNLOCK (VAX Adainput-output procedure)
in an instance of indexed_io 14.2a.4,
14.2a.5
in an instanceof relative_io 14.2a.2,
14.2a.3
in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8
UNSIGNED_BYTE (VAX Adapredefined type)
[see: system.unsigned_byte]

UNSIGNED_BYTE_ARRAY(VAX Ada predefined

type)

[see: system.unsigned_byte_array]

UNSIGNED_LONGWORD(VAX Adapredefined
type)
[see: system.unsigned_longword]

UNSIGNED_LONGWORD_ARRAY (VAX Ada

predefined type)
[see: system.unsigned_longword_array]

UNSIGNED_QUADWORD(VAX Adapredefined
type)
[see: system.unsigned_quadword]
UNSIGNED_QUADWORD_ARRAY(VAX Ada
predefined type)
[see: system.unsigned_quadword_array]
UNSIGNED_WORD(VAX Ada predefined type)
[see: system.unsigned_word]

UNSIGNED_WORD_ARRAY(VAX Ada predefined

type)

[see: system.unsigned_word_array]

UPDATE (VAX Adainput-output procedure)
in an instance of indexed_io 14.2a.4,
14.2a.5
in an instance of relative_io 14.2a.2,
14.2a.3
in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8
Updating the value of an object 6.2
Upper bound
[see: bound, last attribute]
Upper caseletter 2.1
[see also: basic graphic character]
A to F in a basedliteral 2.4.2
E in a decimalliteral 2.4.1
in an identifier 2.3
Urgencyof a task
[see: task priority]
Use clause(to achieve direct visibility) 8.4; 8.3, D
[see also: context clause]
as a basic declarative item 3.9
as a later declarative item 3.9
in a code procedure body 13.8
in a context clause of a compilation unit
10.1.1
in a context clause of a subunit 10.2
inserted by the environment 10.4
USE_ERROR(input-output exception) 14.4; 14.2.1,
14.2.3, 14.2.5, 14.3.3, 14.3.10, 14.5, 14.2a.2,
14.2a.3, 14.2a.4, 14.2a.5, 14.2b.4, 14.2b.6,
14.2b.7, 14.2b.8, 14.2b.9, 14.2b.10
index—61

VAL (predefined attribute) 3.5.5; A
Value
[see: assignment, evaluation, expression,
initial value, returned value, subtype , task
designated ... , type]
in a constant 3.2.1; 3.2
in a task object 9.2
in a variable 3.2.1, 5.2; 3.2
of an access type [see: object
designated, task object designated]
of an array type 3.6; 3.6.1 [see also:
array, slice]
of a basedliteral 2.4.2
of a boolean type 3.5.3
of a characterliteral 2.5
of a character type 3.5.2; 2.5, 2.6
of a decimalliteral 2.4.1
of a fixed point type 3.5.9, 4.5.7
of a floating point type 3.5.7, 4.5.7
of a record type 3.7
of a record type with discriminants 3.7.1
of a string literal 2.6; 2.10
of a task type [see: task designated]
returned by a function call [see: returned
value]
VALUE (predefined attribute) 3.5.5; A
Value parameter passing mechanism 13.9a.1.2
Variable 3.2.1; D
[see also: object, shared variable]
as an actual parameter 6.2
declared in a package body 7.3
formal parameter6.2
in an assignment statement 5.2
of an array type as destination of an
assignment5.2.1
of a private type 7.4.1
renamed 8.5
that is a slice 4.1.2
Variable declaration 3.2.1

Variant 3.7.3; 4.1.3
[see also: componentclause, record type]
in a variant part 3.7.3

Index—62

Variant part 3.7.3; D

[see also: dependence on a discriminant]
in a componentlist 3.7
in a record aggregate 4.3.1

Vertical bar character 2.1
replacement by exclamation character
2.10
Vertical bar delimiter 2.2
Vertical tabulation format effector 2.1

Violation of a constraint
[see: constraint_error exception]
Visibility 8.3; 8.2, D
[see also: direct visibility, hiding, identifier,

name, operation, overloading]

and renaming 8.5
determining multiple meanings of an
identifier 8.4, 8.7; 8.5

determining order of compilation 10.3
due to a use clause 8.4
of a basic operation 8.3
of a characterliteral 8.3
of a default for a generic formal
subprogram 12.3.6
of a generic formal parameter 12.3
of a library unit due to a with clause 8.6,
10.1.1
of a nameof an exception 11.2
of an operation declared in a package
7.4.2
of an operator symbol8.3
of a renaming declaration 8.5
of a subprogram declared in a package
6.3
of declarations in a package body 7.3
of declarations in a package specification
7.2
of declarations in the package system
13.7
within a subunit 10.2
Visibility by selection 8.3
[see also: basic operation, character
literal, operation, operator symbol, selected
component]

Visible part (of a package) 7.2; 3.2.1, 7.4, 7.4.1,
7.4.3, D
[see also: deferred constant declaration,
private type declaration]
expanded name denoting a declaration in
a visible part 8.2
scope of a declaration in a visible part
4.1.3
use clause naming the package 8.4
visibility of a declaration in a visible part
8.3

WRITE_REGISTER(VAX Adapredefined
procedure)
[see: system.write_register]
Writing to an outputfile 14.1, 14.2.2, 14.2.4

VOLATILE (VAX Ada predefined pragma) 9.11; B

Xor operator
[see: logical operator]

Wait

YEAR(predefined function) 9.6

[see: selective wait, task suspension]

While loop
[see: loop statement]
WIDTH (predefined attribute) 3.5.5; A
With clause 10.1.1; D
[see also: context clause]
determining order of compilation 10.3
determining the implicit order of library
units 8.6
in a context clause of a compilation unit
10.1.1
in a context clause of a subunit 10.2
inserted by the environment 10.4
leading to direct visibility 8.3
WRITE(input-output procedure)
in an instance of direct_io 14.2.4; 14.1,
14.2, 14.2.5
in an instance of sequential_io 14.2.2;
14.1, 14.2, 14.2.3
in an instance of indexed_io 14.2a.4,
14.2a.5
in an instance of relative_io 14.2a.2,
14.2a.3
in direct_mixed_io 14.2b.5, 14.2b.6
in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8
in sequential_mixed_io 14.2b.3, 14.2b.4

| index—63

Postscript : Submission of Comments
NOTE
This postscript is not part of the standard definition of the Ada
programming language.

For submission of comments on the VAX Ada information (all material printed in
color), use the Reader’s Comments form at the back of the manual. For reporting
errors or problems encountered when using the VAX Adasoftware, submit a Software
Problem Report (SPR); see Developing Ada Programs on VMS Systems for more
information.
For submission of comments on the standard Ada reference manual (all material

printed in black), use the Arpanet address
Ada-Comment at ECLB

If you do not have Arpanet access, please send the comments on the standard Ada
reference manual by mail to
Ada Joint Program Office (AJPO)
Office of the Under Secretary of Defense Research and Engineering
_ Washington, DC 20301
United States of America
If you mail your comments, it will assist the AJPO if you can send them on 8-inch

single-sided single-density IBM format diskettes—with an additional paper copy, in

case of problems with reading the diskettes.

All comments are sorted and processed mechanically, in order to simplify their analysis
and to facilitate giving them proper consideration. To aid this process, please precede
each comment with the three line header
!section ...
lversion 1983

Itopic ...

The section line should include the section number, the paragraph numberenclosed
in parentheses, your nameoraffiliation (or both), and the date in ISO standard form
(year-month-day). The paragraph numberis the one given in the margin of the paper
form of this document (it is not contained in the ECLBfiles); paragraph numbers are
optional, but very helpful. For example, here is the section line of comment #1194 on a
previous version:

!section 03.02.01(12)D.Taffs 82-04-26

The version line for comments on the current standard should contain only “!version
1983”. The purpose of this line is to distinguish comments that refer to different

versions.

The topic line should contain a one line summary of the comment. This lineis
essential, and you are kindly asked to avoid topics such as “Typo” or “Editorial
comment”, which will not convey any information whenprinted in a table of contents.
As an example of an informative topic line consider:
[topic Subcomponents of constants are constants
Note also that nothing prevents the topic line from includingall the information of a
comment, as in the following topic line:
[topic Insert: “... are {implicitly} defined by a subtype declaration”
Asa anal example here is a complete comment received on a prior version of this
manual:
!section 03.02.01(12)D.Taffs 82-04-26
!version 10
!topic Subcomponentsof constants are constants
Change “component” to “subcomponent”in the last sentence.
Otherwise the statement is inconsistent with the defined use of subcomponent
in 3.3, which says that subcomponents are excluded when the term componentis
used instead of subcomponent.

How to Order Additional Documentation

Technical Support
If you need help deciding which documentation best meets your needs, call 800-343-4040
before placing yourelectronic, telephone, or direct mail order.

Electronic Orders
To place an order at the Electronic Store, dial 800-DEC-DEMO (800-332-3366) using
a 1200- or 2400-baud modem. If you need assistance using the Electronic Store,
call 800-DIGITAL (800-344-4825).

Telephone and Direct Mail Orders
Your Location

Call

Contact

Continental USA,

800-DIGITAL

Digital Equipment Corporation
P.O. Box CS2008
Nashua, New Hampshire 03061

Puerto Rico

809-754-7575

Local DIGITAL subsidiary

Canada

800-267-6215

Digital Equipment of Canada
Attn: DECdirect Operations KAO2/2
P.O. Box 13000
100 Herzberg Road
Kanata, Ontario, Canada K2K 2A6

Alaska, or Hawaii

International

Local DIGITAL subsidiary or
approved distributor

Internal?!

SDC Order Processing - WMO/E15
or
Software Distribution Center
Digital Equipment Corporation
Westminster, Massachusetts 01473

lor internal orders, you must submit an Internal Software Order Form (EN-01740-07).

Reader’s Comments

VAX Ada Language Reference Manual
AA—EG29B-TE

Please use this postage-paid form to comment on this manual. If you require a written
reply to a software problem andare eligible to receive one under Software Performance
Report (SPR) service, submit your comments on an SPR form.
Thank you for your assistance.

I rate this manual’s:
Accuracy (software works as manual says)
Completeness (enough information)
Clarity (easy to understand)
Organization (structure of subject matter)
Figures (useful)
Examples (useful)
Index (ability to find topic)
Page layout (easy to find information)

Excellent

Good

Fair

Poor

CL]
C)
CL
OJ
O
LJ
CJ
LJ

L
LJ
O
CJ
LJ
LJ
L
LJ

L
LO
C
C
CU)
O
L)
LO

O
C]
CO
LJ
O
CL]
L
OJ

I would like to see more/less
What I like best about this manual is
WhatI like least about this manual is

I found the following errors in this manual:
Page
Description

Additional comments or suggestions to improve this manual:

I am using Version
Name/Title

of the software this manual describes.
Dept.

Company

Date

Mailing Address
Phone

-— Do Not Tear - Fold Here and Tape ——————————---——

SOSHRE0"

No Postage
Necessary
if Mailed
in the
United States

ee
ee

BUSINESS REPLY MAIL

FIRST CLASS PERMIT NO. 33 MAYNARD MASS.
POSTAGE WILL BE PAID BY ADDRESSEE

DIGITAL EQUIPMENT CORPORATION
Corporate User Publications—Spit Brook
ZKO1—3/J35
110 SPIT BROOK ROAD
NASHUA, NH 03062-9987

Pe
PO
ee
Pe
ee
PS

Along Dotted Line

-— Do Not Tear - Fold Here —-——-———————

Pe
Pe

Reader’s Comments

VAX Ada Language Reference Manual
AA-EG29B-TE

Please use this postage-paid form to comment on this manual. If you require a written
reply to a software problem andareeligible to receive one under Software Performance
Report (SPR) service, submit your comments on an SPR form.
Thank you for your assistance.

I rate this manual’s:

Excellent

Good

Fair

Poor

Accuracy (software works as manual says)
Completeness (enough information)
Clarity (easy to understand)
Organization (structure of subject matter)

O
C
C)
L]

C)
C)
O
O

C)
CJ
LJ
O

O
O
CJ
CJ

Examples (useful)
Index (ability to find topic)
Page layout (easy to find information)

C]
O
C)

Figures (useful)

L
C)
OJ

CL)
L
CJ

I would like to see more/less
What I like best about this manual is
What I like least about this manual is

I found the following errors in this manual:
Page
Description

Additional comments or suggestions to improve this manual:

I am using Version
Name/Title
Company

of the software this manual describes.
Dept.
|

Date

Mailing Address
Phone

C
C
C

Do Not Tear - Fold Here and Tape

_-———

SOSHRE0"

No Postage
Necessary
if Mailed
in the
United States

BUSINESS REPLY MAIL

FIRST CLASS PERMIT NO. 33 MAYNARD MASS.
POSTAGE WILL BE PAID BY ADDRESSEE

DIGITAL EQUIPMENT CORPORATION
Corporate User Publications—Spit Brook
ZKO1-—3/J35
110 SPIT BROOK ROAD
NASHUA, NH 03062-9987

a
a
Pe
ee
Se
ee

ut Along D-‘tted Line

Do Not Tear - Fold Here

‘

—-—

PS
PE
a
as