Digital PDFs

AA-EG29B-TE

May 1989

684 pages

Original

54MB

view download

OCR Version

46MB

view download

Document:	VAX Ada Language Reference Manual
Order Number:	AA-EG29B-TE
Revision:	000
Pages:	684
Original Filename:

OCR Text

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

ATE

THIS PRODUCT CONFORMS

TO ANSI/MIL-STD-1815A AS

DETERMINED BY THE AJPO
UNDER ITS 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 appear in 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 use or reliability of software on equipment that is
not supplied by Digital Equipment Corporation or its affiliated companies.

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 the first 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
DEC
DEC/CMS
DEC/MMS
DECnet

EduSystem
IAS
MASSBUS
PDP
PDT

DECsystem-10
DECSYSTEM-20
DECUS

Professional
Q-bus
Rainbow

VT
Work Processor
VAXELN

RSX

dlilofilt|a[1

DECmate

DECwriter

DIBOL

P/OS

RSTS

RT
ULTRIX
UNIBUS
VAX
VAXcluster

VMS

ZK3227

Contents
Preface . ... ...

XixX

ScopeoftheStandard ... ............
... ... . ... . . . ...

1-1

1.1.1

Extentof the Standard . . . .. ...........
... .. .. ...

1-2

1.1.2

Conformity of an Implementation With the Standard . . . . . ...

1-3

New and Changed Features ... .......... ... .. . ...

Chapter 1
1.1

Introduction

1.2

Structureofthe Standard . . . . ... ........ ...

.. ...

1-3

Design Goalsand Sources . ... ..........
... ...
..

1—4

Language Summary . . ... ... ... ...ttt
e

1-5

1.4a

VAX Ada . . .. ..

1-9

1.5

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

1-9

1.6

Classification of Errors . . . . . . ...... ...

...

1-11

Chapter 2

e e

...

. ..

Lexical Elements

2.1

Character Set.

. .. ... ... .. .

2—1

2.2

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

2-3

2.3

Identifiers

2-5

. ....... ... . .

e e e e e e e e e e

2.4.1

Numeric Literals . . . . . . . . . .

Decimal Literals . . . . .........
.. ...

2—6

2.4.2

Based Literals . . . ... ... ...

2—7

2.5

Character Literals . . . . .. ...

2.6

String Literals

. ... . .

.. . . .. .

2-8

. ... .. ... ... . . . ...

2-8

2.7

Comments . .. ... .. ... ... e

2-9

2.8

Pragmas . . ... ...

2-10

2.9

Reserved Words . . . . . . ... ... ...

. e

2—-11

2.10

Allowable Replacements of Characters

Chapter 3

...

e e e e e e e e e

......................

2-12

Declarations and Types

3.1

Declarations

. ...........
.. ...
i

3-1

3.2

Objects and Named Numbers . ... ....... ... .. ... ... ... .....

3-3

3.2.1

Object Declarations

. . ... ..... ... .. ...

3.2.2

Number Declarations

. ............
... ... . ... . ....

3-7

Types and Subtypes . . . . .. . ... .. e

3-8

3.3

3.3.1

Type Declarations

... ... ... ... .. ... ... ..

. ...,

3-9

3.3.2

Subtype Declarations ... ............
.. ... . ... .. ...

3-11

3.3.3

Classification of Operations . . ... ...................

3-12

3.4

Derived Types . ... ...................e

3.5

Scalar TYPeS . . ... .

e e e e

3-17
3-18

Character Types

.. ... ... ittt
e it

3-19

3.5.3

Boolean Types

. .. ... ... . . i

3-20

3.5.4

Integer Types

3.5.5

Operations of Discrete Types . . . . .. ... ...

3.5.6

Real Types . ... ... .

3.5.7

Floating Point Types . . . . . . ... ...

3-27

3.5.7a

Pragma LONG_FLOAT . ... ... ... . ..

3-31

3.5.8

Operations of Floating Point Types . . . ... .............

3-32

3.5.9

Fixed Point Types

. ... ... . .. . .. ...

3-34

3.5.10

Operations of Fixed Point Types . . . . . ... ... . ... .....

3-38

Enumeration Types

3.5.2

.. ...

e e

3-13

. ... . ... ... . ...

3.5.1

e e

3-20

.. ... .....

3-22

e e

3-25

3.6

3.7

3.8

3.9

Chapter 4
4.1

4.2
4.3

4.4

4.5

4.6

Array TYPeS . . . .

3—-40

3.6.1

Index Constraints and Discrete Ranges . . . . ............

e e

342

3.6.2

Operations of Array Types . . . . . . . . .. .

i it

3—44

3.6.3

The Type String . . . . . . ...

3-46

Record Types . . . . ... . .

3—47

3.7.1

Discriminants.

3-49

3.7.2

Discriminant Constraints . .. .......................

3-51

3.7.3

Variant Parts . . . . .. ...

3-54

3.7.4

Operations of Record Types

. . . ....................

3-56

ACCESS TYPES

. .. ...

.. ... ..

3-57

3.8.1

Incomplete Type Declarations

. . . .

. .....................

3-58

3.8.2

Operations of Access Types

. . .. ... .ot
..

3-60

. . . . ...

3-61

Declarative Parts . . ... ..........

e e

Names and Expressions
NamesS . . . . . .

e e

e e e

4—1

e e

4-2

411

Indexed Components . . ............ e

4.1.2

SlCES

4-3

4.1.3

Selected Components . . . ...........
...
...

4-5

4.1.4

Attributes . .. .. .. . e
e

4-8

Literals . ... ... . . . e
e e

4-9

Aggregates

. . i

e e

. . ... ... ... .

4.3.1

Record Aggregates

4.3.2

Array Aggregates . . . . . . ..

EXPresSSiONS . . . . . ..

e e

. ......... ...

Operators and Expression Evaluation

it
e

e e e

4-10

4-11

4-12

4-15

. ......................

4-17

4.5.1

Logical Operators and Short-circuit Control Forms . . . ... ...

4-18

4.5.2

Relational Operators and Membership Tests . . .. ... ......

4-20

4.5.3

Binary Adding Operators . . . . ... ...................

4-22

4.5.4

Unary Adding Operators . ..............0

...

4-24

4.5.5

Multiplying Operators . . .. ..... ... ... .. . . .. . . ...

4-24

4.5.6

Highest Precedence Operators . . . . . .................

4-28

4.5.7

Accuracy of Operations with Real Operands . . . . ... ......

4-29

Type CoNVversions

. . ... ... ... ...ttt
ettt e

4-31

4.7

Qualified Expressions . . . . . ....... ... . ..

4-34

4.8

Allocators . .. ......... . . .
e
e

4-36

4.9

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

4-38

4.10

Universal Expressions . ...................
... ...

4-40

Chapter 5
5.1
5.2

Statements
Simple and Compound Statements—Sequences of Statements . . . ..
Assignment Statement . ........ ...
5.2.1

... . . . . . . . i

5-1

5-3

Array Assignments . . ... ... ... e

5-5

5.3

If Statements . . . ...

5-5

5.4

Case Statements ... ..........
... ... . . . . .

k5——6

5.5

Loop Statements ... ..........
... . ... ...

5-9

5.6

Block Statements . . . ... ...... ... ...

5-11

5.7

Exit Statements . .. .......... ... .. . ... . .

5-12

5.8

Return Statements . .. ... ...... ... ... .. ... . . . . . . ...

5-13

5.9

Goto Statements

.. ..........
... ... .. . ..,

5-14

6.1

Subprogram Declarations . .. .................
... ... .. ....

6-1

6.2

Formal Parameter Modes

6-3

6.3

Subprogram Bodies . ... ....... ... .. ...

Chapter 6

6.4

... .. . . ..

... .. . ...

Subprograms

......................
.. ...c.o...

6-5

6.3.1

Conformance Rules . ...............
.. iii.....

6—7

6.3.2

Inline Expansion of Subprograms . . ..................

6-8

Subprogram Calls

. ...............
. . .. .
.

6.4.1

Parameter Associations.

6.4.2

Default Parameters

6-9

. .. .......................

6-11

.. ... .........
... ... ... .....

6—-12

6.5

Function Subprograms . . . ... .. ........ ... .. . .. . . . ...,

6-13

6.6

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

6-14

6.7

Overloadingof Operators .. ........
... ...
......
... .......

6-15

Chapter 7

Packages

7.1

Package Structure . . ... ......
.. . . . .......
...

7-1

7.2

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

7-3

7.3

Package Bodies . . . .......
... ..,
......

7-4

Private Type and Deferred Constant Declarations . . .............

7-6

7.4.1

Private Types

7-7

... ...

7.4.2

Operations of

7.4.3

Deferred Constants

744

Limited Types ... ...

aPrivate Type . . ... ..................

. ..........
...
......
... .....

7-8

7-11

. i

7-12

7.5

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

7-14

7.6

Example of a Text HandlingPackage . . . .....................

7-16

Chapter 8

‘ Visibility Rules

8.1

Declarative Region . . . . .. ... .. ... ... ... ... .. . ...

8.2

Scope of Declarations

8.3

Visibility

8.4

UseClauses

.....
... ........
. . ...
..

8-8

8.5

Renaming Declarations . . ... ..........
.......
............

8-11

8.6

The Package Standard . . . ..............
... .............

8-14

8.7

The Context of Overload Resolution

8-15

. ...... ..

...

8—1

. ................
... ... .. . .. ....
..

8-3

8—4

. .......................

Vii

Chapter 9

9.1

Task Specificationsand Task Bodies . . . . .. ..................

9-2

9.2

Task Types and Task Objects .. ... ..........
.. ... ... ... ...

9-5

9.3

Task Execution—Task Activation . . . . . ... ...................

9-6

9.4

Task Dependence—Terminationof Tasks ... ..................

9-8

9.5

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

9—11

9.6

Delay Statements, Duration,and Time .. ... ..................

9-14

9.7

Select Statements . ... ...... ... ... . . . ...
e
9.7.1
Selective Waits . . ... ..... ... i,
9.7.2
Conditional Entry Calls . ... ........
... .. ...
9.7.3
TmedEntryCalls .........
... ... .
...

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

9.8

Priorities . ... ... . ... .
e

9-22

9.8a

Time Slicing . . ....... . e

9-23

9.9

Task and Entry Attributes . . . . .. ... ...

9-24

9.10

Abort Statements . . . ... ... .

9-25

9.11

Shared Variables . ... ..... ... . .. . ...

9-27

9.12

Example of Tasking . . ... ..... ...

. iy

9-30

9.12a

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

9-32

Chapter 10
10.1

10.2

10.3

viii

Tasks

... .

Program Structure and Compilation Issues
Compilation Units—Library Units . . . . . . ... ..................

10-1

10.1.1

Context Clauses—With Clauses . . . ... ...............

10-4

10.1.2

Examples of Compilation Units . . .. . .................

10-6

Subunits of Compilation Units . . . . ... ......................

10-8

10.2.1

oo,

10-9

...

10-12

Examples of Subunits . . . ... .. ...

Order of Compilation . ... ....... ... ... .. .. ..

10.4

The Program Library

10.5

Elaboration of Library Units

10.6

Chapter 11

. .. ... ...... ... ... . . . .. ... ..

...

10-15

. ... ..........................

10-15

Program Optimization . . . ... ...... ... ... ... ... ... .. ... .....

10~-16

Exceptions

11.1

Exception Declarations . . . .. .........
... . ... .. . . . . . . .. ....

111

11.2

Exception Handlers

. .. ............
. . . . . . . . ... ...

11-5

11.3

Raise Statements . . . . .... ... ... ... ... ... . .. ... .. ...

11-6

11.4

Exception Handling

11-7

. ..............
... . ... . . . ... ... . ...,

11.4.1

Exceptions Raised During the Execution of Statements

. . ...

11.4.2

Exceptions Raised During the Elaboration of Declarations . .

11-7

11—10

11.5

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

11-12

11.6

Exceptions and Optimization.

11—-13

11.7

Suppressing Checks.

Chapter 12
12.1

. . ... ........................

. . ......... ...

... . . . . ...

11-15

Generic Units
Generic Declarations

12.1.1

. .......
... ...
.......
. ... . ... ... ....

Generic Formal Objects

... .......................

12.1.2

Generic Formal Types

12.1.3

Generic Formal Subprograms

.. ........

12—1

12—4

12-5

. .....................

127

121a

PragmaINLINE_ GENERIC . . .. ... ...... ... ... ... ... .. .....

12-8

12.1b

Pragma SHARE_GENERIC.

12.2

Generic Bodies

12.3

Generic Instantiation

. . ... .......
... .. .. .....
... ....

12-10

. ......
... .. .. ......
.. ...,

12—11

. .. ......... .. ...

.. .. .. ... ... . ....

12-12

12.3.1

Matching Rules for Formal Objects . ... ...............

12-16

12.3.2

Matching Rules for Formal Private Types . . ... ..........

12—16

12.3.3

Matching Rules for Formal Scalar Types . ..............

12-17

12.3.4

Matching Rules for Formal Array Types . . . . .. ..........

12-18

12.4

Chapter 13

12.3.5

Matching Rules for Formal Access Types.

.. ............

12-19

12.3.6

Matching Rules for Formal Subprograms . ..............

12-20

Example ofaGenericPackage .................
... ... .. ...

12-21

Representation Clauses and Implementation-Dependent
Features

13.1

Representation Clauses .. ... ... . ... .. . .. .. ..

13-1

13.2

Length Clauses . .. ... ... ... . .. . ...ttt

134

13.2a

Pragma TASK STORAGE

... ... ... ... ... iy

13-8

13.2b

Pragma MAIN_STORAGE

. ... ..... ... ... ... ... .

13-9

13.3

Enumeration RepresentationClauses . . . . . ... ... .............

13—10

134

Record RepresentationClauses . . . .. ...............
... .....

13—11

13.5

Address Clauses .. ... ... ... .. ittt

13-16

13.5.1

1318

....

13-19

Interrupts ... ...

13.6

Change of Representation.

13.7

The Package System

13.7a

13.8

. .. ... ....... ...

.. ... ...

. ... ........ .. it

13-20

13.7.1

System-Dependent Named Numbers . . . . . ... ... .......

13-22

13.7.2

Representation Attributes

13-23

13.7.3

Representation Attributes of Real Types

... ..............
... ....

VAX Ada Additions to the Package System

. ..............

13-27

...................

13-29

13.7a.1

Properties of the Type ADDRESS . . ... ...............

13-30

13.7a.2

Enumeration Type for Identifying Type Classes . . . .. ... ...

13-31

13.7a.3

Floating Point Type Declarations

13-32

13.7a.4

Asynchronous-System-Trap-Related Declarations

13.7a.5

Non-Ada Exception

.. .... ... ... . ...

13-34

13.7a.6

VAX Hardware-Oriented Types and Functions . . .. ... .. ...

13-35

13-37

. ...................

.........

13-32

13.7a.7

Conventional Names for Unsigned Longwords

. ..........

13.7a.8

Global Symbol Values . . . . .. ... ... ..

13-38

13.7a.9

VAX Processor and Device Register Operations . ... ......

13-38

13.7a.10

VAX Interlocked-Instruction Procedures . .. ... ..........

13—-39

Machine Code Insertions

. . ... ....... ... .. ... .. ... . ... ...

13—41

13.9

Interface to Other Languages ..................
... ......

13.9a

VAX Ada import and Export Pragmas
13.9a.1

.......................

13-46

Importing and Exporting Subprograms . . . ..............

13-48

13.9a.1.1
13.9a.1.2

1348

Importing Subprograms . . . ... .............
Controlling the Passing Mechanisms for Parameters

and Function Results . . .. ................
13.9a.1.3

. ........
... ... .
..

13-56

Exporting Subprograms . . . ... .............

13-58

Importing and Exporting Objects . . . .. ................

13-61

13.9a.2.1

ImportingObjects.

. . .. .........
... . ...

13-62

13.9a.2.2

ExportingObjects.

... ...................

13-63

13.9a.2.3

Importing and Exporting Objects with the Pragma
PSECT OBJECT .. ... ... ... .

13.9a.3

13-53

Atiribute for Optional Parameters in Imported VMS
Routines.

13.9a.1.4
13.9a.2

13-43

Importing and Exporting Exceptions

...

13-64

. .................

13-65

13.9a.3.1

Importing Exceptions

.. . .................

13-66

13.9a.3.2

Exporting Exceptions

.. .. ... ... ... ......

13-67

Unchecked Programming . .........
... ..ttt

13-68

13.10.1

Unchecked Storage Deallocation

....................

13-68

13.10.2

Unchecked Type Conversions

. .......... ...

13—69

14.1

External Filesand FileObjects ............................

14-2

14.1a

Elementsand Records ..............
... ... ... .. ... .. . ...

14-6

14.1b

Specification of the FORM Parameterin VAXAda.

. .............

14-7

14.2

Sequential and Direct Files . . . ... ... ...

. ... ... .. .. ........

14-8

13.10

Chapter 14

14.2a

Input-Output

14.2.1

File Management . . .. .......... ...t

nnnnn.

14.2.2

Sequential Input-Output.

14-9

. ... ......................

1412

14.2.3

Specification of the Package Sequential_IO .............

14-13

14.2.4

DirectInput-Output . . . ... ...... ...

14—-14

14.2.5

Specification of the Package Direct
10 ................

14-16

Relative and Indexed Files

. ... .. ... ... .. .... .. .. .. .. . . ....

14-17

14.2a.1

File Management . . . . .........
.. .. ... . . . . ... ...

14-20

14.2a.2

Relative Input-Output . ... ...

... . ....

14-21

14.2a.3

Specification of the Package Relative_
IO ...............

14-23

14.2a.4

Indexed Input-Output

e e e e

14-25

14.2a.5

Specification of the Package Indexed_IO .. . ............

14-28

. ... ... ...

. .............. e

14.2b

Mixed-Type Input-Output . . . . . ... ...
14.2b.1

14.3

...

14--30

14-30

14.2b.2

ltem Input-Output . . . ... .. ... .. . .

14.2b.3

Sequential Mixed Input-Output . . ....................

14-31
14-34

14.2b.4

Specification of the Package Sequential

14-35

Mixed 10

...
.. ...

14.2b.5

Direct Mixed Input-Output . ........................

14-36

14.2b.6

Specification of the Package Direct

...........

14-38

Mixed 10

14.2b.7

Relative Mixed Input-Output.

. ... ... ... ... ... .......

1440

14.2b.8

Specification of the Package Relative_Mixed
10 ... .... ...

14—43

14.2b.9

Indexed Mixed Input-Output . . . . ... .................

1445

14.2b.10

Specification of the Package Indexed Mixed 10 .. ..... ...

1448

Text Input-Output . . . ...

... ... ... ... . .

14-50

14.3.1

File Management . . ... ........0 0.

14-53

14.3.2

Default Input and Output Files . ... ..................

14-54

14.3.3

Specification of Line and Page Lengths . . . . . ...........

14-55

14.3.4

Operations on Columns, Lines,and Pages.

. ............

14-56

14.3.5

Getand PutProcedures . . ........................

14-60

14.3.6

Input-Output of Characters and Strings .. ..............

14-63

14.3.7

Input-Output for Integer Types . . .. .......
... ... .....

14-65

14.3.8

Input-Output for Real Types . . . . . .. . ... ...

...

14-67

14.3.9

Input-Output for Enumeration Types

... ...............

14-70

14.3.10

Specification of the Package Text
IO

.................

14-73

14.4

Exceptions inlnput-Output . . .. . ... ... ...

. ... . ... ... ..

14-78

14.5

Specification of the Package 10_Exceptions . . . ... .............

14-80

14.5a

Specification of the Package Aux 10Exceptions ...............

14-80

14.6

Low Level Input-Qutput

14-81

14.7

Exampleof Input-Output . . . . . ... ........ ...

... ... ... ....

14-82

14.7a

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

14-83

Annex A

Xii

... .. ... . ..

File Management . . ... ... ... ... . ... . . .

...............
... ... . ... .. ...

Predefined Language Attributes

Annex B

Predefined Language Pragmas

Annex C

Predefined Language Environment

Appendix D

Glossary

Appendix E

Syntax Summary

Appendix F

Impiementation-Dependent Characteristics

F.1

Implementation-Dependent Pragmas . .......................

F-1

F.2

Implementation-Dependent Attributes.

. . . .. ... ...............

F-2

F.3

Specification of the Package System . . . . .. ..................

F-3

F.4

Restrictions on RepresentationClauses . . . . . . . ...............

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

F-8

F.7

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

F-8

F.8

Implementation-Dependent Characteristics of Input-Output

PacKages . . . . .. .

F.9

e e

F-9

F.8.1

Additional VAX Ada Input-Output Packages .............

F-9

F.8.2

Auxiliary Input-Output Exceptions . .. .................

F-9

F.8.3

Interpretation of the FORM Parameter.

. ... ............

F-10

F.8.4

Implementation-Dependent Input-Output Error Conditions . . ..

F-10

Other Implementation Characteristics

... ....................

F-11

F.9.1

Definition of a Main Program . . . . .. .................

F-11

F.9.2

Values of Integer Attributes . .. . ...... ...

F-12

F.9.3

Values of Floating Point Attributes

F.9.4

Attributes of Type DURATION

... ... ...,

. . . ... ... .. ..... ...

F-12

. ... ... ...............

F-15

xiii

F.9.5

Appendix G

Xiv

Implementation Limits . . . .. ...........
... ... ...

Ada Language Interpretations

Preface

The entire text of the Reference Manual for the Ada Programming Language

(ANSI/MIL-STD-1815A-1983, 1S0/8652-1987) is reprinted in this manual.
In addition, this manual contains VAX Ada implementation information and
Digital-supplied supplementary examples and text.

VAX Ada information appears in chapters 1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 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 some familiarity 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 the visibility 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 SHARED and describes the VAX Ada pragmas TIME_

SLICE and VOLATILE, as well as the VAX Ada pragma and attribute

AST_ENTRY.

Chapter 10 explains the overall structure of programs and the 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 SUPPRESS and 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 Ada interpre-

tations of the pragma PACK, the attributes 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
ADDRESS and SIZE, and describes the VAX Ada representation attributes BIT and MACHINE_SIZE. Finally, chapter 13 presents the

VAX Ada interpretation of the pragma INTERFACE and describes 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 I0), it presents the VAX Ada input-output

packages (RELATIVE_IO, INDEXED_IO, SEQUENTIAL_MIXED_IO,
IO, INDEXED_MIXED_IO, and DIRECT_MIXED_
RELATIVE_MIXED
I0) and the VAX Ada package AUX_IO_EXCEPTIONS.

Annex A summarizes the language attributes.

Annex B summarizes all pragmas and defines the pragmas IDENT,

Annex C presents the specification of the package STANDARD.
Appendix D is a glossary of Ada terms. It is not part of the standard

Appendix E contains a syntax summary of the Ada language. It 1s not

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

LIST, OPTIMIZE, PAGE, and TITLE.

definition of the Ada language.

part of the standard definition of the Ada language.

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 how to compile, link, run,
and debug Ada programs. It also gives information on the VAX Ada program
library manager and its commands and suggests ways of structuring and
managing Ada program libraries.

The VAX Ada Run-Time Reference Manual gives system-related information.
It presents information on VAX Ada storage 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 instructions for installing
the VAX Ada compiler and the VAX Ada HELP file.

The VAX Ada and VAXELN Ada Technical Summary characterizes VAX
Ada and VAXELN Ada by answering a series of questions familiar to the

general Ada community and published as the Ada-Europe Guidelines for
Ada compiler specification and selection.

VMS Documentation

The Guide to Using VMS or VMS General User’s Manual gives information
useful to those who are new to the VMS operating system. These manuals discuss using the terminal, creating and handling files, 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 Ada insertions.

xviii

New and Changed Features
The following features have changed or have been added to VAX Ada since

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 determined by 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 subprograms is 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_
PROCEDURE that 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_ERROR be raised (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 added to the type

SYSTEM.NAME (see 13.7). Also, an enumeration representation clause
has been added for this type (see 13.7 and Appendix F).
Two conversion operations—TO_UNSIGNEDLONGWORD and
TO_ADDRESS—have been added to the package SYSTEM (see 13.7a.6).
A function—IMPORT_VALUE—for importing link-time global symbols
has been added to 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_PARAMETER option has been added to the
pragmas IMPORT_FUNCTION, IMPORT PROCEDURE, and IMPORT
_
VALUED_PROCEDURE (see 13.9a.1.1).

A RESULT_MECHANISM option 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-output files (see 14.2a).

Length clauses have been added for the types STANDARD.CHARACTER
and STANDARD.DURATION (see Annex C).

The maximum number of characters in an identifier and a source line
has been increased to 255 (see Appendix F).

Chapter

Introduction

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 requirements call for a language with
considerable expressive power covering a wide application domain. As a
result, the language includes facilities 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.
2

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.

1.1

Scope of the Standard
1

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

1-1

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

€y

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.

(8)

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

(k)

The form or contents of any listings produced by implementations; in

different language constructs.

particular, the form or contents of error or warning messages.
14

The effect of executing a program unit that contains any violation that

a conforming implementation is not required to detect.
15

(m)

The size of a program or program unit that will exceed the capacity of
a particular conforming implementation.

Where this 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:

The represented values of fixed or floating numeric quantities, and the
results of operations upon them.

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

Conformity of an Implementation With the Standard

1.1.2
1

A conforming implementation is one that:1

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

(¢)

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.

1.2

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

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 of a section.
3

Examples are meant to illustrate the possible forms of the constructs
described. Notes are meant to emphasize consequences of 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 another section.

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

Structure of the Standard

1.2

The standard definition of the Ada programming language consists 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:

1.3

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 whose title starts with the word “Example” or “Examples”

Design Goals and Sources
1

Ada was designed with three overriding concerns: program reliability and
maintenance, programming as a human activity, and efficiency.
The need for languages that promote reliability and simplify maintenance is

well established. Hence emphasis was placed on program readability over
ease of writing. For example, the rules of the language require that program

variables be explicitly declared and that their type be specified. Since

the type of a variable is invariant, compilers can ensure that operations

on variables are compatible with the properties intended for objects of
the type. Furthermore, error-prone notations have been avoided, and the
syntax of the language avoids the use of encoded forms in favor of more
English-like constructs. Finally, the language offers support for separate

compilation of program units in a way that facilitates program development
and maintenance, and which provides the same degree of checking between

units as within a unit.

Concern for the human programmer was also stressed during the design.
Above all, an attempt was made to 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 number of underlying concepts integrated

in a consistent and systematic way. Nevertheless we have tried to avoid
the pitfalls of excessive involution, and in the constant search for simpler

designs we have tried to provide language constructs that correspond
intuitively to what the users will normally expect.
Like many other human activities, the development of programs is becoming
ever more decentralized and distributed. Consequently, the ability to

assemble a program from independently produced software components
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.

1.3

Design Goals and Sources

No language can avoid the problem of efficiency. Languages that require
over-elaborate compilers, or that lead to the inefficient use of storage

or execution time, force these inefficiencies on all machines and on all
programs. Every construct of the language was examined in the light
of present implementation techniques. Any proposed construct whose
implementation was unclear or that required excessive machine resources
was rejected.

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

Another significant 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.
Many of 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.
3

An Ada program will normally make use of a library of program units
of general utility. The language provides means whereby individual
organizations can construct their own libraries. The text of a separately

compiled program unit must name the library units it requires.
4

Program Units

A subprogram is the basic unit for expressing an algorithm. There are

two kinds of subprograms: procedures and functions. A procedure is the
means of invoking a series of actions. For example, it may read data, update
variables, or produce some output. It may have parameters, to provide a
controlled means of passing information between the procedure and the
point of call.
6

A function is the means of invoking the computation of a value. It is similar

to a procedure, but in addition will return a result.
7

A package is 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.
8

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

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

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

1.4

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 another place).
13

An assignment statement changes the value of a variable. A procedure call

invokes execution of a procedure after associating any actual parameters
provided at the call with the corresponding formal parameters.
14

Case statements and if statements allow the selection of an enclosed sequence of statements based on the value of an expression or on the value of
a condition.

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

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 forms of the select statement allow conditional or timed
entry calls.
Execution of a program unit may encounter error situations in which normal
program execution cannot continue. For example, an arithmetic computation

may exceed the maximum allowed value of a number, or an attempt may

be made to access an array component by using an incorrect index value.
To deal with such error situations, the statements of a program unit can be
textually followed by exception handlers that specify the actions to be taken

when the error situation arises. Exceptions can be raised explicitly by a
raise statement.

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 CHARACTER are 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 the error, or floating point types, with

relative bounds on the error. The numeric types INTEGER, FLOAT, and
DURATION are 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
same or 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 made visible to the users of such types.

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 subranges of scalar types, arrays with a limited set of index values,
and records and private types with particular discriminant values.

1.4

Language Summary

1-8

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 components of a record are to be represented using a
given storage layout. Other features allow the controlled use of low level,
nonportable, or implementation-dependent aspects, including the direct
insertion of machine code.
30

Input-output is defined in the language by means of 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.
31

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 applied to all types of a given class.

1.4a

VAX Ada
All of the language elements specified by the ANSI or ISO standard

definition for the Ada language are provided by VAX Ada. In addition,
VAX Ada implements certain options and makes certain interpretations,
as permitted by the standard. Material has been inserted throughout this
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 means of a context-free

syntax together with context-dependent requirements expressed by narrative
rules.
The meaning of Ada program units is described by means of 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

of Backus-Naur-Form. In particular,
5

(a)

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

Whenever the name of 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

(c)

Square brackets enclose optional items. Thus the two following rules

(d)

return_ statement

return

statement

are equivalent.
return

[expression];

return;

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.

(e)

term

::=

factor

{multiplying operator

term

::=

factor

factor}

term multiplying operator

factor

A vertical bar separates alternative items unless it occurs immediately
after an opening brace, in which case it stands for itself:
letter_or_digit

::=

letter

component association

[choice

()

{]|

choice}

digit

::=

=>]

expression

If the name of any syntactic category starts with an italicized part,
it is equivalent to the category name without the italicized part. The

italicized part is intended to convey some semantic information. For
example {ype_name and Zask_name are both equivalent to name alone.

1.5

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
if statement

::=

if condition then
sequence
of statements

{elsif

condition then

sequence
of statements}

[else
sequence_
of statements]

end if;

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 recommended that all indentations
be by multiples of a basic step of indentation (the number of 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 recommended paragraphing.

1.6

Classification of Errors

The language definition 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 correspond to (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 error is not a legal Ada program; on the other
hand, the fact that a program is legal does not mean, per se, that the
program is free from other forms of error.
(b)

Errors that must be detected at run time by the execution of an Ada
program.

The corresponding error situations are associated with the names of

the predefined exceptions. Every Ada compiler is required to generate
code that raises the corresponding exception if such an error situation

arises during program execution. If 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

(¢)

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

(d)

Incorrect order dependences.

Whenever the 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

If a compiler 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_ERROR is raised if such a check fails.

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 of lexical 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
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 ISO seven-bit coded character set (ISO 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 ISO character set. The description of the

language definition in this standard reference manual uses the ASCII
graphical symbols, the ANSI graphical representation of the ISO character

set.1
graphic character
|

::= basic_graphic_ character

lower
case letter

basic graphic character
|

other special character

::=

upper
case letter

digit

special character

space_ character

basic character

::=

basic_graphic_character

format_ effector

1 See also Appendix G, AI-00339.

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)

uppercaseletters

ABCDEFGHIJKLMNOPQRSTUVW

XYZ

(b)

digits 0123456789

(c)

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

(d)

the space character

Format effectors are the ISO (and ASCII) 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 caselettersabcdefghijklmnopqrstuvwxyz

(f)

other special characters!

$%? @[\ ]~

~
{}

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

The ISO character that corresponds to the sharp graphical symbol in the
ASCIT 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 used in this section are as follows: ANSI
stands for American National Standards Institute, ASCII stands for

American Standard Code for Information Interchange, and ISO stands
for International Organization for Standardization.
The following names are used when referring to special characters and other
special characters:

2.1

symbol

name

symbol

name

quotation

greater than

sharp

underline

ampersand

vertical bar

apostrophe

Character Set

exclamation mark

2—2

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

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 numeric literal, a character literal, a string literal, or a comment.
The effect of a program depends only on the particular sequences of 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 character literal. 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. However if, 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 format effectors other than horizontal tabulation must cause at
least one end of line.

2—-3

Lexical Elements, Separators, and Delimiters

2.2

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

(RMS). Each RMS record 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 RMS contains a sequence of one or more format effectors other than
horizontal tabulation, the sequence is interpreted as the end of the line.
However, no characters, other than a space or a horizontal tabulation
character, are allowed in a record following a format effector sequence if the
sequence occurs in a comment.

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 numeric literal.
5

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

character set)

&' ()*+,—./: ;<=
6

or one of the following compound delimiters each composed of two adjacent

special characters
=>
7

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 forms of lexical element are described in other sections of

this chapter.
Notes:
9

Each lexical element must fit on one line, 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.
10

The following names are used when referring to compound delimiters:

delimiter

name

arrow

double dot

2.2

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

ldentifiers
1
2

Identifiers are used as names and also as reserved words.
identifier

letter

::=

{[underline]

or digit
letter
letter

letter or_digit}

::= letter

case letter
::= upper

digit
|

lower_ case_letter

All characters of an identifier are significant, including any underline
character inserted between a letter or digit and an adjacent letter 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

4
SNOBOL

PageCount

STORE _NEXT

Marion
ITEM

Note:

5
6

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
There are two classes of numeric literals: real literals and integer literals.

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

universal_real. Integer literals are the literals of the type universal_integer.
numeric_literal

::=

decimal literal

based literal

References: literal 4.2, universal_integer type 3.5.4, universal_real type 3.5.6

2.4.1

Decimal Literals
1

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

::=

integer

[.integer]

integer

::=

digit

{[underline]

exponent

::=

integer

[+]

[exponent]

digit}
-

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
decimal literal with the exponent. An exponent for an integer literal must

not have a minus sign.
Examples:
12

1E6

123

456

—-—

1integer

12.0

0.0

0.456

3.14159
26

real

1.34E-12

1.0E+6

real

literals

with

literals

exponent

Notes:

Leading zeros are allowed. No space is 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 integer literal.
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

2.4.1

Decimal Literals

2—6

2.4.2

Based Literals
1

A based literal is a numeric literal expressed in a form that specifies the
base explicitly. The base must be at least two and at most sixteen.
based literal

base
base

::=

# based integer

::=

[.based integer]

[exponent]

integer

based integer

::=
extended digit

extended digit

{[underline]

::= digit

extended digit}

letter

An underline character inserted between adjacent digits of a based literal
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 exponent indicates the power of the base by which the value of the based
literal without the exponent is to be multiplied to obtain the value of the

based literal with the exponent.2
Examples:
2#1111 11114

16#E#E1

164#F .FF#E+2

16#FF#

Ol6#0FF#

2#1110 0000#

2#1.1111 1111 111#E11

integer

-—

of value

-—

integer

-—

of value

literals
255

literals
224

real literals

-—

of wvalue

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

Based Literals

2.4.2

2.5

Character Literals
1

A character literal 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.
2

character literal

’graphic character’

Examples:
X

::=

r k7

rrzr

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

string_ literal

::=

"{graphic character}"

A string literal has a value that is a sequence of character values cor-

responding to the graphic characters of the string literal apart from the
quotation character itself. 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 the string literal.

(This means that a string literal that includes two adjacent quotation
characters is never interpreted as two adjacent string literals.)
4

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

IIA"

"Characters

2.6

String Literals

the

day:"

mmenan

such

-—

——

three

and

empty

}

string

string
are

literal

literals

allowed

length

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

PART

"sequence

CONTINUES

that

SEQUENCE
ON

THE

includes

the"

CHARACTERS

LINE"

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

Comments
1

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

the line. A comment can appear on any line 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 purpose is the enlightenment of the human reader.’
2

Examples:
——

the

end;

last

——

-—

two

sentence

processing

long

comment

or more

________________

above

may

LINE

split

consecutive
the

echoes

first

the

Algol

report

complete

onto

lines
two

hyphens

start

the

comment

Note:
3

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.4
This character set has 256 characters, each with a decimal equivalent
number in the range 0 to 255. The first 128 characters in the set correspond

to the characters in the ASCII 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
1

A pragma is 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

[ (argument association
{,

argument _association
|

argument association})];

::=

[argument identifier =>]

name

[argument identifier =>]

expression

Pragmas are only allowed at the following places in a program:

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

pau't.5

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.
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
1dentifiers are defined. A name given in an argument must be either a name

visible at the place of the pragma or 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 pragma that is not language-defined has no effect 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 what is 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 (RANGE

CHECK,

INDEX)
;

Note:
It is recommended (but not required) that implementations issue warnings
for pragmas that are not recognized and therefore ignored.
12

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, component 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

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

2.9

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

begin

entry

body

exception

exit

subtype

out
task

package

terminate

pragma

then

private

type

procedure

raise

use

range

mod

record

when

rem

while

with

new

renames

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
1

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.

2.10

Allowable Replacements of Characters

2-12

The quotation characters (") used as string brackets at both ends of 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 recommended that 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 recommended in this
case.

The rules given for identifiers and numeric literals are such that lower

case and upper case letters 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. Thus the string literal "AB$CD" could be
replaced by "AB" & ASCII.DOLLAR & "CD". Similarly, the string literal

"ABcd" with lower case letters could be replaced by "AB" & ASCII.LC_C &
ASCII.LC_D.

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 and the 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 named block 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.
basic_declaration

::=

object declaration

type declaration

number declaration
subtype declaration

subprogram declaration

package declaration

task_declaration

generic declaration

exception_declaration

generic_instantiation

renaming declaration

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 name of a block, the
name of 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 the visibility rules

(see 8.3). At such places the identifier is said to be a name of the entity (its
simple name); the name is said to denote the associated entity.
7

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 achieves its 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

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 whenever this change of 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).
10

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

Note:
11

The syntax rules use the term identifier for the first occurrence of an iden-

tifier in some form of declaration; the term simple name is used for any
occurrence of an identifier that already denotes some declared entity.
12

References: attribute 4.1.4, block name 5.6, block statement 5.6, character literal
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

3.1

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
An object is an entity that contains (has) a value of a given type. An object
is one of the following:

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

g 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,

a component or a slice of another object.

A number declaration is a special form of object declaration that associates

an identifier with a value of type universal_integer or universal_real.l
object declaration ::=
identifier list :

[constant]
[:=

identifier list

[constant]
[:=

number declaration

::=

constrained
array definition

expression];

::=

identifier list
identifier list

subtype indication

expression];

constant

universal static_expression;

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 number of single object
declarations. For each identifier of the list, the equivalent sequence has a
single object declaration formed by this identifier, followed by a colon and by
whatever appears at the right of the colon in the multiple object declaration;
the equivalent sequence is in the same order as the identifier list.

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

Example:
——

the

JOHN,

multiple

PAUL

-—

——

1in the

object

PERSON

equivalent

declaration

NAME

the

two

new PERSON(SEX

single

object

M);

see

3.8.1

declarations

order given

JOHN

PERSON

NAME

new

PERSON (SEX

M);

PAUL

PERSON

NAME

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
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 compound delimiter 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 subcomponent or slice of a
constant is a constant.

3.2.1

Object Declarations

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
constant is 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 subcomponent of 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

(b)

If the 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 subcompo-

elaborated. This establishes the subtype of the object.

nents are evaluated.

(¢)

The object is created.

(d)

Any initial value (whether explicit or 1mp1101t)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:
10

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

e
o

If the type of an object is a task type, the implicit initial (and only) value

designates a corresponding task.

If the 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 evaluation of this expression, unless the component is a discriminant of a
constrained object (the previous case).

In the case of a component that is 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 same rules as for a declared object.

3-5

Object Declarations

3.2.1

The steps (a) to (d) are performed in 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 name of the discriminant. Apart from the previous rule, the evaluation
of default expressions is performed in some order that 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_ERROR is raised if this check fails.2

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 erroneous if it attempts to evaluate a scalar variable with
an undefined value. Similarly, the execution of a program is erroneous if

it attempts to apply a predefined operator to a variable that has a scalar

subcomponent with an undefined value.3

Examples of variable declarations:
COUNT,

SUM

INTEGER;

SIZE

INTEGER

range

SORTED

BOOLEAN

FALSE;

COLOR TABLE

array(l

OPTION

BITVECTOR(1

of
..

000

COLOR;
10)

(others

TRUE);

Examples of constant declarations:
LIMIT

constant

INTEGER

LOW_LIMIT

constant

INTEGER

LIMIT/10;

TOLERANCE

constant

REAL

DISPERSION(1.15);

000;

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_LIMIT are initialized
with static expressions, but TOLERANCE is not if DISPERSION is 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 number declaration 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 universal_integer or the type universal_real. The
constant declared by a number declaration 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 number is
also of this type. Similarly, if every primary is of the type universal_real,
then the named number is also of this type.
Examples of nhumber declarations:
PI
TWO_PI
MAX

:
:
:

constant
constant
constant

:= 3.14159 26536;
:= 2.0*PI;
:= 500;

-- a real number
-— a real number
—-— an integer number

POWER 16
ONE, UN, EINS

:
:

constant
constant

:= 2**16;
:= 1;

-— the integer 65_536
—— 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-7

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 components called 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 discriminants if

any, and by the corresponding set of operations.
4

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 type if it belongs

to the type and satisfies the constraint; the given type is called the base
type of the subtype. A type is a subtype of itself; such a subtype is said to
be unconstrained: it corresponds to a condition that imposes no restriction.
The base type of a type is the type itself.

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 some or all 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

The term subcomponent is used in this manual in place of the term

component to indicate either a component, or a component of another
component or subcomponent. Where other subcomponents are excluded, the
term component is used instead.

3.3

Types and Subtypes

3-8

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

The name of a 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.
type declaration ::=
full _type_declaration
| incomplete
type declaration | private
type declaration
full

type declaration

type

identifier

::=

[discriminant part]

is type definition;

type definition

::=
enumeration
type definition

integer
type definition

real type definition

array type definition

record
type definition

access_type definition

derived
type definition

The elaboration of a full type declaration consists of the elaboration of the
discriminant part, 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).

3-9

Type Declarations

3.3.1

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

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 type is said to be anonymous if it has no simple
name. For explanatory purposes, this reference manual sometimes refers
to an anonymous type by a pseudo-name, written in italics, and uses such

pseudo-names at places where the syntax normally requires an identifier.
6

Examples of type definitions:
(WHITE,

RED,

range

YELLOW,

array(l

10)

GREEN,

BLUE,

BROWN,

BLACK)

INTEGER

Examples of type declarations:
type

COLOR

(WHITE,

RED,

type

COLUMN

range

72;

YELLOW,

type

TABLE

array(l

10)

GREEN,

BLUE,

BROWN,

BLACK);

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.

array(l

10)

BOOLEAN;

array(l

10)

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,

array(l

10)

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

3.3.1

Type Declarations

3-10

3.3.2

Subtype Declarations
1

A subtype declaration declares a subtype.
subtype declaration

subtype

::=

identifier

subtype indication;

subtype indication

::=

type mark

type

name

mark

::=

constraint

type

[constraint]

subtype name

::=

range constraint

floating
point constraint

fixed point constraint

index constraint

discriminant constraint

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 mark is, 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 constraint is first elaborated.

(b)

A check is then made that 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_ERROR is raised 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

COLOR range RED

subtype

RAINBOW;
INTEGER;

RED

BLUE

BLUE;

subtype

INT

subtype

SMALL INT

INTEGER range -10

subtype

COLUMN

subtype

SQUARE

MATRIX(1

PERSON(SEX

subtype MALE

range
..

10,

see

3.3.1

see

3.3.1

see

3.6

-—-

see

3.8

10;
10);

=> M);

Note:
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 constraint 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 tgpe; such subprograms are

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 subprograms occur last.
A basic operation is an operation that is inherent in one of the following:

An assignment (in assignment statements and initializations), an
allocator, a membership test, or a short-circuit control form.

A selected component, an indexed component, or a 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.
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:

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. Assignment is 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.
11

3.4

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, numeric literal
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

Derived Types
1

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

::= new subtype indication

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 bound is 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 same class 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.
5

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

For each enumeration literal or predefined operator of the parent type

there is a corresponding operation for the derived type.
7

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

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 same collection; there is a null access value for the derived
type and it 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.6

Certain subprograms that are operations of the parent type are said to
be derivable. For each derivable subprogram of the parent type, there
1s a corresponding derived subprogram for the derived type. Two kinds

of derivable subprograms exist. 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 type is 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 the visible part of a package and the derived
subprogram is hidden by a derivable subprogram of the 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
subprograms occur last.
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 re-

placed 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
1s made to be the operand of a type conversion that yields a result of the
derived type.
14

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 happens after 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

1s converted to the derived type.
15

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 indication is

first elaborated, the derived type is then created, and finally, the derived

subtype is created.
17

Examples:
type

LOCAL

COORDINATE

is new COORDINATE;

type MIDWEEK

new DAY

type

new POSITIVE;

COUNTER

range

TUE

THU;

two

different

see

3.5.1

——
—-—

type

SPECIAL KEY

——

the

derived

—-—

procedure

-—

function

new KEYMANAGER.KEY;

subprograms

GET KEY (K
"<"(X,Y

have

out

the

same

range

types

POSITIVE

following

see

7.4.2

specifications:

SPECIAL KEY);

SPECIAL KEY)

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

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

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

range

::=

range

range attribute

simple expression

simple_expression

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 bound of 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 < L is 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 same as 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 same type as T.

T’ LAST

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

3-17

Scalar Types

3.5

Note:

10
11

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.
enumeration
type definition

::=

(enumeration
literal specification
{,

enumeration
literal specification})

enumeration
literal specification
enumeration literal

::=

identifier

enumeration literal
character literal

The identifiers and character literals listed by an enumeration type definition must be distinct. Each enumeration literal specification is the
declaration of the corresponding enumeration literal: this declaration is

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 enumeration literal

specification.?

Each enumeration literal yields a different enumeration value. The pre-

defined order relations between enumeration values follow the order of
corresponding position numbers. The position number of the value of the
first listed enumeration literal is zero; the position number for each other
enumeration literal is one more than for its predecessor in the list.

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

9 See also Appendix G, AI-00330 and AI-00430.

3.5.1

Enumeration Types

3-18

Examples:
type

DAY

(MON,

type

SUIT

(CLUBS,

TUE,

type

GENDER is

(M,

type

LEVEL

(LOW,

type

COLOR

(WHITE,

type

LIGHT

(RED,

WED,

THU,

DIAMONDS,

SAT,

SUN);

SPADES);

F);
MEDIUM,

URGENT);

RED,

YELLOW,

GREEN,

BLUE,

AMBER,

GREEN);

—--

RED

and GREEN

—-—

overloaded

type

HEXA

(’A’,

'B’,

'C’,

'D’',

type

MIXED

4is

(’A’,

'B’,

’'*’,

subtype WEEKDAY

DAY

range MON

subtype MAJOR

SUIT

range

subtype

COLOR range RED

RAINBOW

FRI,

HEARTS,

'E’,

NONE,

HEARTS
..

BROWN,

BLACK);

are

'F');
’?',

'%');

FRI;
..

SPADES;

BLUE;

the

color

not

the

RED,

light

Note:
7

If an enumeration literal occurs in a context that does not otherwise suffice

to determine the type of the literal, then qualification by the name of the
enumeration type is one way to resolve the ambiguity (see 8.7).
8

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 number 3.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 enu-

meration literals is a character literal. The predefined type CHARACTER is
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 character literal.

Example:
type

ROMAN DIGIT

(’I’,

'V’,

'X',

'L’,

’C’,

'D’',

'M');

Notes:
3

The predefined package ASCII includes the declaration of constants denoting
control characters and of constants denoting graphic characters that are not
in the basic character set.

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
1

There is a predefined enumeration type named BOOLEAN. It contains the
two literals FALSE and TRUE ordered with the relation FALSE < TRUE. A

boolean type is either the type BOOLEAN or a type that 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.
integer
type definition

::=

range constraint

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 same integer type. (Negative bounds are

allowed.)10

A type declaration of the form:!!
type

range

is, by definition, equivalent to the following declarations:
type

integer type

subtype T
range

is new predefined integer type;

integer type

integer type(L)

iInteger type(R);

where integer_type is an anonymous type, 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 universal_

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 type itself.
VAX Ada provides the following predefined integer types:
Predefined type

Range of values

INTEGER

231 2311

SHORT_INTEGER

—215,.21°1

(or -2,147,483,648..2,147,483,647)

(or —32768..32767)

SHORT _SHORT _INTEGER

-27.271
(or -128..127)

Integer literals are the literals of an anonymous predefined integer type that
is called universal_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 number of an integer value is the corresponding value of the
type universal_integer.
10

The same arithmetic operators are predefined for all integer types (see 4.3).
The exception NUMERIC_ERROR is 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_ERROR if the operation is part of a larger expression

whose result can be computed correctly, as described in section 11.6.12
Examples:
type

PAGE

type

LINE SIZE

NUM

is range

2_000;

MAX LINE_ STIZE;

range

subtype

SMALL INT

subtype

COLUMN PTR

is LINE_SIZE

range 1

10;

range

MAX;

subtype BUFFER SIZE

INTEGER
INTEGER

range -10
0

10;

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

Integer Types

3.5.4

Notes:
12

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

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

References: anonymous type 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

3.5.5

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 universal_integer to the type.
2

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 terms of the base type of 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 as follows:
4

T WIDTH

Yields the maximum image length over all 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 value of this attribute is of the type

universal_integer.

3.5.5

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 number of 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
number is the universal_integer value corresponding to X.
The exception CONSTRAINT _ERROR is raised 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 number is
one greater than that of X. The exception CONSTRAINT_
ERROR is raised if X equals T’ BASE’ LAST.

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 number is 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 bound of the image is one.13

The image of an enumeration value is either the corresponding identifier in upper case or the corresponding
character literal (including the two apostrophes); neither leading nor trailing spaces are included. 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 char-

acter, is implementation-defined; the only requirement is that the image must be such that C equals

CHARACTER' VALUE(CHARACTER' IMAGE(C)).14
In VAX Ada, the image of a character C that is not a
graphic character is defined as a string of two or three

upper case letters, without enclosing quotation marks
or apostrophes. The upper case letters used are those

shown in italics as the literals of the predefined type

CHARACTER in Annex C (package STANDARD).
12

T'VALUE

This attribute is a function. The parameter X must be a

value of the predefined type STRING. The result type is

the base type of T. Any leading and any trailing spaces
of the sequence of characters that corresponds to the
parameter are ignored.
13

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_ERROR is raised.
14

In addition, the attributes A’ SIZE and A’ ADDRESS are defined for an

object A of a discrete type (see 13.7.2).
15

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:

For a subtype of a discrete type, the results delivered by the attributes

SUCC, PRED, VAL, and VALUE need 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(X)

T/ POS (T’ PRED (X))

T'’POS(X)

T’ VAL (T’ POS (X))

T’P
(T’ VAL
OS
(N) )

183

X
N

Examples:
-—-

For the types

-—

1in section

and subtypes

3.5.1

declared

we have:

—-—

COLOR'FIRST

——

RAINBOW'FIRST = RED,

= WHITE,

COLOR'’ LAST

= BLACK

——

COLOR’
SUCC (BLUE)

= RAINBOW’SUCC(BLUE)

-—

COLOR’POS (BLUE)

= RAINBOW/POS(BLUE)

——

COLOR'’VAL(O0)

= RAINBOW’
VAL (0)

= WHITE

RAINBOW’ LAST = BLUE

= BROWN

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 errors for floating point types, and with absolute bounds for fixed point
types.

real

type definition

::=

floating
point constraint

3—-25

fixedpoint_constraint

Real Types

3.5.6

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

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

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 numbers is 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 and is therefore independent of the implementation.
5

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
converts a untversal_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 universal_
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_ERROR if the operation is part of a larger expression

whose result can be computed correctly (see 11.6).1°
7

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

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

::=

floating accuracy definition
floating accuracy definition
digits

[range constraint]

::=

static simple expression

The minimum number of significant 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 remainder of 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 same real type.
For a given radix, the following canonical form is defined for any floating

point model number other 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 the first digit of its fractional
part is not a zero.

The specified number D is the minimum number of 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 number B 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 number B is the integer next above

(D*log(10)/1og(2)) + 1.)16
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 type is
defined in terms of the model numbers of the floating point constraint that
forms the corresponding real type definition (see 4.5.7).

The predefined floating point types include the type FLOAT. An implemen-

tation may also have predefined types such as

SHORT FLOAT and LONG_

FLOAT, which have (substantially) less and more accuracy, respectively,

than FLOAT. The base type 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 Ada floating 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_FLOAT is 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_FLOAT is 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

328

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

derived therefrom), a set of safe numbers is defined as follows. The safe
numbers have the same number B of mantissa digits as the model numbers 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 given

in section 4.5.7. The safe numbers of a subtype are those of its base type. 17

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): 18
type

T is

[range

R];

is, by definition, equivalent to the following declarations:
type

floating point type is new predefined floating point type;

subtype

[range

digits D

floating point type digits D

floating
point type(L)

floating
point 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 .. R is supplied, then both L. and R must belong to the range of safe

numbers. The floating point declaration is illegal if none of the predefined
floating point types satisfies these requirements, excepting universal_real.

The maximum number of 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 number characteristics 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.
13

The elaboration of a floating point type declaration consists of the elabora-

tion of the equivalent type and subtype declarations.

If a floating point constraint follows a type mark in a subtype indication, the
type mark must denote a floating point type or subtype. The floating 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 constraint is,
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.
16

The same arithmetic operators are predefined for all floating point types

(see 4.5).
Notes:
17

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 belongs to a floating point subtype need not be

a model number of the subtype.1?
18

Examples:
type

COEFFICIENT

is digits

type REAL

digits

type MASS

digits

subtype

SHORT COEFF

PROBABILITY

8;
7 range
is

range

0.0

COEFFICIENT

REAL

range

-1.0

1.0;

1.0E35;
digits

0.0

1.0;

-—

less

subtype

with

accuracy

subtype

with

-—

smaller

range

Notes on the examples:
19

The implemented accuracy for COEFFICIENT is that of a predefined type
having at least 10 digits of precision. Consequently the specification of 5

digits of precision for the subtype

SHORT COEFF is allowed. The largest

model number for the type MASS is approximately 1.27E30 and hence less

than the specified upper bound (1.0E35). Consequently the declaration of
this type is legal only if this upper bound is 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.72a

Pragma LONG_FLOAT
The pragma LONG_FLOAT is provided by VAX Ada to 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 pragma is as follows:
pragma

LONG FLOAT (D_FLOAT

G_FLOAT);

This pragma is only allowed at the start of a compilation, before the first
compilation unit (if any).

If D_FLOAT is specified, and the range is adequate, then a D_floating
representation is used for the predefined type LONG_FLOAT and for
floating point types declared with digits in the range 7..9. Similarly,
if G_FLOAT is specified, and the range is adequate, then a G_floating
representation is used for the predefined type LONG_FLOAT and for

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 ranges as follows:
Pragma argument

D_FLOAT

G_FLOAT

Digits specified

Representation

1..6

F _floating

7.9

D_floating

10..33

H_floating

1..6

F_floating

7..15

G_floating

16..33

H_floating

Use of the pragma LONG_FLOAT is interpreted as an implicit recompilation
of the predefined STANDARD environment. 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. Whenever a program library is reinitialized, the G_floating

representation is established by default.
Notes:

F_floating 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, ffloating representation 3.5.7, floating point

type declaration 3.5.7, g_float type 3.5.7, g_floating representation 3.5.7, h_float type
3.5.7, h_floating representation 3.5.7, long_float 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 universal_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 of T.

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:
T’ DIGITS

Yields the number of decimal digits in the decimal

mantissa of model numbers of the subtype T. (This
attribute yields the number D of section 3.5.7.) The value

of this attribute is of the type universal_integer.
T MANTISSA

Yields the number of binary digits in the binary mantissa

of model numbers of the subtype T. (This attribute yields
the number B of section 3.5.7.) The value of this attribute
is of the type universal_integer.
3.5.8

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 number above, 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 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 number of the subtype T.
The value of this attribute is of the type universal_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 number of the
base type of T. The value of this attribute is of the type
universal_real.
T SAFE_LARGE Yields the largest positive safe number of the base type of

T. The value of this attribute is of the type universal_real.
In addition, the attributes A’SIZE and A’ ADDRESS are 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 correspond to the attribute designators MACHINE_RADIX, MACHINE_MANTISSA, MACHINE_EMAX,
MACHINE_EMIN, MACHINE_ROUNDS, and MACHINE_OVERFLOWS
(see 13.7.3).

Appendix F gives values for all of the machine-dependent attributes for each

of the four VAX Ada floating point representations (F_floating, D_floating,
G_floating, and H_floating).
15

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, membership tests, qualification,

explicit conversion, and the attributes of the first group; the effects of these

operations are redefined in terms of the subtype.20
Notes:

The attributes EMAX, SMALL, LARGE, and EPSILON are provided for
convenience. They are all related to MANTISSA by the following formulas:

T/ EMAX

T’EPSILON

2.0**
(1 —

T/ SMALL

2.0*%* (-T'"EMAX

T’

2.0**T’EMAX

(1.0

LARGE

4*T’MANTISSA

T’'/MANTISSA)

2.0*%* (-T'MANTISSA))

The attribute MANTISSA, giving the number of binary digits in the man-

tissa, is itself related to DIGITS. The following relations hold between the
characteristics of the model numbers and those of the safe numbers:
T’BASE’'EMAX

T’SAFE EMAX

T’BASE’ SMALL

T’SAFE SMALL

T’BASE’ LARGE

T’SAFE LARGE

The attributes T’ FIRST and T’ LAST need not yield model or safe numbers.
If a certain number of digits is specified in the declaration of a type or

subtype T, the attribute T+ DIGITS yields this number.
20

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.3, 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 bound is specified as an absolute value,
called the delta of the fixed point type.
fixed point constraint

::=

fixed_accuracy definition
fixed accuracy_definition

::=

[range constraint]
delta

static simple

expression

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 same real 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 number is a multiple of a certain positive real
number called small, as follows:
sign

mantissa

small

For the model numbers defined 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 and all 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 bound of the specified range is
either a model number or 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 subtype indication), 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.2!
7

An implementation must have at least one anonymous predefined fixed
point type. The base type of each such fixed point type is the type itself.
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

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.03*2 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 changed by a representation clause

(see 13.1).

A fixed point type declaration of the form:*?
type T

delta D

range

is, by definition, equivalent to the following declarations:*>
type

fixed point type is

subtype
range

new predefined
fixed point type;

fixed point type

fixed point type(L)

fixed point

type(R);

In these declarations, fixed_point_type is an anonymous type, 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) *4

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

numbers of 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. The fixed 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.

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 of a fixed point
type belongs to a fixed Eoint subtype if and only if it belongs to the range

defined by the subtype. 6

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 anonymous predefined fixed 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:
16

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.

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

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

same range as VOLT

--—

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

—-—

DEL

the type

constant

FRACTION:

1.0/2*%* (WORD_LENGTH -

1);

type FRACTION is delta DEL range -1.0 .. 1.0 - DEL;28
19

References: anonymous type 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 types to the fixed 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 type of T.
The first 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 universal_real.

T'MANTISSA

Yields the number of binary digits in the mantissa of
model numbers of the subtype T. (This attribute yields the
number B 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
untversal_real.

T/ LARGE

Yields the largest positive model number of the subtype T.
The value of this attribute is of the type universal_real.

T'FORE

Yields the minimum number of 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.
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’DELTA 1is 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_SMALL Yields the smallest positive (nonzero) safe number of the
base type of T. The value of this attribute is of the type
universal_real.
12

T+ SAFE_LARGE Yields the largest positive safe number of the base type of
T The value of this attribute is of the type universal_real.
In addition, the attributes A’ SIZE and A’ ADDRESS are 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_
ROUNDS and 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.

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 subtype.3
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:
(2**T/MANTISSA -

T/ LARGE

LARGE

T/ BASE’ LARGE

T’ SAFE SMALL

T’ BASE'’ SMALL

T’ SAFE

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 name for a component of an array uses one or more
index values belonging to specified discrete types. The value of an array
object is a composite value consisting of the values of its components.
2

array type definition

::=

unconstraine
array definition
d
|

const
array
raine
definition
d

unconstraine
array definition
d

::=

array (index_subtype definition

{;,

index subtype definition})

component_subtype

constrained_array definition
array

index constraint

index subtype definition
index_constraint
discrete range

::=

indication

::=
component subtype indication

::= type mark range <>

(discrete_range

discrete range})

discrete subtype indication

range

An array object is characterized by the number of indices (the dimensionality of the array), the type and position of each index, the lower and
upper bounds for each index, and the type and possible 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.
5

An unconstrained array definition defines an array type. For each object
that has the array type, the number of indices, the type and position of
each index, and the subtype of the components are as in the type definition;

the values of the lower and upper bounds for each index belong to the

corresponding index subtype, 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.

3.6

Array Types

3-40

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

The array type is an implicitly declared anonymous type; this type is
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
name declared 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 some order that is not defined by the
language.
11

Examples of type declarations with unconstrained array definitions:
type VECTOR

is array (INTEGER

range <>)

type MATRIX

is array (INTEGER

range

type BIT VECTOR
type ROMAN

is array (INTEGER
range <>)
is array (POSITIVE range <>)

INTEGER range <>)

of REAL;

of BOOLEAN;
of ROMAN DIGIT;

Examples of type declarations with constrained array definitions:
type TABLE

is array(l ..
type SCHEDULE is array (DAY)
type LINE
is array(l ..

of REAL;

<>,

10) of INTEGER;
of BOOLEAN;
MAX LINE SIZE) of CHARACTER;

Examples of object declarations with constrained array definitions:
GRID

array(l

MIX

array(COLOR range RED

PAGE

array(l

80,
50)

100)
..

of LINE;

of BOOLEAN;
GREEN)
--

of BOOLEAN;

an array of

arrays

Note:

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

3—41

is array(POSITIVE

range MIN

MAX)

of COMPONENT;

Array Types

3.6

1s equivalent (in the absence of an incorrect order dependence) to the succes-

sion of declarations
subtype
type

subtype
16

index subtype

array

type

POSITIVE

range MIN

array(index subtype

range

MAX;

<>)

COMPONENT;

array type(index subtype);

where index_subtype and array_type are both anonymous. Consequently,
T is the name of a subtype and all objects declared with this type mark
are arrays that have the same bounds. Similar transformations apply to

multidimensional arrays.
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 same type.
References: anonymous type 3.3.1, bound of a range 3.5, component 3.3, constraint 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 INTEGER is assumed

if each bound is 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).31

If an index constraint follows a type mark in a subtype indication, 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 and the 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

342

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 constrained is a null array, having no components.

An array value satisfies an index constraint if at each index position the
array value and the index constraint have the same index bounds. (Note,
however, that assignment and certain other operations on arrays involve an
implicit subtype conversion.)32
5

The bounds of each array object are determined as follows:

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 requirement exists for the
subtype indication of a component declaration, if the type of the record
component is an array type; and for the component subtype indication of
an array type definition, if the type of the array components is 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 constant is
unconstrained; they are otherwise defined by this subtype (in the latter
case, the initial value is the result of an implicit subtype conversion).
The same rule applies to a generic formal parameter of mode in.

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 order that is not defined by the language.

Examples of array declarations including an index constraint:
BOARD

MATRIX(1

8);

RECTANGLE

MATRIX(1

20,

30);

INVERSE

MATRIX(1

N);

FILTER

BIT_VECTOR(O

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

——

have

the

same

type

SCHEDULE

bounds

Example of record type with a component that is an array:
type

VAR LINE (LENGTH

INTEGER)

record
IMAGE

STRING(1

LENGTH);

end record;
NULL_LINE

VAR~LINE(O);

——

NULL _LINE.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).
16

All components of an array have the same subtype. In particular, for an
array of components that are one-dimensional arrays, this means that all
components have the same bounds and hence the same length.

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 parameter 6.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
1

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

3.6.2

Operations of Array Types

344

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 universal_integer. The value of N must be positive
(nonzero) and no greater than the dimensionality of the array.
A’ FIRST

Yields the lower bound of the first index range. The
value of this attribute has the same type as this
lower bound.

A’ FIRST(N)

Yields the lower bound of the N-th index range. The

value of this attribute has the same type as this
lower bound.

A'LAST

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

A'LAST(N)

Yields the upper bound of the N-th index range. The
value of this attribute has the same type as this
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 number of values of the first index range

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

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

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 subtype T,

and the attributes A’ SIZE and A ADDRESS are defined for an array object
A (see 13.7.2).
12

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 include all 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)

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’

15
16

LENGTH

A’LAST

A'FIRST

A’ LENGTH(N)

A’'LAST(N)

A’FIRST(N)

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 STRING are one-dimensional arrays of the
predefined type CHARACTER, indexed by values of the predefined subtype

POSITIVE:
subtype
type

POSITIVE

STRING

INTEGER range

array (POSITIVE

range

..
<>)

INTEGER'’LAST;
of

CHARACTER;

In VAX Ada, the maximum number of 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

QUESTION

constant

STRING

——

QUESTION'FIRST

——

QUESTION’LAST

ASK

TWICE

NINETY SIX

(1L

120)
Il

120

"HOW MANY

"*7

);

CHARACTERS?";

(the

number

characters)

constant

STRING

QUESTION

constant

ROMAN

"XCV1I";

QUESTION;

-—

=see

3.6

Notes:
3

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

i1s 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 correspond to 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.7

Record Types
1

A record object is a composite object consisting of named components. The

value of a record object is a composite value consisting of the values of its
components.
2

record
type definition

::=

record

component list
end record
component list

::=

component declaration
|

{component

null;

declaration}

component declaration

identifier list

{component declaration}
variant part

::=

component subtype definition

[:= expression];
component _subtype definition

347

::=

subtype

indication

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 discriminant is not allowed within the record type definition

that declares the component.
4

A component declaration 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.
5

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

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 and all records of the type are null
records.
7

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

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

33 See also Appendix G, AI-00358.
3.7

Record Types

3-48

Examples of record type declarations:
type DATE

record

DAY

INTEGER range

MONTH

MONTH NAME;

YEAR

INTEGER range

31;

4000;

end record;

type COMPLEX is
record
RE

REAL

0.0;

REAL

0.0;

end record;

Examples of record variables:
TOMORROW,

YESTERDAY

COMPLEX;

— both components

are

DATE;

of A,

and C

implicitly initialized to

zero

Notes:
11

The default expression of a record component is 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 component of the object (since
the declaration is equivalent to a sequence of single component declarations).

Unlike the components of an array, the components of a record need not be
of the same type.

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, discriminant 3.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 component of the record. The type of a discriminant must be
discrete.
discriminant
part

::=

(discriminant specification
discriminant specification
identifier list

3—49

{;

discriminant specification})

::=

type mark

[:= 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.
4

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

The use of the name of a discriminant is not allowed in default expressions

of a discriminant part if the specification of the discriminant is itself given
in the discriminant part.
6

Within a record type definition the only allowed uses of the name of 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 appear by itself, not as
part of a larger expression. Such component subtype definitions and such
constraints are said to depend on a discriminant.
7

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

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 component that itself depends on a discriminant.

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

Direct assignment to a discriminant of an object is not allowed; furthermore

a discriminant is 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.
10

3.7.1

The elaboration of a discriminant part has no other effect.

Discriminants

3-50

Examples:
type BUFFER(SIZE

BUFFER SIZE

100)

-—

see

3.5.4

record

POS

BUFFER SIZE

VALUE

STRING(1l

SIZE);

end record;

type

SQUARE (SIDE

INTEGER)

1is

record

MAT
end

MATRIX(1

SIDE,

SIDE);

-—

see

3.6

record;

type DOUBLE_ SQUARE (NUMBER

INTEGER)

record
LEFT

SQUARE (NUMBER) ;

RIGHT

SQUARE (NUMBER) ;

end record;

type

ITEM(NUMBER

POSITIVE)

record

CONTENT

—-—

INTEGER;

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

Discriminant Constraints
1

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

discriminant constraint

::=

(discriminant associlation
discriminant association

discriminant association})

::=

[discriminant
simple name
{|]

3-51

discriminant
simple name} =>]

expression

Discriminant Consiraints

3.7.2

Each discriminant association associates an expression with one or more

discriminants. A discriminant association is said to be named if the discriminants are specified explicitly by their names; it is otherwise said to be

positional. For a positional association, the (single) discriminant is 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 occur first,
at their normal position. Hence once a named association is used, the rest of

the discriminant constraint must use only named associations.
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
name is only allowed if the named discriminants are 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.
5

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

nant value is substituted for the discriminant in this component subtype
specification and the compatibility of the resulting subtype indication is

checked3*
6

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

The initial values of the discriminants of an object of a type with discrimi-

nants are determined as follows:
8

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 arragf type, if the type of the array components is a type

with discriminants?

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

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

TFor 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 parameter is constrained if the corresponding actual parameter is constrained, and in any case if the mode is
in or if the subtype of the formal parameter is constrained.)

TFor 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 named association is evaluated once for
each named discriminant.
14

Examples using types declared in the previous section:
LARGE

: BUFFER(200);

MESSAGE

: BUFFER;

—constrained,

always 200 characters

-—

(explicit discriminant value)

-—

unconstrained,

-—-

characters

-—

value)

constrained,

BASIS

SQUARE (5);

——

ILLEGAL

SQUARE;

1llegal,

-—

constrained

initially 100

(default discriminant

always 5 by 5

a SQUARE must be

Note:

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.3, component declaration 3.7, component subtype
indication 3.7, composite value 3.3, constant 3.2.1, constrained subtype 3.3, con-

straint 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.3, generic formal parameter 12.1 12.3, mode in 6.1, mode in 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
1

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.

variant part
case

::=

discriminant simple name

variant
{variant}
end case;

variant

when

::=

choice

choice}

component list

choice
|

::=

simple expression

discrete

range

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
discriminant is static, then each value of this subtype must be represented

once and only once in 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 in the set of choices.
4

The simple expressions and discrete ranges given as choices in a variant
part must be static. A choice defined by a discrete range stands for all

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 name is not allowed as a choice of a variant (although it
1s part of the syntax of choice).

3.7.3

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 component list of the given variant.
If the component list of a variant is specified by null, the variant has no
components.

Example of record type with a variant part:
type DEVICE is
is
type STATE

(PRINTER, DISK,
(OPEN, CLOSED);

type PERIPHERAL (UNIT

DEVICE

DRUM);

:= DISK)

record
STATUS

STATE;

case UNIT is
=>

when PRINTER

INTEGER range 1

CYLINDER

CYLINDER INDEX;

TRACK

TRACK NUMBER;

LINE COUNT
when others

PAGE SIZE;

end case;

end record;

Examples of record subtypes:
subtype DRUM UNIT is PERIPHERAL (DRUM) ;
subtype DISK UNIT is PERIPHERAL (DISK);

Examples of constrained record variables:
WRITER

PERIPHERAL(UNIT => PRINTER);

see also examples

of KEYBOARD DRIVER;

declarations

single tasks

9.1

Example of access type designating task objects:
type KEYBOARD
TERMINAL

is access

KEYBOARD

KEYBOARD DRIVER;
new KEYBOARD

DRIVER;

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 assignment is
available. However the reserved word constant is 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).
9-5

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

References : access type 3.8, actual parameter 6.4.1, allocator 4.8, assignment 5.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.3, 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

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

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 subcomponent of an object declared
immediately within a declarative part or package specification. The first
statement following the declarative part is executed only after conclusion of

the activation of these task objects.
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 during its
activation, the exception TASKING_ERROR is 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

9.3

Task Execution—Task Activation

9-6

several of these tasks thus become completed during their activation, the

exception TASKING_ERROR is 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 and is
theregore 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 of the 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 during its activation, the exception
TASKING_ERROR is raised upon conclusion of the activation of all of these
tasks (whether successfully or not); the exception is raised at the place
where the allocator is evaluated. Should several of these tasks thus become
completed during their activation, the exception TASKING_ERROR is raised
only once.

Should an exception be raised by the initialization of the object created by
an allocator (hence before the start of any activation), any task designated
by a subcomponent of 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.

4 See also Appendix G, AI-00198.
9—7

Task Execution—Task Activation

9.3

Example:
procedure P
A,

RESOURCE;

elaborate

the

task

objects

RESOURCE;

elaborate

the

task

object

begin
-—

+the

——

before

tasks

the

first

are

activated

parallel

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

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 that is

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 master is 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)

Furthermore, if a task depends on a given master that is a block statement
executed by another master, then the task depends also on this other master,

The task designated by any other task object depends on the master
whose execution creates the task object.

in an indirect manner; the same holds if the given master is a subprogram

called by another master, and if the given master is a task that depends

(directly or indirectly) on another master. Dependences exist for objects of a
private type whose full declaration is in terms of 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 when it 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.%

If a task has no dependent task, 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.
Task Dependence—Termination of Tasks

9.4

Example:
declare
type

GLOBAL

RESOURCE;

GLOBAL;

access

RESOURCE;

see

9.1

begin
—-—

activation

of A and B

declare
type

LOCAL

access

GLOBAL

new

RESOURCE;

RESOURCE;
--

activation

X.all

LOCAL

new

RESOURCE;

activation

L.all

RESOURCE;

begin
—-—
G

end;
end;

activation
:=

—--

await

both

and

termination

designate

and
and

the

same

task

L.all

(but

not

obiject

X.all)

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

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 environment task 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 dependence is on the

master that elaborates the ultimate parent access type definition.
15

A renaming declaration defines a new name for an existing entity and hence

creates no further dependence.

9.4

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, statement 5,
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
Entry calls and accept statements are the primary means of 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.
entry declaration

::=

entry identifier
entry call statement
accept

statement

[(discrete range)]
::= entry name

[formal part];

[actual_parameter part];

::=

accept entry simple name

[(entry index)]

[formal part]

[do

sequence
of statements
end

[entry simple name]];

entry index

::= 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 name of 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 name has the form of a
selected component, whose prefix denotes the task object, and whose selector

is the simple name of one of its single entries or entry families.

9-11

Entries, Entry Calls, and Accept Statements

9.5

A single entry overloads a subprogram, an enumeration literal, 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
The parameter modes defined for parameters of the formal part of an entry
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).
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
statement must conform to the formal part given in the declaration of the

single entry or entry family named by the accept statement (see section 6.3.1
for the conformance rules). 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 consequence of 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.
10

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 manner as for a

subprogram call (see 6.4). Further execution of an accept statement and of a
corresponding entry call statement are synchronized.

If a given entry is called by only one task, there are two possibilities:
*

If the calling task issues an entry call statement before a corresponding
accept statement is reached by the task owning the entry, the execution

of the calling task is suspended.
e

If a task 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 an entry 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. The calls are processed in the order of arrival.
16

An attempt to call an entry of a task that has completed its execution
raises the exception TASKING_ERROR at the point of the call, in the
calling task; similarly, this exception is raised at the point of the call 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_ERROR is raised if the index of an entry of a family is not
within the specified discrete range.

Examples of entry declarations:
entry READ(V
entry

out

ITEM);

SEIZE;

entry REQUEST (LEVEL) (D
18

ITEM);

a family of entries

Examples of entry calls:
CONTROL.RELEASE;
PRODUCER_CONSUMER.WRITE(E);

-—

see

9.2 and 9.1

see

9.1

POOL (5) .READ (NEXT CHAR) ;

-—-

see

9.2

CONTROLLER.REQUEST (LOW) (SOME ITEM) ;

-—

see

9.1

and

9.1

Examples of accept statements:
accept

SEIZE;

READ(V

out

ITEM)

LOCAL ITEM;

end READ;

accept REQUEST (LOW) (D

ITEM)

end REQUEST;

9-13

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 subprograms that 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.
22

If the bounds of the discrete range of an entry family are integer literals, the
index (in an entry name or 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.3, subprogram declaration 6.1, task 9, task body 9.1, task specification 9.1,

tasking_error exception 11.1, timed entry call 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.?
delay statement

::=

delay

simple expression;

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, AT-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 (whenever possible, a
value not greater than fifty microseconds should be chosen). Note that
DURATION’ SMALL need not correspond to the basic clock cycle, the named

number SYSTEM.TICK (see 13.7). 0

In VAX Ada, DURATION' SMALL is 214 seconds, or approximately 61
microseconds. The value does not correspond to the value of the named

number SYSTEM.TICK, which is 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 TIME is provided in the predef ied library package
CALENDAR. The function CLOCK returns the current value of TIME at the
time it is called. The functions YEAR, MONTH, DAY and SECONDS return
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 the relational operators for

times, have the conventional meaning. 11

In VAX Ada, the type TIME is implemented as VMS binary time.

The exception TIME_ERROR is raised by the function TIME_OF if the
actual parameters do not form a proper date. This exception is also
raised by the operators “+” and “~” if, for the given operands, these operators

cannot return a date whose year number is 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
type

CALENDAR is
TIME

is private;

subtype

YEAR NUMBER

INTEGER

range

1901

subtype

MONTH

INTEGER

range

12;

subtype

DAY

NUMBER

INTEGER

range

subtype

DAY

DURATION

range

0.0

function

CLOCK

NUMBER

return

2099;

31;
..

86 400.0;

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 : TIME)

return MONTH NUMBER;

function DAY

(DATE

TIME)

return DAY NUMBER;

SECONDS (DATE

: TIME)

function
procedure

SPLIT

TIME)

"+"

return DAYDURATION;

TIME;

YEAR

out

YEAR NUMBER;

MONTH

out

MONTH

DAY

out

DAY~NUMBER;

SECONDS

out

DAY_DURATION);

NUMBER;

YEAR NUMBER;

MONTH

MONTH“NUMBER;

DAY

DAY NUMBER;

SECONDS

DAY

(LEFT

RIGHT

(LEFT

RIGHT

function

"-"

(LEFT

RIGHT

function

"-"

(LEFT

RIGHT

function

"<"

(LEFT,

RIGHT

function

"<="

(LEFT,

RIGHT

function

">"

(LEFT,

RIGHT

function

">="

(LEFT,

RIGHT

—-—

raised by

0.0)

return

TIME;

"+"

TIME ERROR

DURATION

DURATION)

function

can be

YEAR NUMBER;

(DATE

function TIME OF (YEAR

function

return

return TIME;

DURATION;
TIME)

return

TIME;

return

TIME;

return

DURATION;

TIME;
DURATION)

TIME;
TIME)

TIME)

return BOOLEAN;

TIME)

return BOOLEAN;

TIME)

return BOOLEAN;

TIME)

return BOOLEAN;

exception;

TIME OF,

"+",

and

"-"

private

-—

end; 13
8

implementation-dependent

Examples:
delay

3.0;

delay

3.0

seconds

declare
use

CALENDAR;

——

INTERVAL

TIME

is
TIME

global
:=

CLOCK

constant
+

type

DURATION

INTERVAL;

begin
loop

delay NEXT TIME
—-—

some

NEXT TIME

CLOCK;

actions
:=

TIME

INTERVAL;

end loop;

end;

13 See also Appendix G, AI-00355.
9.6

Delay Statements, Duration, and Time

9-16

Notes:

The second example causes the 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 number 3.2, system predefined package 13.7 13.7.1

9.7

Select Statements
1

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

select statement

1 9.7.1

::=

selective wait

conditional
entry call

timed entry_ call

References : selective wait 9.7.1, conditional entry call 9.7.2, timed entry call 9.7.3

Selective Waits
1

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

::=

select
select alternative
{or

select alternative}
[else

sequence_
of statements]

end select;

select alternative
[when

condition

::=
=>]

selective
wait alternative

selective
wait alternative
|

9—17

delay alternative

::= accept alternative

terminate alternative

Selective Waits

9.7.1

accept alternative

::=

accept statement

[sequence
of statements]

delay alternative

::=

delay statement

[sequence
of statements]

terminate alternative

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

A select alternative is said to be open if it does not start with when and a

condition, or if the condition is TRUE. It is said to be closed otherwise.
5

For the execution of a selective wait, any conditions specified after when
are evaluated in some order 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
6

Open accept alternatives are first considered. Selection of one such alternative takes place immediately if a corresponding rendezvous is 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.
9

The else part is selected and its statements are executed if no accept

alternative can be immediately selected, in particular, if all alternatives
are closed.

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

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

The exception PROGRAM_ERROR is raised if all alternatives are closed and

there is no else part.
12

Examples of a select statement:
select
accept

DRIVER AWAKE SIGNAL;

delay

30.0*SECONDS;

STOP_
THE TRAIN;

end select;

Example of a task body with a select statement:
task body RESOURCE
BUSY

BOOLEAN

is
:=

FALSE;

begin
loop

select
when

not

BUSY

accept
BUSY

SEIZE
:=

TRUE;

end;
or

RELEASE

BUSY

FALSE;

end;
or

terminate;
end

select;

end loop;

end RESOURCE;

Notes:
14

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.

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

9-19

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:.15
conditional
entry call

::=

select

entry call statement
[sequence_
of statements]

else
sequence_of statements

end select;

For the execution of a conditional entry call, the entry name is first evaluated. 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 the call (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 entry call 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_
ERROR if 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

RESOURCE)

begin

loop
select

R.SEIZE;
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

Timed Entry Calls

9.7.3
1

A timed entry call issues an entry call that is canceled if a rendezvous is not
started within a given delay.
timed entry call

::=

select
entry
call statement

[sequence
of statements]
or

delay alternative
end select;

For the execution of a timed entry call, the entry name is 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 delayis then
evaluated, and the entry callis 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 alternative is
executed.

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

CONTROLLER.REQUEST
(MEDIUM) (SOME ITEM) ;
or

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

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

9.8

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). 17 A lower value indicates a lower
degree of urgency; the range of priorities is im8p1ementation-defined. A

priority is associated with a task if a pragma 1
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 appears in 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 no effect if it occurs in a subprogram other than

the main program.
VAX Ada specifies the subtype PRIORITY to be of the type INTEGER with
a range of 0..15. A VAX Ada task whose priority has not been explicitly
specified has a default priority of 7.

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 tasks eligible for execution than can be supported simultaneously

by the available processing resources. The effect of priorities on scheduling
is defined by the following rule:
4

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 order is 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 rendezvous are 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 priority during a rendezvous is 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 suspended or until
a task of higher priority becomes eligible for execution. Tasks of the same
priority are executed in 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 causes the task scheduler to limit
the amount of continuous execution time given to a task when other tasks of
the same priority are also eligible for execution. The form of this pragma is
as follows:
pragma TIME SLICE

(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 disables it.
This pragma is only allowed in the outermost declarative part of a subprogram that is a library unit; at most one such pragma is allowed in a
subprogram. If it occurs in a subprogram other than the main program, this
pragma has no effect.

9-23

Time Slicing

9.8a

The following rules define the effect of enabling round-robin scheduling with
the pragma TIME_SLICE:

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 number of seconds (approximate elapsed
time) specified by the pragma. Then, if other tasks of the same priority
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 amount of scheduling overhead needed to support round-robin task

scheduling increases as the value of a time slice decreases. See the VAX Ada
Run-Time Reference Manual for the recommended minimum value.
The VAX Ada predefined package SYSTEM_RUNTIME_TUNING

also has

operations that enable time slicing. See the VAX Ada Run-Time Reference

Manual for 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
TRUE otherwise. The value of this attribute is of the

predefined type BOOLEAN.
3

T'TERMINATED

Yields the value TRUE if the task designated by T
1s terminated. Yields the value FALSE otherwise.

The value of this attribute is of the predefined type
BOOLEAN.
4

In addition, the representation attributes STORAGE_SIZE, SIZE, and

ADDRESS are defined for a task object T or a task type T (see 13.7.2).

9.9

Task and Entry Attributes

9-24

The attribute COUNT is 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 that is, itself, inner to the body of T.

E:COUNT

Yields the number of 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
allow for the increase of the value of this attribute for incoming entry calls,

and its decrease, for example with timed entry calls.

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

Abort Statements

9.10
1

An abort statement causes one or more tasks to become abnormal, thus
preventing any further rendezvous with such tasks.
abort statement

::= abort task name {,

task name};

The determination of the type of each task name uses the fact that the type

For the execution of an abort statement, the given task names are evaluated
in some order that is not defined by the language. Each named task then
becomes abnormal unless it is already terminated; similarly, any task that
depends on a named task becomes abnormal unless it is already terminated.

Any abnormal task whose execution is suspended at an accept statement,

of the name is a task type.

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

ERROR at the place of the call. Similarly, the exception TASKING _ERROR
is raised for any task that has called an entry of an abnormal task, if the
entry call is still queued or if the rendezvous is 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).

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,

including itself.

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

A synchronous implementation causes an abnormal task to become com-

pleted 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 means of ensuring the

completion of an abnormal task 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.
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 entry call 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 1s
synchronized with the task that causes this activation. A task that has
completed its execution is synchronized with any other task.

For the actions performed by a program that uses shared variables, the

following assumptions can always be made:

If between two synchronization points of a task, this task reads a shared
variable whose type is a scalar or access type, then the variable is not
updated by any other task at any time between these two points.

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 assumptions is
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 variable itself.

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 SHARED can be used to 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 pragma is as follows:23
pragma

SHARED (variable

simple name) ;

This pragma is allowed only for a variable declared by an object declaration

and whose type is 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 name of the variable, other than in an address clause.

An implementation must restrict the objects for which the pragma SHARED

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 SHARED for objects of floating point
types whose representation is not the same as the representation of the
type STANDARD.FLOAT (F_floating). Also, VAX Ada does not allow the

pragma SHARED for 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
VOLATILE to 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 pragma is as
follows:
pragma VOLATILE

(variable simple_name)

This pragma is 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 name of 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 must not 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:
CONSTANT FIVE
VOLATILE VAR,

DUMMY

pragma VOLATILE

constant

INTEGER;

INTEGER

(VOLATILE VAR);

begin

VOLATILE VAR

DUMMY

CONSTANT FIVE;

:= VOLATILE VAR;

statement

—-—

statement

end;

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 may be subject 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 VMS system service

operation (such as SYS$QIO) were to update the value of VOLATILE_VAR
between statements 1 and 2. Then, the pragma VOLATILE ensures 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 statement 1.

Suppose, instead, that another task or a VMS system service operation
were to read the value of VOLATILE_VAR sometime after statement 1, but

before statement 2. Then, the pragma VOLATILE ensures 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
VOLATILE is 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 address clause.

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

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

exit

when

the

CHAR =

character

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 1is
entry READ

out

CHARACTER);

entry WRITE(C

CHARACTER);

end;

task body BUFFER is
POOL SIZE

constant

POOL

array(l

INTEGER

COUNT

INTEGER range 0

ININDEX,

OUT INDEX

..
:

100;

POOL SIZE)

CHARACTER;

POOL SIZE

INTEGER range

:= 0;
POOL_SIZE

begin

loop

select
when

COUNT

POOL SIZE

accept WRITE(C

in CHARACTER)

POOL (IN_INDEX)

end;
IN

INDEX

COUNT

or when COUNT

ININDEX mod POOL SIZE

COUNT

accept READ
(C
C

out

CHARACTER)

POOL(OUT_INDEX);

end;

OUT INDEX

OUT INDEX mod POOL SIZE

COUNT

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 VMS operating

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

VMS system services that deliver ASTs can be called in VAX Ada with the
subprograms provided in the VAX Ada package STARLET. (The package

TASKING_SERVICES also provides subprograms for 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_ENTRY identifies 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_ENTRY attribute, and is allowed only in the
same task type specification (or single task) as the entry to which it applies.
The form of this pragma is as follows:
pragma

AST

ENTRY

(entry

simple

name);

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 may be given for any one entry.
When the 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 of a 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 name of a single entry of a task:
E’'AST_ENTRY

Yields a value of the predefined type ASTHANDLER
(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_
HANDLER and no AST occurs. If the entry is for a
task that is not callable (T CALLABLE is false), the
exception PROGRAM_ERROR is raised. If an AST
occurs for an entry of a task that is terminated, the
program is erroneous.

E'AST_ENTRY is 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 TEXT IO;

use

TEXT_IO;

with

use

STARLET;

with CONDITION HANDLING;
procedure

AST

EXAMPLE

use

CONDITION_ HANDLING;

RETURN STATUS:

COND VALUE TYPE;

CHANNEL TYPE;

CHANNEL:

FUNCTION

CODE:

FUNCTION

task AST HANDLER

entry RECEIVE AST
pragma AST
end AST

CODE_TYPE;

ENTRY

(ASTPRM:

INTEGER)
;

(RECEIVE AST);

HANDLER;

task body AST HANDLER

begin
loop
select

accept
if

RECEIVE AST(ASTPRM:
ASTPRM =

INTEGER)

then

PUT LINE ("Received the

expected AST

parameter");

end if;

end;
or

terminate;

end select;
end loop;

end

9-33

ASTHANDLER;

Task Entries and VMS Asynchronous System Traps

9.12a

begin
—-—

Code

-—

variables

—-—

Call

—-—

VAX

the
Ada

initialize

VMS

SYSS$SQIO

package

STARLET.QIO (STATUS

IO_CHANNEL

and FUNCTION_CODE

system service

STARLET

using

the

interface

RETURN_STATUS,

CHAN

IOCHANNEL,

FUNC

FUNCTION CODE,

ASTADR

AST HANDLER.RECEIVE
AST’AST ENTRY,

ASTPRM =>

end AST

the

3);

EXAMPLE;

Note:

Because it depends on the VAX Ada defined type AST_HANDLER, the
AST _ENTRY attribute 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

Program Structure and Compilation Issues

The overall structure of programs and the facilities 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

::=

{compilation_unit}

compilation
unit

::=
context clause library unit

library unit

context_clause

secondary unit

::=

subprogram declaration

package declaration

generic declaration

generic_instantiation

subprogram body

secondary unit

::=

library
unit body

10—1

library
unit body
::=

subprogram body

subunit
|

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 (whether a library unit or a subunit) must

be an identifier. Within a program library the simple names of all library
units must be distinct identifiers.

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

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

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

A subprogram that is a library unit can be used as a main program in 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 impose certain
requirements on the parameters and on the result, 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:
e

Ifitis a procedure with no formal parameters. In this case, the status

returned to the VMS environment 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

Ifitis a function with no formal parameters whose returned value is 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, 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 of the first (and only)
parameter.

Note that when a main function or a main procedure declared with the
pragma EXPORTVALUED_PROCEDURE returns a discrete value whose
size is less than 32 bits, the value is zero- or sign-extended as appropriate.
Notes:

A simple program may consist of a single compilation unit. A compilation
need not have any compilation units; for example, its text can consist of
pragmas.
10

The designator of a library function cannot be an operator symbol, but a
renaming declaration is allowed to rename a 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
STANDARD is hidden) since library units act as declarations that occur
immediately within the package STANDARD.
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

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

with_clause

::=

{with clause

::= with

unit_ simple

{use clause}}

name

unit simple name};

The names that appear in a context clause must be the simple names of

library units. The simple name of any library unit is allowed within a with
clause. The only names allowed in a use clause of a context clause are the
simple names of 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 same effect is obtained
whether the name of 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 compilation 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 assumed to be already present

in the program library. Such packages may be used by other main programs.
with TEXT IO,

REAL OPERATIONS; use REAL_OPERATIONS;
procedure QUADRATIC EQUATION is
A,

REAL;

use REAL IO,

TEXT IO,
REAL FUNCTIONS;

—-—

achieves direct visibility of

——

GET and PUT

for REAL

——

achieves direct visibility of

-—

PUT

achieves direct visibility of SORT

for

strings

and of NEW_LINE

begin

GET (A) ;
D

GET(B);

:= B**2

if D

0.0

GET(C);

4.0*%A*C;
then

PUT ("Imaginary Roots.");
else

PUT ("Real Roots

X1 =

");

X2 = ");
PUT((-B - SQRT(D))/(2.0*A)); PUT("
PUT((-B + SQRT(D))/(2.0%Rn));

end if;
NEW LINE;

end QUADRATIC EQUATION;

Notes on the example:

The with clauses of a compilation unit need only mention the names of those
library subprograms and packages whose visibility 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 named in 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_EQUATION since
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 number of compilation units. For
example, consider the following program.

procedure

PROCESSOR

SMALL

constant

20;

TOTAL

INTEGER

package

STOCK

LIMIT

constant

1000;

TABLE

array

LIMIT)

INTEGER;

procedure RESTART;
end

STOCK;

package body

STOCK

procedure

RESTART

begin
for

N in

TABLE (N)

LIMIT

loop

end loop;
end;
begin
RESTART;

end

STOCK;

procedure UPDATE
(X
use

INTEGER)

STOCK;

begin
TABLE (X)

TABLE (X)

SMALL;

end UPDATE;

begin
STOCK.RESTART;

reinitializes

TABLE

end PROCESSOR;

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

10.1.2

Examples of Compilation Units

Example 2: Several compilation units:
package STOCK is
LIMIT

constant

1000;

TABLE

array

LIMIT)

procedure

INTEGER;

RESTART;

end STOCK;
—

—

———

——

—

———

—

WWWD

WHWe

W——

———

—

——

—

——

package body STOCK is
procedure RESTART is
begin

for N

TABLE (N)

LIMIT

loop

end loop;

end;
begin
RESTART;

STOCK;

end

with

STOCK;

procedure PROCESSOR is
SMALL

constant

20;

TOTAL

INTEGER

procedure UPDATE
(X
use

INTEGER)

STOCK:;

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 no visibility 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.RESTART and in 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.

body stub

::=

subprogram specification

package body package

task body

subunit

name

separate;

name
is

separate;

::=

separate

task simple

simple

(pare
unit nt
name)

proper body

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

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

Each subunit mentions the name of 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 unit is 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
names of all subunits that have the same ancestor library unit must be

distinct identifiers.5

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 appended to

the context clause of the parent unit. If the parent unit is itself a subunit,
then the same rule is used to define the visibility 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 subunait.
Notes:

Two subunits of different library units in the same program library need not
have distinct identifiers. In any case, their full expanded names are distinct,
since the simple names of library units are distinct and since the simple
names of 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 names of 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 name 4.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

Examples of Subunits

10.2.1
1

The procedure TOP is first written as a compilation unit without subunits.
with

TEXT IO;

procedure

TOP

type REAL is digits
R,

REAL

package FACILITY

constant

function

10;

1.0;

F (X

procedure G(Y,

3.14159 26536;
return REAL;

REAL)

:
2

REAL);

end FACILITY;

package body FACILITY is
—-—
some local declarations

10-9

followed by

Examples of Subunits

10.2.1

function

F(X

REAL)

return REAL

begin
—-—

sequence

statements

end F;
procedure

——

G(Y,

local

REAL)

procedures

using

TEXT IO

begin
——

sequence

statements

end G;

end FACILITY;
procedure
use

TRANSFORM(U

in out

REAL)

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 made into separate subunits of TOP. Similarly, the body of the
procedure G can be made into a subunit of FACILITY as follows.

Example 3:

procedure

TOP

type

REAL

is
is

REAL

digits
:=

package FACILITY
PI

10;

1.0;

constant

function

F(X

procedure

G(Y,

is
:=

3.14159

REAL)
Z

26536;

return REAL;

REAL);

end FACILITY;
package body
procedure

FACILITY

TRANSFORM(U

is
:

separate;
in

out

REAL)

~-is

-—

begin

stub

FACILITY

TRANSFORM

separate;

stub

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)

FACILITY;

use

begin
F(U);

end TRANSFORM;
.

——

separate

- ———

—

——

—

——

— O—

—

——

—————

—

S W

————

——— T——

Ottt

—

(TOP)

package body FACILITY is
—-—

some

local

function F (X

declarations

REAL)

followed by

return REAL is

begin
-—-

sequence

statements

of F

end F;

procedure G(Y,

REAL)

is separate;

-— stub of G

end FACILITY;
—— —————— — —— — ——— — ——

- f— —— — — — — ———

—— —— —— —— —————— —— t—

— — — — — —

with TEXT IO;

separate

(TOP.FACILITY)

procedure G(Y,

——

REAL)

——

full

name

of FACILITY

local procedures using TEXT IO

begin

-—-

sequence

statements

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
same as 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 same identifiers 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.
10

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
consequences of 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 by its
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).6

The order in which the compilation units of a program are compiled must be
consistent with the partial ordering defined by the above rules.

Similar rules apply for recompilations. A compilation unit is potentially
affected by a change in any library unit named by its 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 compi-

lation 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

If a pragma INLINE is applied to a subprogram declaration given in
a package specification, inline inclusion will only be achieved if 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 separatelg compiled
subprogram for which an INLINE pragma is specified.

In VAX Ada, if a pragma INLINE_GENERIC is 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).

Tor 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 body is 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_
OPERATIONS since they appear in its with clause.
12

(b)

In example 2 (see 10.1.2): The package body STOCK must be compiled

after the corresponding package specification.
13

(¢)

In example 2 (see 10.1.2): The specification of the package STOCK

must be compiled before the procedure PROCESSOR. On the other
hand, the procedure PROCESSOR can 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:
16

For library packages, it follows from the recompilation rules that a package
body is made obsolete by the recompilation of the corresponding specification. 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 package is

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, elaboration 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 the library 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 named are not concerns of the language definition; they are
concerns of the programming environment.
There should be commands for 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 commands is not specified by the language definition.

VAX Ada program library management, as well as commands for 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
1

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 liobrary unit bodies, and to their subunits; and so on, in a

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

(library
unit simple name

library_unit

simple name}) ;

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 name of a library

unit mentioned by the context clause, and this library unit must have a

library unit body. Such a pragma specifies that the library unit body must

be elaborated before the given compilation unit. If the given compilation
unit 1s 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 (that is, if a
circularity exists). The elaboration of the compilation units of the program
1s performed in some order 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 programmer of a potential error.
References: condition 5.3, declaration 3.1, elaboration 3.9, evaluation 4.5, exception 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

Exceptions

This chapter defines the facilities for dealing with errors or other exceptional
situations that arise during program execution. Such a 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

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.3, subprogram body 6.3, task body 9.1

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

11-1

exception declaration

::= identifier_ list

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 name for a different exception. In par-

ticular, 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 name is 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

NUMERIC_ERROR

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

Exception Declarations

11-2

an implementation is not required to raise this
exception when such an error situation arises; see
also section 11.6.1
VAX Ada raises NUMERIC_ERROR only when
it is explicitly raised with a raise statement.

Wherever this standard requires that NUMERIC_
ERROR be raised, CONSTRAINT_ERROR will be

raised instead.?

PROGRAM_ERROR

This exception is raised upon an attempt to
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 no else part,
if this execution determines that all 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
erroneous situations; it is not raised for incorrect
order dependences.

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.

TASKING_ERROR

This exception is raised when exceptions arise
during intertask communication (see 9 and 11.5).

In addition to these exceptions, VAX Ada provides two packages of inputoutput exceptions: IO_EXCEPTIONS (predefined by the language), and
AUX I0_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.7a.5.
Note:

The situations described above can arise without raising the corresponding
exceptions, if the pragma SUPPRESS has 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,
12

UNDERFLOW

exception;

References: access value 3.8, collection 3.8, declaration 3.1, exception 11, excep-

tion 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 body 6.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 expression 4.7, range

constraint 3.5, selected component 4.1.3, slice 4.1.2, subtype indication 3.3.2, type

conversion 4.6

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
15

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 exceptions is specified by an exception handler.
exception handler

::=

when exception choice

exception_choice}

sequence
of statements

exception choice

::= exception name

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
sequence
of statements

exception

exception_handler

{exception handler}
end

The exceptions denoted by the exception names given as exception choices
of a frame must all be distinct. The exception choice others is only allowed
for the last exception handler of a frame and as its only exception choice;
it stands for all exceptions not listed in previous handlers of the frame,
including exceptions whose names are 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_ERROR can be 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

statements

exception

when

SINGULAR

PUT ("

when

NUMERIC ERROR

MATRIX

others

SINGULAR

");

PUT ("

FATAL

raise

ERROR;

ERROR

")
;

end;

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 statement is 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.
raise_statement

::=

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 name is

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

raise;

explicitly

—-—

exception

——

only within

raising

a predefined

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

Exception Handling

11.4

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.?3
Note:

By providing the pragma IMPORT_EXCEPTION (see 13.9a.3.1), VAX Ada
allows Ada exception handlers to handle any VMS conditions raised in Ada
code or in imported (non-Ada) code. VAX Ada also provides the package
CONDITION_HANDLING to 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 Manual for
implementation details and for information on using these pragmas and
packages.

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 whether or not this frame has
a handler for the exception, and on whether the exception is raised in the
sequence of statements of the frame or 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 and control 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).

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.

(b)

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

(c)

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)

An exception that is raised again (as in the above cases (a), (b), and

For a task body, the task becomes completed.

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

FLOAT(N)

FACTORIAL (N-1);

begin
if

return

return FLOAT

then
1.0;

else
return

end

if;

exception

when NUMERIC ERROR

return FLOAT’ SAFE LARGE;

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_
ERROR exceptions to be raised by the evaluation of 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

ERROR

exception;

procedure R;

procedure Q is
begin

(2)

-—

error situation

—--

handler EZ

——

error situation

(3)

-—

error situation

(1)

——

handler E1

exception

when ERROR =>
end Q;

procedure R is
begin

.o
end R;
begin

.« o
Q;
exception

when ERROR =>
end P;

The following situations can arise:

(1)

If the exception ERROR is raised in the sequence of statements of the
outer procedure P, the handler E1 provided within P is used to complete

the execution of P.
16

(2)

If the exception ERROR is raised in the sequence of statements of 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.

(8)

If the exception ERROR is 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 (in-

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

Lastly, if ERROR had been declared in R, rather than in P, the handlers E1
and E2 could not provide an explicit handler for ERROR since this 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 abandoned after 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.
23

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 body 6.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:

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

11.4.2

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
package is a library unit, execution of the main program is abandoned.
(d)

For a task body, the task becomes completed, and the exception

TASKING_ERROR is 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), (¢) 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

begin
declare

INTEGER

:= F;

the

function F may

——

handler E1

——

handler

raise ERROR

begin
exception
when ERROR =>
end;

exception
when ERROR

EZ2

end P;

11-11

—-—

1f the

—-—

exception ERROR is
handled by

raised

in the

declaration

EZ2

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 a task calls an entry of another task, the exception TASKING._
ERROR is raised in the calling task, at the place of the call, if the called
task is completed before accepting the entry call or is already completed at

the time of the call.

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_ERROR is 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 is left, 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 same effect 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 invoked in the alternative order if 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 operands is

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
operands is allowed if it satisfies the following requirement: an integer

result must be equal to that given by the canonical left-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_ERROR need not be raised in such a
case. In particular, if the numeric expression is an operand of a predefined

relational operator, the exception NUMERIC_ERROR need not be raised by
the evaluation of the relation, provided that the correct BOOLEAN result is

obtained.’

A predefined operation need not be invoked at all, 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

forms.

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

Example:
declare
N

INTEGER;

begin
N

for

J in
N

1
N

..
+

-—-

(1)

loop

J**A(K);

and

are

global

variables

end loop;
PUT (N) ;

exception

when others

=> PUT ("Some

error arose");

PUT(N):;

end;
11

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 the possibility of
having an undefined initial value of N in the handler.
12

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 pragma is 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 SUPPRESS is 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
pragma to 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 named object 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 Ada provides the pragma
SUPPRESS_ALL for the purpose of suppressing all run-time checks in a
compilation unit. The form of this pragma is as follows:
pragma

SUPPRESS ALL;

The pragma SUPPRESS_ALL is only allowed following a compilation unit.
The scope of the pragma is 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 may be raised; for these checks, the name Gif
present) must denote either an object or a type.

ACCESS_CHECK

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

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

INDEX CHECK

Check that the bounds of an array value
are equal to the corresponding bounds of

an index constraint. Also, when accessing a
component of an array object, check for each

dimension that the given index value belongs
to the range defined by the bounds of the
array object. Also, when accessing a slice of

an array object, check that the given discrete
range is compatible with the range defined by

the bounds of the array object.
9

LENGTH_CHECK

Check that there is a matching component

for each component of an array, in the case
of array assignments, type conversions,

and logical operators for arrays of boolean
components.

RANGE_CHECK

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 descriptor is created or used to pass
a parameter to or accept a function result

from an imported subprogram, check that the
descriptor length field is large enough to hold
the actual parameter or 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_ERROR is raised. The only allowed names in the corresponding
pragmas are names of numeric types.

DIVISION_CHECK

Check that the second operand is not zero for
the operations /, rem and mod.

OVERFLOW_CHECK

Check that the result of a numeric operation
does not overflow.

The following check corresponds to situations in which the exception
PROGRAM_ERROR is raised. The only allowed names in the corresponding
pragmas are names denoting task units, generic units, or subprograms.

ELABORATION_CHECK

When either 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_ERROR is 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 than is available for a
collection. Check that the space available for

a task or subprogram has not been exceeded.
18

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

11-17

Examples:
pragma

SUPPRESS (RANGE CHECK) ;

pragma

SUPPRESS (INDEX CHECK,

TABLE);

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

antee 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_CHECK correspond to hardware checks that cannot be suppressed; the exceptions that correspond to

ACCESS_CHECK and STORAGE_CHECK may also be raised when the
pragma SUPPRESS_ALL is 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.3, 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

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 package is 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 parameter of a
subprogram), it can be a type or a subprogram.

12-1

Generic Declarations

12.1

generic_declaration

::=

generic specification
|

generic specification;

::=

generic_form
part
al

subprogram specification

generic_form
part
al

package specification

generic_formal
part
generic

::=

{generic_parameter declaration}

generic parameter declaration

::=

identifier list

[in

type

gener
type definition;
ic

identifier

[out]]

type mark

[:= expression];

priva
type declaration
te

with

subprogram specification

[is

name];

with

subprogram specification

[is

<>];

gener
type definition
ic

(<>)
|

range <>

::=

digits <>

array_type_definition

delta <>

access_type

definition

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 name of this
program unit denotes the generic unit. In contrast, within the declarative

region associated with a generic subprogram, the name of 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 name of this program unit denotes the package obtained by the

current instantiation.1

The elaboration of a generic declaration has no other effect.
Examples of generic formal parts:
generic

—--

parameterless

generic
SIZE

NATURAL;

formal

object

generic
LENGTH

AREA

INTEGER

200;

LENGTH*LENGTH;

——-

formal

—-

default

formal

—-—

default

object

with

expression
object

with

expression

1 See also Appendix G, AI-00286, AI-00367, and AI-00412.
12.1

Generic Declarations

12-2

generic

-— formal type

1is private;
type ITEM
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

generic
type

in out

ITEM is private;

with function "*" (U,
function SQUARING(X

ITEM)

ELEM);

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,

ITEM)

return

of ITEM;

ITEM;

package ON_VECTORS 1is
function

SUM

(A,

function SIGMA
(A

LENGTH _ERROR

VECTOR)

return VECTOR;

VECTOR)

return ITEM;

exception;

end;

Notes:
10

Within a generic subprogram, the name of this program unit acts as the
name of a subprogram. Hence this name can be overloaded, and it can
appear in a recursive call of the current instantiation. For the same reason,
‘this name cannot appear after the reserved word new in a (recursive)
generic instantiation.

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 name for 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 subprograms are 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.)
12

Neither generic formal parameters nor their attributes are allowed constituents 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 other effect

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 8.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 mode that 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 mode is 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 mode is in (whether this mode is 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 value is 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 recommended that the name of 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: anonymous type 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 the class 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)

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

12-5

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

(c)

For an access type definition, the available operations are those defined
in section 3.8.2 (for example, allocators can be used).

The four forms of generic type definition in which a box appears (that is, the

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.

(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 same holds for a formal fixed point type, except for the
multiplying operators that deliver a result of the type universal_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:

12.1.2

type

ITEM is

type

BUFFER (LENGTH

private;
:

NATURAL)

type ENUM

i1is

(<>);

type

range

<>;

type ANGLE

delta

<>;

type MASS

digits

<>;

type

array

(ENUM)

INT

TABLE

Generic Formal Types

limited private;

ITEM;

12-6

Example of a generic formal part declaring a formal integer type:
generic

FIRST

RANK

SECOND

RANK

range <>;

mou

type RANK

RANK'FIRST;

FIRST

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
1

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 name of 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,

ITEM)

with function

"+" (X,

with function

IMAGE
(X

with procedure UPDATE

12-7

:
:

:
is

INTEGER)

ITEM)

ENUM)

return

INTEGER;

return

ITEM;

return

ITEM is <>;

return STRING is

ENUM'’ IMAGE;

DEFAULT UPDATE;

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 name of 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 recommended that the subtype name defined 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.
References: anonymous type 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.3, 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 INLINE_GENERIC
VAX Ada provides the pragma INLINE_GENERIC to 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 pragma is as follows:
pragma

INLINE

GENERIC

(name

name});

Each name is either the name of a generic declaration or the name of
an instance of a generic declaration. The pragma INLINE_GENERIC 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.
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) subprograms satisfy this
requirement, the pragma applies to all of them. If the pragma appears

after a given library unit, the only name allowed is the name of 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 of calls of
the subprogram is desired).

If the name specified by a pragma INLINE_GENERIC is 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 pragma all occur in the same declarative part
or package specification. The pragma is 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_GENERIC causes inline expansion of the generic body
(and substitution of actual parameters for any generic formal parameters)
at the point of any instantiation to which the pragma applies. Because
of this effect, the pragma INLINE_GENERIC differs from the pragma
INLINE in two respects. First, the pragma INLINE_GENERIC for a generic
subprogram or an instance of a generic subprogram does not indicate a

desire that calls of the subprograms are to be expanded inline. 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 INLINE is given for a generic subprogram, the pragma
INLINE_GENERIC may also be given; similarly, if the pragma INLINE
is given for an instance of a generic subprogram, the pragma INLINE_

GENERIC may also be given. In such cases, if calls are expanded inline,
then the pragma INLINE_GENERIC has no additional effect. However, if

calls are not expanded inline, the instance may still be expanded inline. (If
only the pragma INLINE is given, and calls are not expanded inline, then
the instance cannot be expanded inline either.)
If a pragma INLINE_GENERIC appears at the place of a declarative item

and a name in the pragma is 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.1b

Pragma SHARE_GENERIC
VAX Ada provides the pragma SHARE_GENERIC to 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
pragma is as follows:
pragma

SHARE GENERIC

(name

name});

Each name is either the name of a generic declaration or the name of
an instance of a generic declaration. The pragma SHARE_GENERIC 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.
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

a given library unit, the only name allowed is the name of that unit.

If the name specified by a pragma SHARE_GENERIC is an instantiation
declared by a renaming declaration, the pragma SHARE_GENERIC applies

The meaning of an instantiation is not changed by the pragma SHARE_
GENERIC.
The pragmas SHARE_GENERIC and INLINE_GENERIC cannot 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 expanded inline.
Similarly, the pragma SHARE_GENERIC can be specified for an instance
even if the pragma INLINE_GENERIC applies to the corresponding generic

12.1b

Pragma SHARE_GENERIC

12-10

declaration. Again, the pragma specified for the instance overrides the
pragma that applies to the generic declaration.
Notes:

The pragma SHARE_GENERIC causes the code for an instance to be
generated in such a manner as to allow the same code to be shared by other

instances of the same generic under some conditions.
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.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.
3

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

Example of a generic procedure body:
procedure

EXCHANGE
(U,

ELEM;

the

out

generic

ELEM)

formal

—-

see

example

12.1

type

begin
T

:=V;

end EXCHANGE;

Example of a generic function body:
function

SQUARING(X

ITEM)

return

ITEM is

see

example

12.1

begin
return

X*X;

the

formal

operator

"*"

end;

2 See also Appendix G, AI-00328.

12—-11

Generic Bodies

12.2

Example of a generic package body:
package body ONVECTORS
function

SUM(A,

see

VECTOR)

example

return VECTOR

RESULT

VECTOR
(A’ RANGE) ;

BIAS

constant

INTEGER

——

the

B’/FIRST

12.1

is
formal

type

VECTOR

A’FIRST;

begin

if A’LENGTH
raise

/= B’LENGTH then

LENGTH ERROR;

end if;
for N

in A’RANGE

RESULT
(N)

loop
SUM(A(N),

B(N

BIAS));

——

the

-—

function

formal

SUM

end loop:;
return

RESULT;

end;

function

SIGMA
(A

TOTAL

ITEM

:
:=

VECTOR)

return

ITEM is

A(A’FIRST);

—-—

the

formal

-—

type

ITEM

-——

the

formal

-—

function

begin
for N

in A’'FIRST

TOTAL

SUM(TOTAL,

A’LAST

loop

A(N));

SUM

end loop;
return

TOTAL;

end;

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

12.3

Generic Instantiation
1
2

An instance of a generic unit is declared by a generic instantiation.
generic instantiation

package
new

procedure

function
new

generic package name

new

::=

identifier

generic procedure name

designator

[generic actual part];

generic association})

::=

[generic
formal parameter

Generic Instantiation

name

::=

(generic_association
generic association

[generic actual part];

generic function

generic actual part

12.3

[generic_actual part];

=>]

generic actual parameter

12—12

generic formal parameter
parameter simple name

::=

generic_actual parameter

::= expression

subprogram name

operator_symbol

entry name

variable name

type mark

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 named associations are not allowed for the
corresponding generic parameters.
Each generic actual parameter must maitch 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 name or

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)

For a name that denotes the generic unit: The corresponding occurrence denotes the instance.

(b)

For a name that denotes a generic formal object of mode in: The

corresponding name denotes a constant whose value is a copy of the
value of the associated generic actual parameter.

(¢)

For a name that 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 named by the associated generic actual
parameter (the actual subtype).

(e)

For a name that 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 corresponding 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.

(1)

For a name that 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 (i1). 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.
16

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 parameter is 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

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

19—-14

Examples of generic instantiations (see 12.1):
procedure SWAP

is new EXCHANGE (ELEM =>

INTEGER);

procedure SWAP is new EXCHANGE (CHARACTER);
function SQUARE is new SQUARING(INTEGER);

—--

SWAP

is overloaded

"*" of

—-—

used

INTEGER
default

function SQUARE is new SQUARING(ITEM => MATRIX,
kN

=> MATRIX_PRODUCT);

function SQUARE is new SQUARING (MATRIX,

MATRIX PRODUCT);
——

same as previous

TABLE,

package INT VECTORS is new ON_VECTORS (INTEGER,
20

"+");

Examples of uses of instantiated units:
SWAP (A,
A

T
N

:
:

B);

SQUARE
(&) ;

TABLE(1
INTEGER

.. 5) := (10, 20, 30, 40,
:= INT VECTORS.SIGMA(T);

use

INT VECTORS;

INTEGER

SIGMA(T);

50);
-150

(see 12.2

-—

body

the

for

SIGMA)

150

Notes:
21

Omission of a generic actual parameter is 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.

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 which all 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

return A;

function NEXT (X

return B;

end;

12-15

package P

is new G(A => BOOLEAN,

-- calls

of P.NEXT are ambiguous

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 name 6.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
1

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 _ERROR is raised if this check
fails.
A generic formal parameter of mode in out of a given type is matched by

the name of 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 renaming is 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.3, 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.3, 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:

If the formal type is not limited, the actual type must not be a limited
type. (If, on the other hand, the formal type is 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

If the formal type has a discriminant part, the actual type must be a
type with the same number of discriminants; the type of a discriminant
that appears at a given position in the discriminant part of the actual
type must be the same as the 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 name is 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 name of 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 elaboration 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 any fixed point subtype. No
other matches are 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.

For each index position, the index type must be the same for 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 same for 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 ERROR is raised if
this check fails.

Example:
--

given

the

generic

package

generic
type

ITEM

is private;

type

INDEX

(<>);

type VECTOR

array

(INDEX

range

type

array

(INDEX)

TABLE

package P

<>)

ITEM;

end;
--

and

the

types

type MIX

array

(COLOR range

type

array

(COLOR)

——

OPTION

then MIX

VECTOR

Maiching Rules for Formal Array Types

<>)

of BOOLEAN;

BOOLEAN;

can match VECTOR and

package R is new P (ITEM

12.3.4

OPTION

can match

TABLE

BOOLEAN,

INDEX =>

COLOR,

MIX,

TABLE

OPTION)

12-18

——

Note that MIX cannot match TABLE and

——

OQPTION cannot match VECTOR

Note:

For the above rules, if any of the index or component types of the formal
array type is 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 actnal parameter 12.3, raise
statement 11.3, subtype 3.3, unconstrained array type 3.6

Matching Rules for Formal Access Types

12.3.5
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_ERROR is raised if this check fails.
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 CAR NAME is access

CAR;

type CAR is
record

PRED,

SUCC

CAR NAME;

NUMBER

LICENSE NUMBER;

OWNER

PERSON;

end record;

——

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 parameter position.
2

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

sponding 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, enumeration literal, or entry is then used by

default (there must be exactly one subprogram, enumeration literal, or entry
satisfying the previous conditions).

Example:
—-

given

the

generic

function

specification

generic
type

ITEM

with

function

function
-—

and

private;

"*"

SQUARING(X
the

(U,

the

ITEM)

return

ITEM;

ITEM

<>;

function

function MATRIX_PRODUCT(A,
——

ITEM)

following

instantiation

MATRIX)
is

return MATRIX;

possible

6 See also Appendix G, AI-00038.
12.3.6

Matching Rules for Formal Subprograms

12-20

function SQUARE is new SQUARING(MATRIX,

MATRIX PRODUCT) ;

the following instantiations are equivalent

-—

function SQUARE is new SQUARING(ITEM => INTEGER,
function SQUARE is new SQUARING (INTEGER, "*");

"*" => "*");

function SQUARE is new SQUARING (INTEGER) ;

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 attribute is
a function with a matching specification. An enumeration literal of a given
type matches a parameterless formal function whose result type is the given
type.

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.3, 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
1

The following example provides a possible formulation of stacks by means of
a generic package. The size of each stack and the type of the stack elements
are provided as generic parameters.

generic
SIZE

type

ITEM is private;

POSITIVE;

package

STACK is
procedure PUSH(E
procedure POP (E

OVERFLOW,
end

ITEM);

out ITEM);
UNDERFLOW : exception;
:

STACK;

package body STACK is

type TABLE is array

12—-21

(POSITIVE range <>)

SPACE

TABLE(1

SIZE);

INDEX

NATURAL

of ITEM;

Example of a Generic Package

12.4

procedure

PUSH(E

ITEM)

begin

INDEX >=
raise

end

SIZE

then

OVERFLOW;

if;

INDEX

SPACE (INDEX)

out

end PUSH;
procedure

POP(E

ITEM)

begin
if

INDEX =
raise

then

UNDERFLOW;

end if;
E

SPACE (INDEX) ;

INDEX

end POP;
end

STACK;

Instances of this generic package can be obtained as follows:
package

STACK INT

new

STACK(SIZE

package

STACK BOOL

new

STACK (100,

BOOLEAN)
;

200,

ITEM =>

INTEGER)
;

Thereafter, the procedures of the instantiated packages can be called as
follows:

STACK_INT.PUSH(N)
;
STACK_BOOL.PUSH
(TRUE) ;

Alternatively, a generic formulation of the type STACK can be given as

follows (package body omitted):
generic
type

package
type

ITEM is private;

ONSTACKS

STACK(SIZE

POSITIVE)

limited private;

procedure

PUSH(S

in out

STACK;

ITEM);

procedure

POP

STACK;

out

ITEM):;

OVERFLOW,

UNDERFLOW

out

exception;

private
type

TABLE

type

STACK(SIZE

array

(POSITIVE

POSITIVE)

range

<>)

ITEM;

record
SPACE

TABLE(1

SIZE);

INDEX

NATURAL

end record;
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
S

STACK REAL is new ON_STACKS (REAL);

use

STACK REAL;

STACK(100);

begin
PUSH (S,

2.54);

end;

12-23

Example of a Generic Package

12.4

Chapter 13

Representation Clauses and
Implementation-Dependent Features

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

::=

type representation
clause

::=

address_clause

length_clause

enumeration representation clause

recordrepresentation_clause

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

An address clause applies either to an object; to a subprogram, package, or

task unit; or to an entry. At most one address clause 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.

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 tgpe itself. In any case, an occurrence within an expression is
always forcing.
7

A representation clause for a given entity must not appear after an

occurrence of the name of the entity if this occurrence forces a default
determination of representation for the entity.
8

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

Whereas a 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 when selecting the representation of a record or array
type. Its form is as follows:
pragma PACK (type

simple name) ;

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, and the restrictions on the
named type, are governed by the same rules as for a representation clause;
in particular, the pragma must appear before any use of a representation
attribute of the packed entity.
13

The pragma PACK is 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 pragma that is not accepted by the implementation is ignored.)

In VAX Ada, all array and record components are aligned on byte boundaries
by default; the effect of the pragma PACK on a record or array is to cause
those components that are packable to be allocated in adjacent bits without
regard to byte boundaries. Whether any particular component is packable
depends on the rules for 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 formal type.
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 subcomponent of 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.

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

length clause

::= for attribute use simple_expression;4

The expression must be of some numeric type and is 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. The effect of the
length clause depends on the attribute designator:
4

(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 number of 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

134

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 also be static.

In VAX Ada, for a discrete type, the given size must not exceed 32
(bits). The given size becomes the 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; that is,
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).

For all 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 specifies the
number of storage units to be reserved for the collection, that is, the
storage space needed to contain all objects designated by values of the
access type and by values of other types derived from the access type,
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 number of bytes in the collection) is rounded up
to the next integral number of pages (where one page is 512 bytes),
and is then used as the initial size for the collection; the collection is
not extended should that initial allocation be exhausted. If the value is
equal to zero, no storage is initially allocated for the collection; storage
is allocated as needed, until all virtual memory is depleted. (This is the
default behavior in the absence of a length clause.) If the value is less
than zero, the exception CONSTRAINT_ERROR is raised.
(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 be static); 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

amount of 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 extended if the initial
allocation is exhausted. If the value is less than zero, the exception

CONSTRAINT ERROR is raised.
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+ SMALL
The prefix T must denote the first named subtype of a fixed point
type. The expression must be a static expression of some real 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

therebgr also affects the amount of storage for objects that have this

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
for

MYFIXED

delta

MYFIXED’SMALL use

0.1

range

0.0

1.0;

0.03125;

This example is a legal specification for the declaration of MY_FIXED

because the value specified for small (0.03125) is a power of two (2.07°)
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.

What is considered to be part of the storage reserved for a collection or for

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 needed for the collection associated
with an access type declared within the task body. Neither does it define
the method of 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 scheme or 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 same size 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

number of allocated objects.
16

Examples:
—-

assumed declarations:

type MEDIUM is range 0

65000;

is delta 0.01 range -100.0
type SHORT
range -360.0
type DEGREE is delta 0.1
BYTE

constant

PAGE

constant

:= 2000;

-—

..
..

100.0;
360.0;

length clauses:

for COLOR’SIZE

use 1*BYTE;

see 3.5.1

for MEDIUM’ SIZE use 2*BYTE;
for SHORT’SIZE

use

15;

E use
SIZE
for CARNAME’STORAG

approximately 2000 cars

2000* ( (CAR’ SIZE/SYSTEM.STORAGE UNIT)

+ 1);

for KEYBOARD DRIVER’STORAGE_SIZE use 1*PAGE;

for DEGREE’ SMALL use 360.0/2** (SYSTEM.STORAGE_UNIT - 1);

Length Clauses

13.2

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~7 and
SHORT' MANTISSA = 14. The length clause for DEGREE forces the model
numbers to exactly span the range of 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_STORAGE to 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 pragma is as follows:
pragma

TASK_STORAGE ([TASK_TYPE

[TOP_GUARD

=>]

simple

name,

static simple expression);

The simple expression must be a static expression of some integer type; its
value specifies the additional number of 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_STORAGE is 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 pragma applies 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 may precede or 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 EVEN GUARD is
end EVEN GUARD;

(TASK_TYPE => EVEN GUARD,
TOP_GUARD => 3*512);

pragma TASK STORAGE

-— guard size will be 2 pages (rounded up);
—-— activation size (storage size) will be 10 pages
task type ROUND
IT

end ROUND IT;

(TASK TYPE => ROUND_IT,

pragma TASK STORAGE

TOP_GUARD

1000);

SIZE use 10%512;
for ROUND IT’STORAGE

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

Pragma MAIN_STORAGE
VAX Ada provides the pragma MAIN_STORAGE to 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 pragma is as

follows:
pragma MAIN STORAGE (

main storage option
main storage option

main storage option]);

[WORKING STORAGE => ] static_simple_expression
[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 number of 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 pages are provided. If the
value is less than zero for either WORKING_STORAGE or TOP_GUARD,
the pragma is ignored.
A pragma MAIN_STORAGE is only allowed in the outermost declarative
part of a library subprogram; at most one such pragma is allowed for a

subprogram. This pragma has an effect only when the subprogram to which

it applies is used as a main program.

On the VMS operating 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
pragma

MAIN PROGRAM

MAIN

STORAGE

(WORKING

STORAGE

TOP_GUARD

10%*512,

1000);

begin

end

MAIN PROGRAM;

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*3512 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

An enumeration representation clause specifies the internal codes for the

literals of the enumeration type that is named in the clause.

enumeration representation

for

type simple_name use

clause

::=

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 universal_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 must satisfy 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 MIX CODE is
for

MIX CODE

(ADD,

SUB,

MUL,

LDA,

STA,

STZ);

use

(ADD =>

SUB =>

ILDA =>

STA => 24,

MUL => 3,
STZ =>

33);

Notes:

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 functions are likely 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

record_representation
clause

for

type

record

simple

name

::=

use

[alignment clause]

{component clause}

end record;
alignment clause

::= at mod

component

::=

clause

component_name

static simple expression;

static simple expression

range static range;’/

The simple expression given after the reserved words at mod in an
alignment clause, or after the reserved word at in a component clause, must
be a static expression of some integer type. If the bounds of the range of a
component clause are defined by simple expressions, then each bound of 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 Ada allows the simple expression in an alignment clause to have a

value of 27, where 0 <= n <= 9. In other words, the simple expression must
be an integer in the range 1..512 that is also a power of 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:

For statically allocated record objects, there are no other restrictions; 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 Manual for 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 component is allowed to overlap a storage boundary, and if so,
how, is implementation-defined.

In VAX Ada, the size of a storage unit (SYSTEM.STORAGE_UNIT) is eight
bits (one byte). If the number of bits specified by the range is sufficient
for the component subtype, the requested size and placement of 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 component clause
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 Ada are restricted 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 component clause 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 clause is given for a
component, then the choice of the storage place for the component is 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 component clause are allocated first;

then, unnamed components are allocated 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 PACK is specified, 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 component clause is only allowed for a component if any
constraint on this component or on any of its subcomponents is static.8

An implementation may generate names that denote implementation-

dependent 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-dependent attributes).
VAX Ada generates no implementation-dependent components or names.
9

Example:
WORD

comstant

storage

unit

-—-

per

word

type

STATE

(A,

type

MODE

(FIX,

type BYTE MASK
type

STATE

type

MODE

MASK
MASK

W,
DEC,

bytes

P);
EXP,

SIGNIF);

is array (0 .. 7) of BOOLEAN;
is

array

(STATE)

BOOLEAN;

array

(MODE)

BOOLEAN;

pragma

PACK

(BYTE _MASK);

pragma

PACK

(STATE

for

pragma

PACK

(MODE MASK) ;

type

byte,

MASK);

PROGRAM STATUS WORD

VAX

Ada

the

these

alignment

must

work

packed

record

end

SYSTEM MASK

BYTE

PROTECTION
KEY

INTEGER

MACHINE_STATE

STATE

MASK;
range

MASK;

INTERRUPT CAUSE

INTERRUPTION CODE;

ILC

INTEGER

range

INTEGER

range

PROGRAM MASK

MODE MASK;

INST ADDRESS

ADDRESS;

record;

8 See also Appendix G, AI-00132.
13.4

Record Representation Clauses

13-14

for

PROGRAM STATUS
record at mod

WORD

use

SYSTEM MASK

0*WORD

range

-—

bits

PROTECTION
KEY

O*WORD

range

11l;

unused

MACHINE STATE

O*WORD

range

15;

INTERRUPT

O*WORD

range

31;

——

second word

CAUSE

ILC

1*WORD

range

1*WORD

range

PROGRAM MASK

1*WORD

range

INST ADDRESS

1*WORD

range

31;

8,9

end record;
for

PROGRAM STATUS WORD'’SIZE

use

8*SYSTEM.STORAGE_UNIT;

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 ADDRESS is represented in 24 bits; in VAX

Ada, type ADDRESS is represented in 32 bits.

Component Specification Example:
subtype
type

REC

INTEGER

range

13;

record
X

¢+

end record;
for

REC

use

record

X at

Y at

Z
end

range

legal:

——

an unsigned

bits

are

sufficient

for

representation

legal:

a biased

bits

representation

are

—-

illegal:

-—

represent

bit
an

sufficient

not

integer

for

enough to
of

subtype

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 number of bits required for the integer subtype. The

component clause for Y is legal because it requires at least the minimum
number of bits required for a biased representation of the subtype. The

13-15

Record Representation Clauses

13.4

component clause for Z is illegal because it does not allow enough bits to
represent the integer subtype.

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 number 3.2, range 3.5, record component

3.7, record type 3.7, simple expression 4.4, simple name 4.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
1

An address clause specifies a required address in storage for an entity.

address_clause

::=

for

simple

name

use

simple expression;

The expression given after the reserved word at must be of the type

ADDRESS defined 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:

(a)

Name of an object: the address is that required for the object (variable
or constant).9

(b)

Name of a subprogram, package, or task unit: the address is that

required for the machine code associated with the body of the program

unit. 10
6

(c)

Name of a single entry: the address specifies a hardware interrupt to
which the single entry is to be linked.

If the simple name is 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.

2 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 name of 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 _ENTRY attribute in section 9.12a.

Address clauses are not allowed in combination with any of the VAX Ada
pragmas for importing or exporting objects. If used in such cases, the
pragma involved is 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.

Example:
for CONTROL use at

16#0020#;

assuming that

-—

SYSTEM.ADDRESS

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
address clause 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 address clause.
For example, access values are initialized to null, and record components
may also receive initial values. See the VAX Ada Run-Time Reference
Manual for more information.

If an address clause is specified for an object whose type has been declared
with an alignment clause, the alignment required for the address is checked
against the alignment given for the record type. If the two are incompatible,
the exception PROGRAM_ERROR is raised.

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 alignment of 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_ENTRY attribute as
alternative mechanisms for handling asynchronous interrupts from the VMS
operating system. See section 9.12a for more information on this pragma

and attribute.
1

An address clause 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.
2

An interrupt acts as an entry call issued by a hardware task whose priority
is higher than the priority of the main program, and also 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.

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

Example:
task

INTERRUPT HANDLER

entry

for
end

13.5.1

Interrupts

DONE;

DONE

use

INTERRUPT

16#40#;

assuming

-—

that

SYSTEM.ADDRESS

integer type

HANDLER;

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 without first invoking a scheduling action.
7

One of 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. 1
2

Example:
——

PACKED DESCRIPTOR and DESCRIPTOR are

types with

——

their

type

identical

two different

characteristics,

apart

from

representation

DESCRIPTOR 1is

record

-—-

components

descriptor

end record;

type
for

PACKED DESCRIPTOR
PACKED DESCRIPTOR

new DESCRIPTOR;

use

record
—-—

component

clauses

for

some

for

all

components

end record;

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:

DESCRIPTOR;

PACKED_ DESCRIPTOR;
PACKED DESCRIPTOR(D);

pack

DESCRIPTOR(P) ;

—-—

unpack

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

package

type

SYSTEM

implementation defined;

type NAME

implementation
defined enumeration type;

SYSTEM_NAME

STORAGE_UNIT

constant

implementation defined;

MEMORY_ SIZE

constant

implementation defined;

—-—

ADDRESS

constant

System—-Dependent

NAME

Named

implementation defined;

Numbers:

MIN INT

constant

implementation

MAX

INT

constant

implementation defined;

defined;

implementation defined;

MAX DIGITS

constant

MAX

MANTISSA

constant

implementation

defined;

FINE

DELTA

constant

implementation

defined;

constant

implementation defined;

TICK

—-—

Other

System-Dependent

subtype PRIORITY

Declarations

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 ADDRESS is the type of the addresses provided in address clauses;
it is also the type of the result delivered by the attribute ADDRESS. Values

of the enumeration type NAME are the names of alternative machine
configurations handled by the implementation; one of these is the constant
SYSTEM_NAME. The named number STORAGE_UNIT is the number of
bits per storage unit; the named number MEMORY_SIZE is the number of

available storage units in the configuration; these named numbers are of the
type universal_integer.
In VAX Ada, values of the type ADDRESS refer 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 means of the corresponding pragmas. These pragmas are only allowed
at the start of a compilation, before the first compilation unit (if any) of the

compilation.
pragma

SYSTEM NAME (enumeration literal);

The effect of the above pragma is to use the enumeration literal with the
specified identifier for the definition of the constant SYSTEM_NAME. This
pragma is 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 may be either
VAX_VMS or VAXELN.
pragma

STORAGE UNIT (numeric literal);

The effect of the above pragma is 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 must be 8 (bits).
pragma

MEMORY SIZE (numeric_literal);

The effect of the above pragma is 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 must be in 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

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 becomes obsolete 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.
13-21

Thev Package System

13.7

VAX Ada imposes no further 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 pragmas are 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 numbers are declared.

The numbers FINE_DELTA and TICK are of the type universal_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 —231.
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 number of significant
decimal digits in a floating point constraint.
In VAX Ada, the value for MAX_DIGITS is 33.

MAX_ _MANTISSA

The largest possible number of binary digits in the
mantissa of model numbers of a fixed point subtype.

In VAX Ada, the value for

13.7.1

System-Dependent Named Numbers

MAX_MANTISSA is 31.

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_DELTA is 2.0731.
7

TICK

The basic clock period, in seconds. 14

In VAX Ada, the value for TICK is 10.0~2 (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 number 3.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 atiributes. 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 ADDRESS defined

in the package SYSTEM. 15

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 use of the attribute. If the location
of the variable is not byte-aligned, the value is the

address of the lowest byte that holds part or all of the
variable. For an object that is a constant, the value is
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 address value.
For an object that is a named number, the value is zero

(ADDRESS_ZERO).
For an access object, X.all’

ADDRESS

is the address

of the designated object; X.all- ADDRESS is subject.

to an ACCESS_CHECK for the designated object. For
a record component, X.C’ ADDRESS is subject to a
DISCRIMINANT_CHECK for an object in a variant

part. For an array component or slice, X(I) ADDRESS
or X(I1..12) ADDRESS

is subject to an INDEX CHECK

for the denoted component or slice.
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 same as 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 number of bits allocated

to hold the object. Applied to a type or subtype, yields

the minimum number of 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 value is 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_CHECK for an object in a variant
part. For an array component or slice, X(I)’ SIZE or
X(11..12)’ SIZE is subject to an INDEX_CHECK for the
denoted component or slice.

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 word all).
For any type or subtype X:

X MACHINE_SIZE Yields 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_ERROR is 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 Ada storage allocation.
For any object X:

X' BIT

Yields the bit offset within the storage unit (byte)
that contains the first bit of the storage allocated for

the object. The value of this attribute is of the type
universal_integer, and is always in the range 0..7.
For an object that is a variable or a constant allocated
in a register, the value is zero. (The use of this at-

tribute 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_CHECK for 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_CHECK for a component in a variant
part. For an array component or slice, X(I) BIT or

X(I11..12)’ BIT is subject to an INDEX_CHECK for the

denoted component or slice.

For any component C of a record object R1?
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_

imfeger.1

R.C'FIRST BIT

Yields the offset, from the start of the first of the storage
units occupied by C, of the first bit occupied by C. This

offset is measured in bits. The value of this attribute is
of the type universal_integer.
10

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 subtype T:
T’ STORAGE_SIZE Yields the total number of storage units reserved for the

collection associated with the base type of T. The value
of this attribute is of the type universal_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 number of bits used to
hold the object X, whereas X’ STORAGE_SIZE gives the number of 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’ ADDRESS yields 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_SIZE gives 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 component of that type or subtype.

The machine size of a type or subtype can be influenced by representation

clauses, unlike the size of a type or subtype, which is independent of representation clauses. The machine size 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 number of bits that
are read or written to external files 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 component 3.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 attributes if
portability is to be ensured.

For both floating point and fixed point types:

T MACHINE_ROUNDS

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

13-27

Representation Attributes of Real Types

13.7.3

otherwise. The value of this attribute is of

the predefined type BOOLEAN. 19

In VAX Ada, this value is TRUE for floating
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_ERROR in 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
of the underlying machine representation, in terms of the canonical form

defined in section 3.5.7:

T'MACHINE_RADIX

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 number of digits in the mantissa

for the machine representation of the base
type of T (the digits are extended digits in

the range 0 to T 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
numbers are 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 number of type F is
almost
(F’ MACHINE RADIX)** (F/MACHINE EMAX),

and the smallest positive representable number is
F’MACHINE

RADIX

(F’MACHINE

EMIN

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, g_floating
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, ADDRESS is a private type for which the following operations

are declared:
type

ADDRESS

private;

ADDRESS_ZERO

function

(LEFT

ADDRESS;

RIGHT

INTEGER)

"+"

constant

ADDRESS;

function

"+"

(LEFT

INTEGER;

RIGHT

ADDRESS)

function

"-"

(LEFT

ADDRESS;

RIGHT

ADDRESS)

function

"-"

(LEFT

ADDRESS;

RIGHT

INTEGER)

return

ADDRESS;

return ADDRESS;
return

INTEGER;

return

ADDRESS;

—-—

function

"="

(LEFT,

RIGHT

ADDRESS)

—-—

function

"/="

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;
return BOOLEAN;

function

"<"

(LEFT,

RIGHT

ADDRESS)

return

function

"<="

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

BOOLEAN;

function

">"

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

function

">="

(LEFT,

RIGHT

ADDRESS)

return BOOLEAN;

-—

Note

——

the

—-—

that

because

functions
not

have

"="

ADDRESS

and

"/="

private

type,

are

already

available

explicitly

and

defined

generic
type

function

TARGET

private;

FETCH
FROM ADDRESS

ADDRESS)

return

ADDRESS;

TARGET;

generic
type

procedure

TARGET

private;

ASSIGN
TO ADDRESS

TARGET);

The addition, subtraction, and relational functions provide arithmetic and
comparative operations for addresses. The generic subprograms FETCH_

FROM_ADDRESS and ASSIGN_TO_ADDRESS provide operations for

reading from or writing to a given address interpreted as having any desired
type. ADDRESS_ZERO is a deferred constant whose value corresponds to

the first (machine) address.

In an instantiation of FETCH_FROM_ADDRESS or 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_ADDRESS is checked to ensure that the discriminants

satisfy the constraints of the actual subtype. In any other case, no check is

made.

13.7a.1

Properties of the Type ADDRESS

13-30

Functions for converting values of other types to the type ADDRESS are
listed in section 13.7a.6.

Example:
X

INTEGER;

SYSTEM.ADDRESS

:= X’ADDRESS;

-—

legal

function FETCH
is new FETCH FROM ADDRESS (INTEGER)
;
procedure ASSIGN is new ASSIGN TO ADDRESS (INTEGER) ;

-- like "X := A.all;"

X := FETCH(A);

ASSIGN (A, X) ;

—— 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 type classes:
type

TYPE CLASS

(TYPE CLASS_ ENUMERATION,
TYPE

CLASS INTEGER,

TYPE

CLASS

TYPE

CLASS FLOATING
POINT,

FIXED POINT,

TYPE CLASS ARRAY,

TYPE_CLASS RECORD,

TYPE CLASS ACCESS,
TYPE_CLASS_TASK,

TYPE CLASS ADDRESS) ;

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

1331

Enumeration Type for Identifying Type Classes

13.7a.2

Examples:

Given
type

type

NEW INT

INT

range

1..10;

new

STRING;

package

PACK

type

PRIV

private;

PRIV

new

private
type
end

FLOAT;

PACK;

then
——

——

NEW_ INT’TYPE

——

PRIV'TYPE

INT’TYPE CLASS
CLASS

CLASS

equals

TYPE

CLASS

INTEGER

equals

TYPE

CLASS

ARRAY

equals

TYPE

CLASS _FLOATING
POINT

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 hardware floating point data representations:
D_floating, F_floating, G_floating, and H_floating.
type

F_FLOAT

implementation defined;

type

D_FLOAT

implementation

type

G_FLOAT

implementation defined;

type

H_FLOAT

implementation defined;

defined;

These types have all 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 AST HANDLER is
NO

AST HANDLER

limited private;

constant

AST

HANDLER;

The type AST_HANDLER is used in the specification of the AST_ENTRY
attribute, which is the only operation defined for this type. A value of the
type AST_HANDLER is 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 used as an actual parameter to an
imported VMS system service routine, allows explicit specification that no
AST handler is provided.

A function for converting values of the type AST_HANDLER to the type

SYSTEM.UNSIGNED_LONGWORD is listed in section 13.7a.6.
Note:

When using the type ASTHANDLER to 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_HANDLER and constant NO_AST_HANDLER are useful in
writing interfaces to VMS system routines. The following specification from
the package STARLET shows the use of the type AST_HANDLER to declare
an AST address parameter, and shows the use of the constant NO_AST_
HANDLER to give that parameter a default value:

—— interface for the Get Job/Process Information system service
GETJPI

(

STATUS

out

EFN

PIDADR

ADDRESS

PRCNAM

PROCESS NAME

ITMLST

ITEM LIST

I05SB

out

IOSB“TYPE

ASTADR

ASTHANDLER

ASTPRM

COND VALUE TYPE;

NUMBER TYPE
TYPE

pPragma

INTERFACE

pragma

IMPORT VALUED PROCEDURE

PROCESS

AST

(EXTERNAL

VALUE,

VALUE))
:;

VALUE,

TYPE’NULL

PARAMETER;

NOAST HANDLER;

USER ARG__ZERO);

GETJPI)
;

(GETJPI,

"SYSSGETJPI",

ADDRESS,

ITEM LIST TYPE,

USER ARG

(VALUE

ZERO;

PROCESS_NAME

EF NUMBER TYPE,

NAME _TYyPE,

HANDLER

NUMBER

TYPE

USER ARGTYPE

(CONDVALUE TYPE,

13-33

ADDRESS_ZERO;

procedure

IOSB TYPE,

TYPE),

DESCRIPTOR(S),

REFERENCE,

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, matches itself 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

condition to be

function DIVIDE

for

imported

caught

(X,Y:

function

INTEGER)

return

pragma

INTERFACE (PASCAL,DIVIDE):;

pragma

IMPORT FUNCTION (INTERNAL

Pascal

MODULE

body

for

the

Ada

will

raise

INTEGER;

DIVIDE,

PARAMETER TYPES
RESULT

that

SYSTEM.NON
ADA ERROR

TYPE

function

(INTEGER, INTEGER),

INTEGER):;

DIVIDE

Pascal Ops;

[GLOBAL]

FUNCTION

Divide

(X,Y:

INTEGER):

INTEGER;

BEGIN

Divide

DIV

END;

END.
T

——

Ada

—-

divide-by-zero with

with

procedure

that

calls

ve—

—

————

DIVIDE,

———

——

—

and

——

——————

catches

—

_—

—

o—

_—

—

SYSTEM.NON
ADA ERROR

SYSTEM;

with DIVIDE;
with

TEXT IO;

procedure
I,J:

use

TEXT IO;

CATCH
NON ADA

INTEGER;

begin
I

:=0;

1;
DIVIDE(J,TI):;

exception

when

SYSTEM.NON
ADA ERROR =>

PUT

LINE ("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:
BIT ARRAY

pragma

PACK(BIT ARRAY);

subtype
subtype
subtype
subtype

BIT
BIT
BIT
BIT

ARRAY
ARRAY
ARRAY
ARRAY

8
16
32
64

type UNSIGNED BYTE

is
is
is
is

BIT ARRAY
BIT_ARRAY
BIT_ARRAY
BIT_ARRAY

function "not"

use 8;

(LEFT

return

UNSIGNED_BYTE)

UNSIGNED BYTE)

UNSIGNED_ BYTE;

function "xor"
return

255;

UNSIGNED BYTE)

RIGHT

(LEFT,

of BOOLEAN;

7);
15);
31);
63);

return UNSIGNED BYTE;

function "or"

..
..
..
..

UNSIGNED BYTE)

RIGHT

(LEFT,

(0
(0
(0
(0

return UNSIGNED_ BYTE;

function "and"

is range 0

UNSIGNED BYTE’SIZE

for

(INTEGER range <>)

is array

type

RIGHT

(LEFT,

UNSIGNED_ BYTE;

8)
BIT_ARRAY

function TO UNSIGNED BYTE
return UNSIGNED BYTE;

UNSIGNED BYTE)

8
function TO BITARRAY
return BIT ARRAY 8;

D is
BYTE ARRAY
type UNSIGNE
array (INTEGER range <>) of UNSIGNED BYTE;

type UNSIGNED WORD
for

is range 0

UNSIGNED WORD’SIZE

function "not"

wuse

(LEFT

65535;

16;

UNSIGNED WORD)

UNSIGNED_ WORD)

UNSIGNED_WORD)

UNSIGNED WORD)

return UNSIGNED_ WORD;

function "and"

(LEFT,

RIGHT

return UNSIGNED WORD;

function "or"

(LEFT,

RIGHT

return UNSIGNED WORD;

function "xor"

(LEFT,

RIGHT

return UNSIGNED_WORD;

function TO UNSIGNED WORD

16)
BITARRAY

UNSIGNED_WORD)

return UNSIGNED WORD;

16
function TO BITARRAY

16;
return BITARRAY

type UNSIGNED
WORD ARRAY is
array (INTEGER range <>) of UNSIGNED WORD;

type UNSIGNED LONGWORD is range MIN_INT
for UNSIGNED LONGWORD’SIZE use 32;

13-35

MAX INT;

VAX Hardware-Oriented Types and Functions

13.7a.6

function

"not"TM

return

function

"and"

return

function
function

UNSIGNED LONGWORD)

(LEFT,

UNSIGNED LONGWORD)

RIGHT

LONGWORD;

(LEFT,

RIGHT

UNSIGNED LONGWORD;

end

(INTEGER

range

QUADWORD

<>)

BITARRAY
32)

UNSIGNED_ LONGWORD)

is
of

UNSIGNED

LONGWORD;

record

UNSIGNED LONGWORD;
UNSIGNED LONGWORD;

record;

for UNSIGNED QUADWORD’SIZE
function

"not"

return

function

function
function

function

(LEFT,

UNSIGNED

"xor"

return

UNSIGNED

QUADWORD)

RIGHT

UNSIGNED

QUADWORD)

RIGHT

UNSIGNED QUADWORD)

UNSIGNED

QUADWORD;

(LEFT,

UNSIGNED

RIGHT

function

return

function
return

(INTEGER

range

TOADDRESS

<>)

function
return

BIT ARRAY
64)

UNSIGNED QUADWORD)

is
of

UNSIGNED

QUADWORD;

INTEGER)

UNSIGNED LONGWORD)

universal integer)

ADDRESS;

TO ADDRESS
ADDRESS;

TO_ADDRESS
ADDRESS;

INTEGER

ADDRESS)

AST HANDLER)

INTEGER;

function TO UNSIGNED LONGWORD
return

BIT ARRAY
64;

UNSIGNED QUADWORD ARRAY

array

UNSIGNED QUADWORD;

TO BITARRAY
64

return

QUADWORD)

QUADWORD;

TO_UNSIGNED_ QUADWORD

return

64;

UNSIGNED QUADWORD;

"or"

return

use

(LEFT

UNSIGNED QUADWORD;

"and"

return

13.7a.6

BIT ARRAY
32;

UNSIGNED

UNSIGNED LONGWORD;

UNSIGNED LONGWORD ARRAY

array

type

RIGHT

TO_BIT ARRAY 32

return

type

UNSIGNED_LONGWORD)

TO_UNSIGNED_ LONGWORD

return

type

(LEFT,

UNSIGNED

"xor"

return

LONGWORD;

UNSIGNED_LONGWORD;

"or"

return

(LEFT

UNSIGNED

UNSIGNED LONGWORD;

TO_UNSIGNED_ LONGWORD
UNSIGNED

LONGWORD;

VAX Hardware-Oriented Types and Functions

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.3, universal_
integer type 3.5.4

13.7a.7

Conventional Names for Unsigned Longwords

UNSIGNED

subtype

UNSIGNED
5

LONGWORD

range

subtype

6
UNSIGNED

is UNSIGNED_ LONGWORD

range

subtype

7
UNSIGNED

UNSIGNED LONGWORD

range

subtype

UNSIGNED
8

UNSIGNED LONGWORD

range

subtype

UNSIGNED_9

is UNSIGNED LONGWORD

range

subtype

UNSIGNED
10

UNSIGNED LONGWORD

range

subtype

UNSIGNED
11

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
12

UNSIGNED

LONGWORD

range

subtype

13
UNSIGNED

UNSIGNED LONGWORD

range

subtype

UNSIGNED
14

is UNSIGNED LONGWORD

range

subtype

UNSIGNED
15

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
16

is UNSIGNED

LONGWORD

range

subtype

UNSIGNED
17

is UNSIGNED

LONGWORD

range

subtype

UNSIGNED
18

LONGWORD

range

subtype

UNSIGNED
19

is UNSIGNED LONGWORD

range

subtype

UNSIGNED_
20

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
21

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
22

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
23

UNSIGNED

LONGWORD

range

subtype

24
UNSIGNED

UNSIGNED LONGWORD

range

25
subtype UNSIGNED

is UNSIGNED LONGWORD

range

subtype

UNSIGNED
26

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
27

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
28

is UNSIGNED LONGWORD

range

subtype

UNSIGNED
29

LONGWORD

range

30
subtype UNSIGNED

is UNSIGNED LONGWORD

range

subtype

range

UNSIGNED
31

UNSIGNED

UNSIGNED LONGWORD

2k
*

2 * %
2 % *

2k
%
2k
%

Dk
%
2%
K

range

LONGWORD

~ ¢

UNSIGNED

il e

UNSIGNED
4

subtype

2%
%

- .

range

LONGWORD

UNSIGNED

d Wi 1|
(I

UNSIGNED
3

U
]

subtype

2k
*

range

Jo
T

range

UNSIGNED LONGWORD

UNSIGNED
2

UNSIGNED
1

subtype

OO0 O

subtype

OO OOO0OO0OO0ODOOOOOODODOOCOOCODO0O00O00O00O0o

The following VAX Ada declarations provide conventional (and convenient)
names for static subtypes of the predefined type UNSIGNED_LONGWORD:

2**10~-1;
2**11-1;
2**12-1;
2**13-1;

2%*14-1;
2*%%]15-1;
2**16-1;
2**17-1;
2**18-1;

2*%*19-1;
2**%20-1;

2*%*21-1;
2**x22-1;

2**%23-1;

2*%*24-1;
2*%*25-1;
2**26-1;

2**%27-1;
2**28-1;
2*x*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 (sometimes called a global literal) to be obtained:
function
return

IMPORT

VALUE

UNSIGNED

(SYMBOL

STRING)

LONGWORD;

If SYMBOL is a string literal of 31 or fewer characters, then the value of the
function is the value of the global symbol in the external environment. If

the symbol is not defined at link time, then the result is zero (the linker also
gives a diagnostic message). If the parameter is not a string literal, then the
result is undefined (currently zero).
Example:
CMS_CREATED

constant

CONDITION_ HANDLING.COND

VALUE

TYPE

IMPORT_VALUE("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_HANDLING is
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
procedure

procedure
procedure

13.7a.9

READ

(SOURCE

UNSIGNED BYTE)

(SOURCE

UNSIGNED WORD)

(SOURCE

UNSIGNED

UNSIGNED BYTE;

READ_REGISTER
UNSIGNED

READ

WORD;

LONGWORD)

UNSIGNED LONGWORD;
WRITE REGISTER(SOURCE

UNSIGNED BYTE;

TARGET

out

UNSIGNED

TARGET

out

WRITE

UNSIGNED BYTE);

WORD;

UNSIGNED WORD) ;

WRITE REGISTER(SOURCE

UNSIGNED LONGWORD;

TARGET

out

VAX Processor and Device Register Operations

UNSIGNED LONGWORD) ;

13-38

The READ _REGISTER functions return the value of a variable reference
(byte, word, or longword). The WRITE_REGISTER procedures load a
specified value or group of values into a specified target variable reference
(byte, word, or longword).

Each READ REGISTER and WRITE_REGISTER operation is performed
by a single machine instruction and is 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 use of the pragma SHARED is the
preferred method of doing so.
function

MFPR

(REG_NUMBER

INTEGER)

return UNSIGNED_ LONGWORD;

procedure MTPR

(REG NUMBER

SOURCE

:
:

INTEGER,
UNSIGNED LONGWORD) ;

The function MFPR is equivalent to the VAX Move From Process Register
instruction, and returns the current contents of the specified VAX internal
processor register. The procedure MTPR is equivalent to the VAX Move To
Process Register instruction, and moves a 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

VALUE

out

(BIT

OLD VALUE

out

OLD

procedure

type

SETINTERLOCKED

ALIGNED WORD

out

BOOLEAN;

BOOLEAN)
;

out

BOOLEAN;

BOOLEAN)
;

record
VALUE

SHORT

INTEGER;

end record;
for

ALIGNED WORD

use

record

mod

end record;
procedure

ADD INTERLOCKED

(ADDEND

AUGEND

SIGN

out

SHORT INTEGER;
out

ALIGNED_WORD;
INTEGER)
;

The procedure CLEAR_INTERLOCKED is equivalent to the VAX Branch

on Bit Clear and Clear Interlocked (BBCCI) instruction; the procedure
SET_INTERLOCKED is equivalent to the VAX Branch on Bit Set and Set

Interlocked (BBSSI) instruction; and the procedure ADD INTERLOCKED is
equivalent to the VAX Add Aligned Word Interlocked (ADAWI) instruction.

These instructions interlock memory accesses, and thus provide a means for
synchronizing access to shared memory across processors.

The CLEAR_INTERLOCKED and SET_INTERLOCKED procedures clear or
set a single bit and return the previous value of the bit.

The ADD_INTERLOCKED procedure adds two signed-word integers

(ADDEND and AUGEND). SIGN is assigned the integer result —1 if the
new value of AUGEND is negative; 0 if AUGEND is zero: +1 if AUGEND is
positive.

The type ALIGNED_WORD, used in the ADD_INTERLOCKED pro-

cedure, specifies a word-sized integer that is word-aligned (the type

STANDARD.SHORT_INTEGER is a word-sized integer that is byte-aligned).

type

INSQ STATUS

(OK_NOT

FIRST,

FAIL
NO LOCK,

type

REMQ_STATUS

(OK_NOT

EMPTY,

FAIL
NO LOCK,

procedure

13.7a.10

INSQHI

REMQHI

INSQTI

OK_EMPTY,

FAIL
WAS EMPTY) ;

(ITEM

ADDRESS;

HEADER

ADDRESS;

STATUS

out

INSQ

STATUS) ;

(HEADER

ADDRESS;

ITEM

out

ADDRESS;

STATUS

out

REMQ

(ITEM

ADDRESS;

HEADER

ADDRESS;

STATUS

out

INSQ STATUS) ;

VAX Interlocked-lnstruction Procedures

OKFIRST);

STATUS) ;

13—40

procedure REMQTI

(HEADER

ADDRESS;

ITEM

out

ADDRESS;

STATUS

out REMQ STATUS):;

The procedure INSQHI is 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
REMQHI is equivalent to the VAX Remove Entry from Queue at Head,
Interlocked instruction; and the procedure REMQTI is equivalent to the
Remove Entry from Queue at Tail, Interlocked instruction. The types INSQ_
STATUS and REMQ_STATUS are 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 and tail of a self-relative
queue. The address values of HEADER and ITEM must be quadwordaligned. The enumeration value assigned to STATUS gives the state of the
queue after the operation has been executed.
Note that the VAX INSQHI, REMQHI, INSQTI, and REMQTI instructions
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
1

A machine code insertion can be achieved by a call to a procedure whose
sequence of statements contains code statements.
code statement

::=

type mark’ recordaggregate;

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

1341

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 named by 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_CODE cannot be used for machine code

Insertions.
5

An implementation is allowed to impose further restrictions on the record
aggregates allowed in code statements. For example, it may require that

expressions contained in such aggregates be static expressions.
6

An implementation may provide machine-dependent pragmas specifying

register conventions and calling conventions. Such pragmas must be
documented in Appendix F.
VAX Ada does not provide machine-dependent pragmas specifying register
conventions; calling conventions are specified by the interface and importexport pragmas (see 13.9 and 13.9a).

Example:
M

MASK;

procedure

SET_MASK;

procedure

SET MASK

use

MACHINE

pragma

INLINE
(SET MASK);

CODE;

begin
SI

FORMAT’ (CODE

SSM,

-—

M’BASE

REG

and M’'DISP

—-—-

predefined

attributes

=>
are

M’BASE REG,

M'DISP);

implementation-specific

end;

References: allow 1.6, apply 10.1.1, comment 2.7, compilation unit 10.1, declar-

ative 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

Interface to Other Languages

13.9
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

(language name,

subprogram name);

must be given for each such subprogram; a subprogram name is allowed to
stand for several overloaded subprograms. This pragma is 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 pragma is 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.

This capability need not be provided by all implementations. An implementation may place restrictions on the allowable forms and places of
parameters and calls.

Use of this pragma in VAX Ada is interpreted as being equivalent to

supplying the body of the named subprogram or subprograms. Therefore,

the following rules apply:

e
e

If a subprogram body is given later for a subprogram named with a

pragma INTERFACE, the body is illegal.

If a pragma INTERFACE names a subprogram body, the pragma is
illegal.

If a duplicate pragma INTERFACE is given, the latter pragma is illegal.

In VAX Ada, if a name specified by a pragma INTERFACE is declared

by a renaming declaration, the pragma INTERFACE applies to the
subprogram only if the subprogram that has been renamed, the renaming
declaration, and the pragma all occur in the same declarative part or
package specification. The pragma is ignored if these conditions are not
satisfied.

21 See also Appendix G, AI-00180 and AI-00298.

1343

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 pragmas are described in
section 13.9a.1.1.

If a pragma INTERFACE is used without one of these import pragmas, a
default interpretation is used, as follows:
1.

The language name is ignored, so it may be any identifier that suggests
the language, source, or nature of the imported subprogram.

If the subprogram name applies to a single subprogram, then a default
import pragma is assumed as follows:

For a function, the default is
pragma

IMPORT_ FUNCTION

(function designator);

For a procedure, the default is
pragma

IMPORT_PROCEDURE

(procedure

identifier);

If the subprogram name applies to two or more subprograms, the

pragma applies to all of them. However, a warning is given if the
appropriate VAX Ada import pragmas are not given for all of the

subprograms.

Whether or not the pragma INTERFACE is used with an import pragma,
the subprogram name must be either an identifier or a string literal that

denotes an operator symbol.

Example:
package FORT LIB

function

function EXP
private

FLOAT)

return FLOAT;

FLOAT)

return FLOAT;

pragma

INTERFACE (FORTRAN,

SQRT):;

pragma

INTERFACE (FORTRAN,

EXP):

end

13.9

SQRT (X

FORT LIB;

Interface to Other Languages

13—44

In VAX Ada, this example is interpreted as follows: the pragma
INTERFACE specifies that the indicated routines SQRT and EXP are to

be imported and used as bodies for the Ada functions SQRT and EXP in the
package FORT_LIB.

R is
package CHOOSE
procedure P (X :
procedure P (X :

INTEGER);
FLOAT);

private

procedure R(X : FLOAT) renames P;
INTERFACE (PLI, R);

pragma

R;
end CHOOSE

In this example, the pragma INTERFACE indicates that the body for the
second procedure P 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 INTERFACE is not defined for generic subprograms.

The meaning of the subprogram name is 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 INTERFACE applies to the first
two procedures; it does not apply to the third because the declaration is not
visible at the place of the pragma. This same interpretation is made for
pragmas used to import and export subprograms (see 13.9a.1).
procedure P

(B:

;
BOOLEAN)

procedure P

(I:

INTEGER);

pragma

INTERFACE

procedure P

(F:

(NONADA,

P);

FLOAT);

If a pragma INTERFACE and a pragma INLINE are used together, the
pragma INLINE is 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-Ada entities. The
import pragmas allow an Ada program to refer to entities written in another

language; the export pragmas make Ada entities available to programs
written in other languages. The names of the pragmas indicate the kind of
entity involved:
*

The pragmas IMPORT_FUNCTION and EXPORT _FUNCTION apply to

(nongeneric) functions.

The pragmas

The pragmas IMPORT_OBJECT, EXPORT_OBJECT, and PSECT_

The pragmas IMPORT_EXCEPTION and EXPORT_EXCEPTION apply

IMPORT _PROCEDURE, IMPORT VALUED _
PROCEDURE, EXPORT_PROCEDURE, and EXPORT_VALUED_

PROCEDURE apply to (nongeneric) procedures.

OBJECT apply to objects.

to exceptions.

These pragmas are described in this section, summarized in Annex B, and
listed in Appendix F.

The form of all of the VAX Ada import and export pragmas is as follows:
pragma

import export pragma name

(internal name
[,

external designator]

pragma_specific

options]);

import_export
pragma name

::=

EXPORT

EXCEPTION

EXPORT FUNCTION

EXPORT

OBJECT

EXPORT PROCEDURE

EXPORT_VALUED

PROCEDURE

IMPORT

IMPORT FUNCTION

IMPORT OBJECT

IMPORT PROCEDURE

IMPORT VALUED PROCEDURE

PSECT

OBJECT

internal_name
|

:.=

[INTERNAL

=>]

operator symbol

[INTERNAL

external

EXCEPTION

designator

external_ symbol

::=

=>]

simple name

[EXTERNAL

identifier

Can

——

IMPORT FUNCTION

=>]

used

external

only

for

symbol

string literal

The internal name may be an Ada simple name, or, if the declared entity
is a function, the internal name may be a 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 name is used as the
external designator. If the external designator (explicit or default) is longer
than 31 characters, the import or export pragma is ignored.

Pragma-specific options are described in the individual pragma sections that
follow.

The VAX Ada import and export pragmas are 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 pragma is allowed for any given entity (in the case
of multiple overloaded subprograms, this rule applies to each subprogram
independently).

Additional placement and usage rules that apply to particular pragmas are
described in the individual pragma sections 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 assocliation, the parameters are
interpreted in the same order as they appear in the syntax definition. The
rules for the mixing of positional and named association 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 pragma for 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 checking is provided to assure that exported symbols do not conflict with
each other or with other global symbols; such checking is performed by the
VMS Linker.
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

1347

VAX Ada Import and Export Pragmas

13.9a

13.9a.1

Importing and Exporting Subprograms
VAX Ada provides a series of pragmas that make it possible to call (non-

generic) subprograms in a mixed-language programming environment. The
pragmas IMPORT_FUNCTION, IMPORT PROCEDURE, and IMPORT_

VALUED_PROCEDURE specify that the body of the subprogram as-

sociated 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

EXPORTVALUED_PROCEDURE allow an

Ada procedure or function to be called from another VAX language.
References: function 6.5, generic subprogram 12.1, pragma 2.8, procedure 6.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 PROCEDURE allow
an Ada program to call external (non-Ada) functions and procedures. The
pragma IMPORT_VALUED_PROCEDURE allows an Ada program to call 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 parameters is not legal in Ada). In other words, the pragma

IMPORT_VALUED_PROCEDURE allows a routine to be interpreted as a
procedure in the environment of an Ada program and as a function in the

external environment; the function result is returned in the first parameter.
This pragma is especially useful for calling VMS system services, which
return a status value but may also update their parameters. The pragma

IMPORT_VALUED_PROCEDURE is also useful for calling routines written
in other programming languages that permit such constructs.

The form of the pragmas for importing subprograms is as follows:
pragma

IMPORT FUNCTION

IMPORT_ PROCEDURE

(internal

name

IMPORT

external

VALUED

PROCEDURE

designator]

[PARAMETER TYPES

=>]

(parameter types)]

[RESULT TYPE

=>]

type mark]

[MECHANISM

=>]

mechanism]

[RESULT MECHANISM

=>]

mechanism name]

——

for

[FIRST

parameter types

13.9a.1.1

Importing Subprograms

IMPORT FUNCTION

only

OPTIONAL PARAMETER
::=

null

type

=>]

mark

identifier]);
type

mark}

13—48

mechanism

::=

mechanism name
mechanism
|
class

name

DESCRIPTOR
name

::=

(mechanism name

::= VALUE
[ ([CLASS
UBS

UBSB

mechanism name

})

REFERENCE

=>]
|

class—name)
]
UBA

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 name in the same declarative part or

package specification. Otherwise, both the parameter and result types must
be specified.
Procedures must be uniquely identified by their internal names and param-

eter types. The parameter types can be omitted only if there is exactly one
procedure of that name in the same declarative part or package specification.

Otherwise, the parameter types must be specified.

While the internal name can denote a subprogram renaming declaration,
the import pragma actually 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 name itself, the rules and requirements
for the use of these pragmas are given in terms of the base subprogram.
The external designator denotes a VMS Linker global symbol that is as-

sociated with the external subprogram. If no external designator is given,
the internal name is 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 mark is 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 names are 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 names given in
parentheses and separated by commas), each mechanism name determines
how the parameter in the same position 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 names and class names are described in
section 13.9a.1.2.

The first optional parameter option specifies the name of the first parameter

that can be omitted from the parameter list in a call to the imported sub-

program. This option is designed to be used with subprograms that allow
parameters to be omitted with a truncated argument list. 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 and all following
formal parameters, if any, of the base subprogram must be of mode in and

must have been specified with default expressions.
When this option is specified, the parameter list generated for the call to the

imported subprogram is truncated as follows:
*

Beginning at the end of the parameter list and working back toward

the beginning of the list, actual parameters are omitted—or truncated—

provided that the evaluation of each actual parameter has no side effects
(assignments to variables or input-output actions) and provided that one
of the following conditions is true:
—

The actual parameter is implicit; that is, it has been omitted in the

call to the subprogram, allowing the default expression to take effect.
—

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

13.9a.1.1

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
subprograms are as follows:

If an import pragma is 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 INTERFACE implies that a corresponding body is not given.

If a 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 _PROCEDURE must have at least one parameter, and the first
(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 pragma all occur
in that same declarative part or package specification. The pragma is
ignored if these conditions are not satisfied.

None of 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 SQRT

FLOAT)

pragma

INTERFACE

(VAXRTL,

pragma

IMPORT FUNCTION

return FLOAT;
SQRT);

(SQRT,

"MTHS$SSQRT",

(FLOAT),

FLOAT);

In this example, the pragma INTERFACE identifies SQRT as an external
subprogram; the language name argument VAXRTL has no effect. The
pragma IMPORT_FUNCTION uses positional 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 the result is of the type FLOAT. Because
no parameter or result passing mechanism is specified, default mechanisms
will be used.

13-51

Importing Subprograms

13.9a.1.1

function

SQRT

pragma

INTERFACE

pragma

IMPORT

LONG_FLOAT)

(VAXRTL,

FUNCTION

return

LONG FLOAT;

SQRT);

(INTERNAL

PARAMETER TYPES

SQRT,
(LONG_FLOAT),

RESULT TYPE

LONG_ FLOAT,

EXTERNAL

"MTH$SDSQRT")
;

This example shows an alternative way of importing the declared function
SQRT using named notation 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

SQRT

FLOAT)

function

SQRT

LONG _FLOAT)

(VAXRTL,

return FLOAT;
return

pragma

INTERFACE

pragma

IMPORT

FUNCTION

(SQRT,

pragma

IMPORT

FUNCTION

(INTERNAL

LONG FLOAT;

SQRT):;

"MTH$SSQRT",

(FLOAT),

FLOAT);

SQRT,

PARAMETER TYPES

(LONG_ FLOAT),

RESULT TYPE

LONG_FLOAT,

EXTERNAL

"MTHSDSQRT")
;

Again, the parameter and result passing mechanisms are not specified,

forcing the use of default mechanisms.
procedure

CHANGE

procedure

EXCHANGE

pragma

INTERFACE

pragma

IMPORT

(X,Y

INTEGER);

(PASCAL,

PROCEDURE

INTEGER)

renames

CHANGE;

EXCHANGE)
:;

(INTERNAL

EXCHANGE,

PARAMETER TYPES

(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

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, renam-

ing 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 Mechanisms for Parameters and Function Results

The import pragmas allow 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 names force the use of mechanisms defined in the VAX Procedure
Calling Standard, and they can be used to guarantee that the specified
mechanisms are used.
As shown in 13.9a.1.1, mechanism names have the following form:
mechanism name
|

DESCRIPTOR

::=

VALUE

[ ([CLASS

|
=>]

REFERENCE
class—name)
]

The names are 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
means a record type that does not have a variant part and in which any
constraint for each component and subcomponent is 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

subcomponent of the record type is static.

VALUE

Specifies that the immediate value of the actual parameter is
passed. Parameters of any type with a compile-time size of
up to 32 bits can be passed by VALUE; the associated 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).

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

When applied 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_PROCEDURE first 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. The associated 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.

DESCRIPTOR Specifies 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 the type.

The possible class names and their meanings follow.
Ada descriptor

class name

Corresponding VMS class
code

UBS

DSC$K_CLASS_UBS

Used for

an unaligned bit string whose
lower bound is equal to 1

UBSB

DSC$K_CLASS_UBSB

an unaligned bit string with
arbitrary bounds

UBA
S

DSC$K_CLASS_UBA

an unaligned bit array

DSC$K_CLASS_S

a scalar, access, or address
type, or a string whose lower

bound is 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 Ada types can be passed by each
mechanism, see the VAX Ada Run-Time Reference Manual. For information
on the VAX Procedure Calling Standard, see the Iniroduction 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_NOTES qualifiers in Developing
Ada Programs on VMS Systems.

13.9a.1.2

Controlling the Passing Mechanisms for Parameters and Function Results

13-54

Examples:
procedure

STRING);

pragma

INTERFACE (PASCAL,

P);

pragma

IMPORT

(P,

PROCEDURE

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

structs the compiler to pass the address of a VMS descriptor using descriptor

class DSC$K_CLASS
A.
type

BIT

pragma

STRING

PACK(BIT

function F

array

(1..32)

BOOLEAN;

STRING);

BIT

STRING)

pragma

INTERFACE

(C,

pragma

IMPORT FUNCTION

return

INTEGER;

F);
(INTERNAL

MECHANISM

RESULT

F,
VALUE,

MECHANISM

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

eter 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
argument list and to return the immediate value of the function result in a

TRNLNM

(

STATUS:

out

INTEGER;

ATTR

SYSTEM.UNSIGNED LONGWORD;

TABNAM:

LOGICAL
NAME TYPE;

LOGNAM:

LOGICAL
NAME TYPE;

ACMODE:

ITMLST:

ACCESS
MODE TYPE;
ITEM LIST TYPE);

pragma

INTERFACE

pragma

IMPORT

(SYSSERV,

VALUED

INTERNAL

TRNLNM,

EXTERNAL

"SYS$TRNLNM",

PARAMETER TYPES

(INTEGER,

LOGICAL
NAME TYPE,
MECHANISM

(VALUE,

(

SYSTEM.UNSIGNED LONGWORD,

ACCESS_MODE_TYPE,

LOGICAL
NAME TYPE,
ITEM LIST

TYPE),

REFERENCE,

DESCRIPTOR
(S),
REFERENCE,

13-55

TRNLNM)
;

PROCEDURE

DESCRIPTOR(S),

REFERENCE))
;

Controlling the Passing Mechanisms for Parameters and Function Results

13.9a.1.2

This example shows an Ada interface for the VMS system service routine

SYS$TRNLNM. Like most system services, SYS$TRNLNM returns a 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_PROCEDURE pragma causes the
STATUS parameter to be treated as both an out parameter (it has an actual
parameter) and a function result (if the VALUE mechanism is specified, the
result is returned in registers). Because the VALUE mechanism is specified
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 REFERENCE is the default mechanism for parameters of the type
INTEGER. Use of the REFERENCE mechanism would have caused the call
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 VMS routines (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 parameter is indicated by a “shortened”
argument list and/or by an argument list 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_PARAMETER allows the VMS
conventions for optional arguments in non-Ada routines to be used in calls
to imported subprograms.

For any type or subtype T:

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 argument list, independent of
the passing mechanism (explicit or default).
Example:
procedure

CRMPSC

(

STATUS:

out

COND VALUE TYPE;

INADR:

ADDRESS RANGE TYPE

:= ADDRESS RANGE
TYPE’
|
NULL PARAMETER;
in

ADDRESS

ACCESS MODE TYPE

ACCESS_MODE_ZERO;

FLAGS:

UNSIGNED_ LONGWORD

GSDNAM:

SECTIONNAME TYPE

IDENT:

SECTION

RETADR:

ACMODE:

ADDRESS ZERO;

:= SECTION_NAME TYPE NULL_ PARAMETER;
1=

ID TYPE

SECTION_ID_TYPE NULL_PARAMETER;

RELPAG:

UNSIGNED LONGWORD

:= 0;

CHAN:

CHANNEL TYPE

:= CHANNEL ZERO;

PAGCNT:

UNSIGNED LONGWORD

VBN:

UNSIGNED LONGWORD

FILE PROTECTION TYPE

PROT:

PFC:

:= FILE PROTECTION_
ZERO;

UNSIGNED LONGWORD

pragma

INTEREFACE

pragma

IMPORT VALUED

INTERNAL

0;
= 0;

(EXTERNAL

= 0);

CRMPSC)
;

PROCEDURE

(

CRMPSC,

EXTERNAL => "SYSSCRMPSC",
PARAMETER TYPES => (COND_VALUE TYPE,

ADDRESS RANGE_TYPE,

ADDRESS,

ACCESS MODE TYPE, UNSIGNEDLONGWORD, SECTION NAME_TYPE,
SECTION_ID“TYPE

UNSIGNED_LONGWORD,

UNSIGNED LONGWORD,
UNSIGNED

MECHANISM =>

FILE PROTECTION_
TYPE,

LONGWORD),

(VALUE,

REFERENCE,

DESCRIPTOR
(S), REFERENCE,
VALUE,

CHANNEL TYPE,

UNSIGNED_ LONGWORD,
VALUE,

VALUE,

VALUE)):;

This example is one of the interfaces declared in the VAX Ada package

STARLET for the VMS system service SYSSCRMPSC. Default values
are specified for all of the parameters except for the STATUS parameter
because all of the parameters to SYS$CRMPSC are optional. Note the use
of the VAX Ada attribute NULL_PARAMETER to 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 EXPORTVALUED_PROCEDURI

All three export pragmas establish an external name for a subprogram and
make the name available 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_PROCEDURE allow

the export of the kind of subprograms indicated. The pragma EXPORT
_
VALUED_PROCEDURE allows 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_PROCEDURE allows a procedure written in Ada to be
interpreted as a function in the external environment; the function result

is returned in the first parameter. The pragma is especially useful for
writing Ada subprograms that 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 subprograms is as follows:
pragma

EXPORT

FUNCTION

EXPORT_PROCEDURE

(internal

name

EXPORT VALUED

PROCEDURE

external designator]

[PARAMETER TYPES

=>]

(parameter types) ]

[RESULT TYPE

=>]

type mark]);

parameter_ types

::=

null

type

mark

—--

for EXPORT FUNCTION

-—

only

type

mark}

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 same declarative part or package specification.
Otherwise, the parameter types must be specified.
The external designator denotes a VMS Linker global symbol that is associated with the external subprogram. If no external name is given, the
internal name is used as the global symbol. If a null string is given, no
global symbol is defined.

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 mark is 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.
In addition to the rules given in section 13.9a, the rules for exporting
subprograms are as follows:

An exported subprogram must be a library unit or must be declared in
the outermost declarative part of a library package. Thus, pragmas for
exporting subprograms are 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 that is declared in the outermost declarations
of a package body that is a library unit.

Consequently, an export pragma for a subprogram body is allowed only
if either the body does not have a corresponding specification, or if the
specification and body occur in the same declarative part.
This set of rules implies that a pragma EXPORT_FUNCTION,
EXPORT_PROCEDURE, or EXPORT_VALUED_PROCEDURE cannot be given for a generic library subprogram, nor can one be given for a
subprogram declared in a generic library package. However, any of these
pragmas may be 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_PROCEDURE must have at least one parameter, and the first
(or only) parameter must be of mode out.

None of these pragmas can be used for a subprogram that is 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
pragma

PROC

EXPORT

INTEGER);

PROCEDURE

(PROC);

This example shows an export pragma that causes the Ada procedure

PROC to be exported for use in a non-Ada routine. The name PROC will be
declared as a VMS Linker global symbol.
procedure

MULTIPLY

out

in out

INTEGER;

INTEGER)

begin
X

10*Y;

end;
pragma

EXPORT

INTERNAL

VALUED

PARAMETER TYPES

PROGRAM

Call

PROCEDURE

(

MULTIPLY,

Ada

(INTEGER, INTEGER))

(INPUT,

OUTPUT);

VAR
A

INTEGER;

FUNCTION

Multiply

(VAR

INTEGER)

INTEGER;

EXTERN;

BEGIN
A

Multiply(A);

END.

This example shows an Ada procedure being used as a function in a Pascal
program. Because of the use of pragma EXPORT_VALUED_PROCEDURE,

the first parameter of the Ada procedure MULTIPLY is recognized as a func-

tion 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 name 6.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_OBJECT references storage declared in an external (non-Ada)
routine. The pragma EXPORT_OBJECT allows an external routine to refer
to the storage allocated for an Ada object. The pragma PSECT_OBJECT
allows both Ada and non-Ada programs to 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:

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:

—

A scalar type or subtype.

—

An array subtype with static index constraints whose component size
is static.

—

A record type or subtype that does not have a variant part and in
which any constraint for each component and subcomponent is static
(a simple record type or subtype).

Import and export pragmas are not allowed for objects declared with a

renaming declaration.

Import and export pragmas for 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 where the type is
declared (that is, where the full type is known).

The VAX Ada pragmas for importing or exporting objects can precede or
follow a pragma VOLATILE for the same objects (see 9.11).

Address clauses are not allowed in combination with any of the VAX Ada
pragmas for importing or exporting objects. If used in such cases, the
pragma involved is 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, sub¢omponent 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_OBJECT specifies 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 VMS Linker global symbol.
The form of this pragma is as follows:
pragma

IMPORT OBJECT

(internal
[,

name

[SIZE

=>]

external designator]

external symbol]);

The internal name is the object identifier. The external designator denotes a
VMS Linker global symbol that is associated with the external object. If no
external designator is given, the internal name is used as the global 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 some level 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:

(Cannot be a constant (have an explicit initial value).

Cannot be an access type (which has a default initial value of null).

(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

IMPORT OBJECT

(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

IMPORT OBJECT

(INTERNAL => PID,

EXTERNAL =>

"PROCESSS$ID",

=> PSIZE);

SIZE

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 OBJECT specifies that the storage allocated
for the object (when the Ada program is compiled) be made known to other
non-Ada programs by a VMS Linker global symbol.
The form of this pragma is as follows:
pragma

EXPORT_QBJECT

(internal name [, external designator]
[, [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 some level of link-time consistency checking. See the
VAX Ada Run-Time Reference Manual for more information.
Example:
PID:

INTEGER;

pragma EXPORT OBJECT

(PID,

"PROCESSSID");

Alternatively, this example can be written in named notation, as follows:
PID:

INTEGER;

pragma EXPORT OBJECT

(INTERNAL

EXTERNAL =>

PID,

"PROCESSS$ID");

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

Thus, the pragma PSECT _OBJECT is useful for referring to FORTRAN or
BASIC common blocks, external variables in PL/I, extern variables in C, or

a Pascal variable with the COMMON attribute.
The pragma PSECT_OBJECT allows only one object to be allocated in a

particular program section. As with imported objects, an object that is
specified with the pragma PSECT _OBJECT may not have an initial value

(see 13.9a.2.1).
The form of this pragma is as follows:
pragma

PSECT

(internal
[,

OBJECT

name

[SIZE

=>]

external designator]

external

symbol]);

The internal name must be an Ada identifier that denotes a variable. The
external designator names the program section, which can be either an
Ada identifier 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_OBJECT is used
for importing an object, the external designator refers to an existing (external) program section. If no external designator is provided, the internal
name 1s used as the name of 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 some level 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 corresponds to 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,

FLOAT;

end record;
XS

BLOCK;

pragma PSECT OBJECT

(XS);

This example of the pragma PSECT_OBJECT shows the allocation of the
record variable XS with three components (X1, X2, X3) of the type FLOAT in
the program section XS. The name of the program section is assumed to be
the internal name XS because no external designator is given.

The code in this example represents the same program section as the
following named FORTRAN common block:
COMMON

/XS/

X1,

X2,

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_
EXCEPTION for importing and exporting exceptions. The pragma IMPORT_
EXCEPTION allows non-Ada (especially VMS) exceptions to be used in Ada
programs; the pragma EXPORT_EXCEPTION allows 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 described in the following sections. Note
that import and export pragmas are not allowed for exceptions declared with
a renaming declaration.
Note:
A pragma for 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_EXCEPTION allows VAX conditions (for
example, from VMS system services or other VAX languages) to be propagated to Ada programs as Ada exceptions. This pragma specifies that the
exception associated with an exception declaration in an Ada program be

defined externally (in non-Ada code).
The form of this pragma is as follows:
pPragma

IMPORT

EXCEPTION

(internal_name

external designator]

[FORM =>]

ADA

[CODE

static integer expression]);

=>]

VMS]

The internal name must be an Ada identifier that denotes a declared ex-

ception. The external designator denotes a VMS Linker global symbol to be
used to refer to the exception. If no external designator is given, the internal
name is used as the global symbol.

The form option indicates whether an Ada exception or a VAX condition is
being imported. Thus, ADA must be 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 ADA is specified, then the external designator refers

to the address of an Ada exception name (the address of a counted ASCII
string that names the exception). If the exception form VMS is 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 VMS is 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).
VMS condition 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:

13.9a.3.1

ACCVIO

pragma

IMPORT_EXCEPTION

exception;

Importing Exceptions

(ACCVIO,

"SS$

ACCVIO");

13-66

In this example, the VAX condition SS$_ACCVIO is imported as the global
symbol SS$_ACCVIO. It is referred to within the Ada program by the
internal name ACCVIO, and the 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

EXxporting 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 name available to the
VMS Linker as a global symbol.
The form of this pragma is as follows:
pragma

EXPORT

(internal

EXCEPTION

name

external designator]

[FORM =>]

ADA

[CODE

static integer expression]);

=>]

VMS]

The internal name must be an Ada identifier that denotes a declared exception. The external designator denotes a VMS Linker 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 ADA is specified, then the external designator refers to the
address of an Ada exception name (the address of a counted ASCII string
that names the exception).

If the form VMS is specified, the code option must be specified. The value for
the code option must be in the range MIN_INT..MAX_INT, and is interpreted
as a standard VAX condition value. The external designator denotes a VMS
Linker global symbol for the condition value. If no external designator is

specified, the internal name is used as the global symbol.
VAX condition 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.

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

The EXPORT_EXCEPTION pragma is not allowed for exceptions that
are declared in a generic unit.

Example:
ACCVIO

pragma

EXPORT EXCEPTION

exception;
(ACCVIO,

"MY PACKAGES

ACCVIO",

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_DEALLOCATIOM

and UNCHECKED_CONVERSION are used for unchecked storage deallocation and for unchecked type conversions.
generic

type OBJECT is limited private;
type NAME
procedure

is access OBJECT;

UNCHECKED DEALLOCATION(X

out

NAME)
;

generic
type

SOURCE

limited private;

type

TARGET

limited private;

function

UNCHECKED_ CONVERSION(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 a call of a procedure that is obtained by
instantiation of the generic procedure UNCHECKED_DEALLOCATION.

For example:22
procedure FREE

is new UNCHECKED DEALLOCATION
(object type name,
access_type name);

22 See also Appendix G, AI-00355.
13.10.1

Unchecked Storage Deallocation

13-68

Such a FREE procedure has the following effect:

(a)

after executing FREE(X), the value of X is null,;

(b)

FREE(X), when X is already equal to null, has no effect;

(¢c)

FREEX), 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 consequence of the visibility rules that the generic procedure
UNCHECKED_DEALLOCATION is not visible in a compilation unit un-

less this generic grocedure is mentioned by a with clause that applies to the

compilation unit.?3

If X designates a task object, the call FREE(X) has no effect 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 subcomponent is a task
object.

Because UNCHECKED_DEALLOCATION is a predefined generic procedure,
VAX Ada does not allow the use of the IMPORT_PROCEDURE pragma to
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, procedure call 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 by a call of a function
that is obtained by instantiation of the generic function UNCHECKED_

CONVERSION
24

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 unchanged as the bit pattern defining
a value of the target type. An implementation may place 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_CONVERSION with

the following restrictions on the class of types involved:
¢

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 value resulting from a call of the conversion function resulting from an instantiation of

UNCHECKED_CONVERSION is 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 order bits of the value are ignored (truncated); if the size of
the source value is less than the size of the target subtype, then the value is
extended with zero bits to form the result value.

Whenever unchecked conversions are used, it is the programmer’s respon-

sibility to ensure that these conversions maintain the properties that are
guaranteed by the language for objects of the target type. Programs that

violate these properties by means of unchecked conversions are erroneous.

Note:
4

It is a consequence of the visibility rules that the generic function

UNCHECKED_CONVERSION is not visible in a compilation unit unless

this generic function is mentioned by a with clause that applies to the
compilation unit.
5

References: apply 10.1.1, compilation unit 10.1, erroneous 1.6, generic function
12.1, instantiation 12.3, 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

Input-Output

Input-output is provided in the language by means of 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 I0_EXCEPTIONS defines 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 10, VAX Ada
provides packages for relative and indexed access to files, as well as

packages for handling files 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_I0O_EXCEPTIONS, which defines the exceptions needed by the relative
and indexed input-output packages.

VAX Ada does not provide the package LOW_LEVEL_IO. Instead, the
library packages STARLET and TASKING_SERVICES are 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 appear in 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

EXxternal 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 external file is identified by a string

(the name). A second string (the form) gives further system-dependent
characteristics that may be associated with the file, such as the physical
organization or access rights. The conventions governing the interpretation

of such strings must be documented in Appendix F.!

The VAX Ada interpretation of form strings is also described in

section 14.1b.
2

Input and output operations are expressed as operations on objects of some
file type, rather than directly in terms of the external files. In the remainder

of this chapter, the term file is always used to 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 external files. The attributes of the external file, the storage

medium, and the input-output package determine which operations can be

used to manipulate data. VAX Ada also supports files 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

10EXCEPTIONS;

generic

type ELEMENT TYPE is private;

package SEQUENTIAL
IO is
type FILE TYPE is limited private;
type

FILE

MODE

(IN FILE,

procedure OPEN

(FILE

procedure READ

(FILE

in FILE TYPE;

ITEM

out

procedure WRITE (FILE

in FILE TYPE;

ITEM

in ELEMENT TYPE):;

end

OUT FILE);

in out FILE TYPE;

...);

ELEMENT TYPE):;

SEQUENTIAL
IO;

In order to define sequential input-output for a given element type, an
instantiation of this generic unit, with the given type as actual parameter,
must be declared. The resulting package contains the declaration of a file
type (called FILE_TYPE) for files of such elements, as well as the operations
applicable to these files, such as the OPEN, READ, and WRITE procedures.
Input-output for direct access files is likewise defined by a generic package
called DIRECT I0O. Input-output in human-readable form is defined by the
(nongeneric) package TEXT_IO.
In VAX Ada, input-output for sequential access files 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 indexed access to files 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 access to files is
defined by the generic package INDEXED_IO and the (nongeneric) package
INDEXED_MIXED_IO.

Before input or output operations can be performed on a 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 otherwise the file 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 corresponding files
have not been closed). The effect of input-output for access types is

implementation-dependent.2
In VAX Ada, input-output for access types is erroneous.
8

An open file has a current mode, which is a value of one of the enumeration
types
type

FILE MODE

(IN_FILE,

type

FILE

MODE

(IN_FILE,

INOUT FILE,

OUT_FILE);

for

DIRECT
IO

OUT FILE);

—--

for

SEQUENTIAL
IO

-—

and

TEXT_ IO

These values correspond respectively to the cases where only reading, both
reading and writing, or only writing are to be performed. The mode of a file

can be changed.
For the six additional VAX Ada input-output packages, an open file’s current

mode may be one of the following values:
type

FILE

MODE

(IN_FILE,

type

FILE

(IN

MODE

FILE,

INOUT_FILE,

OUT _FILE);

for

——

DIRECT MIXED IO,

RELATIVE
IO,

-—

RELATIVE MIXED IO,

-—

INDEXED

——

INDEXED_ MIXED IO

IO,

and

—-—

for

OUT FILE);

SEQUENTIAL MIXED IO

Several file management operations are common to 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, AT-00466.
14.1

External Files and File Objects

144

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

All of the VAX Ada input-output packages use the package IO_EXCEPTIONS;
the VAX Ada packages RELATIVE_IO, INDEXED_IO, RELATIVE_MIXED_
10, 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_
10 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
IO declares a different type FILE_TYPE; in the case of
and INDEXED
SEQUENTIAL_MIXED_IO, DIRECT_MIXED_IO, RELATIVE_MIXED_
10, and INDEXED_MIXED_IO, the type FILE_TYPE is declared by the
(nongeneric) package.

A bidirectional device can often be modeled as two sequential files associated
with the device, one of mode IN_FILE, and one of mode OUT_FILE. An
implementation may restrict the number of files that may be associated with
a given external file. The effect of sharing an external file in this way by
several file objects is implementation-dependent.?
VAX Ada permits the sharing of external files, and, in addition, uses the
VMS RMS automatic locking facility to provide record-locking capabilities.
In other words, when an external file is opened in more than one place, the
operations are automatically coordinated. Record locking ensures that one
task cannot add, delete, or modify a record of an external file that 1s concurrently being accessed by another task. (Record locking also coordinates

accesses between programs that are executing as separate VMS processes,
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

142

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.3, 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.1a 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 of file
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 element of the file are written to a record of the external file. In VAX
Ada, each external file record corresponds to a VMS RMS record.
For files containing values of mixed types, an element may represent a

single value (just as an element in a 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 a 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-type files.
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 terms of lines and in terms of 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 more detail.

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, and all 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 be a 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).

FDL is a special-purpose VMS language for 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
parameter is not necessary: it is never necessary in an OPEN procedure; it
may be necessary in a CREATE procedure. The packages for which a value
for the FORM parameter must be specified in a CREATE procedure are as
follows:

The packages DIRECT_IO and RELATIVE_IO require that a maximum
record size be specified in the FORM parameter if the item with which
the package is 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
1

Two kinds of access to external files are defined: sequential access and
direct access. The corresponding file types and the associated operations are
provided by the generic packages SEQUENTIAL_IO and DIRECT I0. A file
object to be used for sequential access is called a sequential file, and one to
be used for direct access is called a direct file.

In VAX Ada, sequential and direct access are also provided in the predefined
(nongeneric) packages SEQUENTIAL_MIXED_IO and DIRECT_MIXED_IO,
which allow values of different types to be mixed in a file. The operations
provided by these packages are described in section 14.2b.
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). When the file is opened, transfer starts from the
beginning of the file.

For direct access, the file is viewed as a set of elements occupying consecutive positions in linear order; a value can be transferred to or from an

element of the file at any selected position. The position of an element
is specified by its index, which is a number, greater than zero, of the

implementation-defined integer type COUNT. The first element, if any, has
index one; the index of the last element, if any, is called the current size; the
current size is zero if there are no elements. The current size is a property

of the external file.

In VAX Ada, the integer type COUNT is range 0.INTEGER’LAST.

An open direct file has a current index, which is the index that will be used

by the next read or write operation. When a direct file is opened, the current
index is set to one. The current index of a direct file is a property of a file

object, not of an external file.

All three file modes are allowed for direct files. The only allowed modes for
sequential files are the modes IN_FILE and OUT_FILE.

References : count type 14.3, file mode 14.1, in_file 14.1, out_file 14.1
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.1a, 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 inputoutput, the procedures CREATE, OPEN, and RESET have additional effects
described in section 14.3.1.
procedure CREATE (FILE
MODE

NAME
FORM

in out FILE TYPE;
:= default mode;

in FILE MODE
in STRING :=

"";

"");

STRING

Establishes a new external file, with the given name and form,
and associates this external file with the given file. The given file
is left open. The current mode of the given file is set to the given
access mode. The default access mode is the mode OUT_FILE for
sequential and text input-output; it is the mode INOUT_FILE for
direct input-output. For direct access, the size of the created file
is implementation-dependent. A null string for NAME specifies an
external file that is not accessible after the completion of the main
program (a temporary file). A null string for FORM specifies the use

of the default options of the implementation for the external file.d

In VAX Ada, NAME overrides the name given in FORM. If NAME is
null, a temporary file is created that is not accessible after the file is

closed.® Any name specified in FORM is ignored.

For direct files, the size of a file that has just been created is zero.

The exception STATUS_ERROR is raised if the given file is already
open. The exception NAME_ERROR is raised if the string given
as NAME does not allow the identification of an external file. The
exception USE_ERROR is 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.”

In VAX Ada, the exception USE_ERROR is raised if the mode is
IN_FILE. The exception USE_ERROR is also 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

MODE

in FILE

FILE

TYPE;

MODE;

NAME

STRING;

FORM

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 given file is left open.
The exception STATUS_ERROR is raised if the given file is already

open. The exception NAME_ERROR is raised if the string given
as NAME does not 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_ERROR is raised 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 form.8
procedure

CLOSE(FILE

in out

FILE TYPE) ;

Severs the association between the given file and its associated
external file. The given file is left closed.®
The exception STATUS_ERROR is raised if the given file is not open.
11

procedure

DELETE (FILE

in out

FILE

TYPE);

Deletes the external file associated with the given file. The given file
is closed, and the external file ceases to exist.

The exception STATUS_ERROR is raised if the given file is not open.
The exception USE_ERROR is raised if (as fully defined in Appendix
F) deletion of the external file is not supported by the environment.
procedure RESET(FILE

in out

FILE

procedure

in out

FILE TYPE);

RESET(FILE

TYPE;

MODE

in FILE MODE) ;

Resets the given file so that reading from or writing to its elements
can be restarted from the beginning of the file; in particular, for
direct access this means that the current index is set to one. If a

MODE parameter is supplied, the current mode of the given file is

set to the given mode. 10

8 See also Appendix G, AT-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_ERROR is raised if the file is not open. The
exception USE_ERROR is raised 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 FILE TYPE)

return

FILE MODE;

Returns the current mode of the given file.

The exception STATUS_ERROR is raised if the file is not open.

function NAME (FILE

in FILE TYPE)

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 correspond to a full specification of the name.
22

The exception STATUS_ERROR is raised if the given file is not
open.

In VAX Ada, the exception USE_ERROR is raised if the file has no

name.12
23

function FORM(FILE

in FILE

TYPE)

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 correspond to 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

The exception STATUS_ERROR is raised if the given file is not open.
function

IS OPEN(FILE

in FILE

TYPE)

return

BOOLEAN;

Returns TRUE if the file 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
1

The operatlolns available for sequential input and output are describedin
this section.””
The exception STATUS_ERRORis raised if any of these
operationsis attempted for a file thatis 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 FILE TYPE;

ITEM

out ELEMENT TYPE);

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_ERROR is raised if the mode is not IN_FILE.
The exception END_ERROR is raised if no more elements can be

read from the given file. The exception DATA_ERROR is 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 FILE TYPE;

ITEM

in ELEMENT TYPE);

Operates on a file of mode OUT_FILE. Writes the value of ITEM to
the given file.

The exception MODE_ERROR is raised if the mode is not OUT_
FILE. The exception USE_ERROR is raised if the capacity of the
external file is exceeded.
function END OF FILE(FILE

in FILE TYPE)

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_ERROR is raised if the mode is not IN_FILE.

13 See also Appendix G, AI-00320.

14.2.2

Sequential Input-Output

14-12

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

14.2.3

Specification of the Package Sequential
10
1

with

IOEXCEPTIONS;

generic
type
package

ELEMENT TYPE

type

FILE

TYPE

limited private;

type

FILE

MODE

(IN FILE,

-—

OUT FILE);

File management

procedure

CREATE (FILE

procedure

OPEN

in out

FILE TYPE;

MODE

in FILE

NAME

STRING

MODE
:=

"";

F'ORM

STRING

"");

(FILE

in out

MODE

in FILE MODE;

OUT FILE;

FILE TYPE;

NAME

STRING;

FORM :

STRING

(FILE

in out FILE TYPE);

"");

procedure

DELETE (FILE

in out

FILE TYPE);

procedure

RESET

(FILE

in out

FILE TYPE;

MODE

procedure

RESET

(FILE

in out

function MODE

(FILE

function NAME

(FILE

in FILE TYPE)

return STRING;

function FORM

(FILE

in FILE TYPE)

return STRING;

TYPE)

return BOOLEAN;

function

IS OPEN(FILE

——

and output

Input

FILE MODE) ;
FILE TYPE);

FILE

TYPE)

FILE

return FILE MODE;

operations

procedure

READ

(FILE

FILE

TYPE;

ITEM

out

procedure

WRITE

(FILE

FILE

TYPE;

ITEM

function
--

END OF FILE (FILE

FILE

TYPE)

ELEMENT TYPE) ;
ELEMENT TYPE) ;

return BOOLEAN;

Exceptions

STATUS

ERROR : exception

MODE ERROR

14-13

is private;

SEQUENTIAL
IO

exception

renames

I0EXCEPTIONS.STATUS
ERROR;

renames

I0_EXCEPTIONS.MODE_ERROR;

NAME ERROR

exception

renames

I0EXCEPTIONS.NAME
ERROR;

USE_ERROR

exception

renames

I0EXCEPTIONS.USE
ERROR;

DEVICE ERROR

exception

renames

IO_EXCEPTIONS.DEVICE
ERROR;

END ERROR

exception

renames

I0_EXCEPTIONS.END
ERROR;

DATA ERROR

exception

renames

IOEXCEPTIONS.DATA
ERROR;

Specification of the Package Sequential_IO

14.2.3

private

——
end

implementation-dependent

SEQUENTIAL
IO;

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, file_mode 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_ERROR is 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

in FILE TYPE;

ITEM

out

ELEMENT TYPE;

FROM

POSITIVE COUNT);

procedure READ (FILE

in FILE

TYPE;

ITEM

out

ELEMENT TYPE);

Operates on a file of mode IN_FILE or INOUT_FILE. In the case of

the first form, sets the current index of the given file to the index

value given by the parameter FROM. Then (for both forms) returns,
in the parameter ITEM, the value of the element whose position
in the given file is specified by the current index of the file; finally,
increases the current index by one.

The exception MODE_ERROR is raised if the mode of the given file
is OUT_FILE. The exception END_ERROR is raised if the index to
be used exceeds the size of the external file. The exception DATA_
ERROR is 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

FILE TYPE;

ITEM

ELEMENT TYPE;

POSITIVE COUNT) ;

FILE

procedure WRITE(FILE

TYPE;

ITEM

ELEMENT TYPE);

Operates on a file of mode INOUT_FILE or OUT _FILE. In the case
of the first form, sets the index of the given file to the index value
given by the parameter TO. Then (for both forms) gives the value

of the parameter ITEM to the element whose position in the given
file is specified by the current index of the file; finally, increases the
current index by one.
The exception MODE_ERROR is raised if the mode of the given file
is IN_FILE. The exception USE_ERROR is raised if the capacity of

the external file is exceeded.
procedure

SETINDEX(FILE

in FILE TYPE;

in POSITIVE

COUNT);

Operates on a file of any mode. Sets the current index of the given
file to the given index value (which may exceed the current size of

the file).
function
1

INDEX(FILE

FILE_TYPE)

return POSITIVE COUNT;

Operates on a file of any mode. Returns the current index of the
given file.

function

SIZE(FILE

in FILE

TYPE)

return

COUNT;

Operates on a file of any mode. Returns the current size of the
external file that is associated with the given file.
In VAX Ada, returns the number of elements (VMS RMS records)

in the file. This value is obtained from the external file when an

existing file is opened. The value is updated whenever the index of a
WRITE operation to the file exceeds the current size. Therefore, the

size of the file is always equal to the highest index number that has

been written to the file.
14

function END

OF FILE(FILE

in FILE

TYPE)

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_ERROR is raised if the mode of the given file

is OUT_FILE.

14—-15

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 RMS record 14.1a

14.2.5

Specification of the Package Direct_IO
1

with

IOEXCEPTIONS;

generic

type ELEMENT TYPE

is private;

package DIRECT
IO is

type FILE TYPE is limited private;
type
type

FILE MODE is (IN FILE, INOUT FILE, OUT FILE);
COUNT
is range 0 .. implementation defined;

subtype POSITIVE COUNT is COUNT range

COUNT'LAST;

—— File management
procedure

in out FILE_TYPE;

CREATE (FILE

MODE

-— NOTE:

FILE

INOUT FILE;

in STRING

"";

FORM

"");

If ELEMENT TYPE

STRING

an unconstrained type,

(element)

size must be specified

—— in the FORM parameter of the

CREATE procedure.

in out FILE TYPE;

(FILE
MODE

NAME

in STRING;

FILE MODE;

FORM

STRING

"");

(FILE

in out FILE_TYPE);

procedure DELETE (FILE

in out

procedure RESET

(FILE

in out FILE TYPE;

MODE

procedure

(FILE

in out FILE TYPE);

procedure

RESET

FILE TYPE);

FILE MODE);

function MODE

(FILE

in FILE_TYPE)

return FILE MODE;

function NAME

(FILE

in FILE _TYPE)

return STRING;

function FORM

(FILE

in FILE TYPE)

return STRING;

return BOOLEAN;

function

—-—

14.2.5

-- a maximum record
procedure OPEN

MODE

NAME

IS OPEN(FILE

Input and output

FILE TYPE)

operations

Specification of the Package Direct_|O

14-16

procedure

READ

procedure READ

(FILE

in FILE TYPE;

ITEM

out

FROM

POSITIVE COUNT) ;

ELEMENT TYPE;

(FILE

in FILE TYPE;

ITEM

out

ELEMENT TYPE);

procedure WRITE(FILE

in FILE TYPE;

ITEM

POSITIVE COUNT);

procedure

WRITE (FILE

in FILE TYPE;

ITEM

in ELEMENT TYPE);

SETINDEX(FILE

TO
function

INDEX(FILE

function SIZE
function

ELEMENT TYPE;

(FILE

in FILE TYPE;

in POSITIVE COUNT) ;

in FILE TYPE)

return POSITIVE COUNT;

in FILE

return COUNT;

END OF FILE(FILE

TYPE)

in FILE

TYPE)

return BOOLEAN;

—— Exceptions
STATUS_ERROR

exception

MODE__ERROR

exception renames

renames

IOEXCEPTIONS.STATUS
ERROR;

IO_EXCEPTIONS.MODE
ERROR;

NAME ERROR

exception

renames

IOEXCEPTIONS.NAME
ERROR;

USE_ERROR

exception

renames

IO_EXCEPTIONS.USE
ERROR;

DEVICE_ERROR

exception renames

IOEXCEPTIONS.DEVICE
ERROR;

END ERROR

exception

renames

IOEXCEPTIONS.END
ERROR;

DATA ERROR

exception

renames

IOEXCEPTIONS.DATA
ERROR;

private
——

implementation-dependent

end DIRECT IO;

References close 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, file_mode 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 defines relative
access and indexed access. The corresponding file 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 access is called a

relative file; a file object to be used for indexed access is 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
values of 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 number of 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 direct file, an open relative
file has a current index, which is the index that will be used by the next read
or write operation. When a relative file is opened, the current index is set
to one. The current index of a relative file is a property of a file object, not
of an external file. Also, the concept of size does not apply to relative files:
end-of-file is true if all remaining elements, starting at the current index,
are empty.

For indexed access, the file is viewed as a set of elements that are ordered
by predefined keys. Each key has a number (a nonnegative integer) and a
value. When the file is created, the keys of an element are defined in the
form string to correspond to fields 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. When a file is read, the
element fields 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

(EQUAL NEXT,

EQUAL,

NEXT):;

The value EQUAL_NEXT corresponds 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 corresponds to 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 the file, they are retrieved in the order in which
they are written to the file.

14.2a

Relative and Indexed Files

14-18

An open indexed file has a next element, which is the first element of the
primary key when the file 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 indexed files: end-of-file is true if no more elements,
starting at the next element in the file, 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
element is said to be defined after a successful READ, READ_EXISTING,
BY KEY, or END OF_FILE operation (if END_OF_FILE results in
READ
the reading of the next element of the file). The current element is 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 indexed files.

Depending on the sharing and access attributes specified in their form
strings, relative and indexed files may be write shared. Thus, element (VMS
RMS record) locking is automatically provided for the packages RELATIVE_
I0 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 the file 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.1a, 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 same as those for 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 CREATE procedure if the package
is instantiated with an unconstrained element type.
procedure

CREATE(FILE

in out

MODE

FILE

NAME

STRING

"";

FORM

STRING

"");

——

Example:

——

procedure

FILE TYPE;
MODE

CREATE (FILE

MY FILE;

FORM

"RECORD;"

INOUT FILE;

"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 package is instantiated with an unconstrained element type,
a maximum external record size must be specified.
procedure

CREATE (FILE

in out

MODE

FILE

NAME

STRING

FORM

STRING)
;

-—

Example:

——

procedure

CREATE (FILE

FILE

MODE

TYPE;

INOUT FILE;

"";

FILE;
FORM

"KEY

O;"

"LENGTH

5;"

"POSITION

O;"

"TYPE

STRING;
") ;

Also for the package INDEXED_IO, the RESET procedures have a parame-

ter for specifying the key number at which the file is to be reset. The default
value for KEY_NUMBER is 0, which designates the primary key.

14.2a.1

File Management

14-20

procedure

RESET

procedure RESET

(FILE

FILE TYPE;

MODE

FILE MODE;

KEY NUMBER

in INTEGER

(FILE

KEY NUMBER

in INTEGER

:= 0);

FILE TYPE;

:= 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_ERROR is raised 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 relative input and output.
procedure READ (FILE

FILE_TYPE;

ITEM

out

ELEMENT

FROM

POSITIVE COUNT) ;

TYPE;

procedure READ (FILE

FILE TYPE;

ITEM

out

ELEMENT TYPE);

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_ERROR is raised if the current mode is OUT_
FILE. The exception LOCK_ERROR is raised if the element to be
read is locked; this error is possible only if the external file is being
shared. The exception EXISTENCE_ERROR is raised if the element
does not exist (that is, the given cell is empty or the current index is
beyond the end of the file).

14-21

Relative Input-Output

14.2a.2

procedure

READ EXISTING(FILE

FILE

ITEM

out

ELEMENT TYPE;

POSITIVE COUNT) ;

TYPE;

FROM

procedure READ EXISTING(FILE

FILE

ITEM

out

ELEMENT TYPE);

TYPE;

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_ERROR is raised if the mode of the given file
1s OUT_FILE. The exception LOCK_ERROR is raised if the element

found is locked; this error is possible only if the external file is being

shared. The exception EXISTENCE_ERROR is raised if the current
index is beyond the end of the file, or if the end of the file is reached
before an existing element (a nonempty cell) is found.
procedure

WRITE(FILE

in FILE

in POSITIVE COUNT);

TYPE;

ITEM : in ELEMENT TYPE;
TO
procedure WRITE (FILE

in FILE TYPE;

ITEM

ELEMENT TYPE);

The exception MODE_ERROR is raised if the mode of the given file
is IN_FILE. The exception USE_ERROR is raised if the element

position in the file has already been written.
procedure

UPDATE (FILE

in FILE_TYPE;

ITEM

ELEMENT TYPE);

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_ERROR is raised if the current mode is not

INOUT_FILE. The exception USE_ERROR is 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 FILE TYPE);

Operates on a file of any mode. After this operation, the current
element is undefined.
procedure DELETE ELEMENT(FILE

in FILE TYPE);,

Operates on a file of mode INOUT_FILE. Deletes the current
element in the file.

The exception MODE_ERROR is raised if the current mode is not
INOUT _FILE. The exception USE_ERROR is raised if the current
element is undefined at the start of this operation.
procedure SET INDEX(FILE

in FILE TYPE;

in POSITIVE COUNT) ;

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 FILE TYPE)

return POSITIVE_ COUNT;

Operates on a file of any mode. Returns the current index of the
given file.
function END OF FILE(FILE

in FILE TYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT_FILE. Returns
TRUE if no cell, starting at the current index, contains an element;
otherwise returns FALSE.

The exception MODE_ERROR is raised 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
IO
with

IO EXCEPTIONS;

with

AUX

IOEXCEPTIONS;

generic

type

ELEMENT TYPE

package RELATIVE
IO

is private;

type

FILE TYPE

type

COUNT

is range

4is

range

type

FILE MODE

subtype POSITIVE COUNT

14-23

limited private;

(IN FILE,

COUNT

INOUT FILE,

OUT_FILE);

INTEGER’LAST;
1

COUNT'LAST;

Specification of the Package Relative_|IO

14.2a.3

-—- File management
procedure

CREATE (FILE

——

NOTE:

——

a maximum

——

in the

in out

in FILE

NAME

in STRING

«—
d

T,
’

FORM

un);

ELEMENT TYPE

record

INOUT FILE;

unconstrained

size

of the

must

in out FILE TYPE;
in FILE MODE;

NAME

in STRING;

FORM

DELETE (FILE

(FILE

procedure

RESET

type,

specified

CREATE procedure.

MODE

procedure

STRING

in out

"");

FILE TYPE);

in out

FILE TYPE);
FILE TYPE;

(FILE

in out

MODE

in FILE MODE):;

(FILE

in out

FILE TYPE);

function MODE

(FILE

in FILE_TYPE)

return FILE MODE;

function NAME

(FILE

in FILE

return

function FORM

(FILE

in FILE TYPE)

return STRING;

in FILE TYPE)

return BOOLEAN;

function

IS OPEN (FILE

—--

and

Input

procedure

output

READ

procedure

TYPE)

(FILE

ITEM

: out

FROM

(FILE
:

FILE

TYPE;

ELEMENT

TYPE;

POSITIVE COUNT) ;

FILE TYPE;

out

ELEMENT

TYPE);

READ EXISTING(FILE

FILE TYPE;

ITEM

out

ELEMENT TYPE;

POSITIVE COUNT);

FROM

READ EXISTING(FILE

FILE TYPE;

ITEM

out

ELEMENT

WRITE

(FILE

FILE TYPE;

ITEM

ELEMENT TYPE;

in POSITIVE COUNT) ;

(FILE

in FILE TYPE;

ITEM

in ELEMENT TYPE);

UPDATE (FILE

in FILE TYPE;

ITEM

in ELEMENT TYPE);

procedure UNLOCK (FILE

in FILE TYPE);

procedure DELETE ELEMENT (FILE
procedure

STRING;

operations

ITEM

SET_INDEX(FILE
TO

14.2a.3

(FILE

procedure

procedure RESET

MODE

STRING

(element)

FORM parameter

procedure OPEN

FILE TYPE;

MODE

Specification of the Package Relative
|O

TYPE);

FILE TYPE);

in FILE TYPE;

in POSITIVE COUNT) ;

14-24

function INDEX(FILE

in FILE TYPE)

function END OF FILE (FILE

return POSITIVE_COUNT;

in FILE TYPE)

return BOOLEAN;

—— Exceptions

STATUS ERROR
MODE ERROR
NAME ERROR
USE_ERROR
DEVICE ERROR
END ERROR
DATA ERROR
LOCK_ERROR

:
:
:
:
:
:
:
:

exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames

EXISTENCE ERROR : exception

IOEXCEPTIONS.STATUS_ERROR;
ERROR;
IOEXCEPTIONS.MODE
ERROR;
IOEXCEPTIONS.NAME
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICE_ERROR;
ERROR;
IOEXCEPTIONS.END_
ERROR;
IOEXCEPTIONS.DATA
AUX IOEXCEPTIONS.LOCK_ERROR;

ERROR;
renames AUX IOEXCEPTIONS.EXISTENCE_

private

—-—

implementation-dependent

end RELATIVE IO;

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 described in this
section. The exception STATUS_ERROR is raised 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_KEY procedure,
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. The range of values for DEFAULT_
KEY NUMBER is 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_KEY procedure is specified,
it must have a value of EQUAL_NEXT, EQUAL, or NEXT (the default is

EQUAL).

procedure

READ

(FILE

FILE

TYPE;

ITEM

out

ELEMENT TYPE);

generic
type

KEY

TYPE

is private;

DEFAUL
KEY NUMBER
T

procedure

INTEGER

READ
BY KEY (FILE

FILE TYPE;

ITEM

out

ELEMENT TYPE;

KEY TYPE;

INTEGER

KEY
KEY

NUMBER

DEFAUL
KEY NUMBER;
T

RELATION

RELATION TYPE

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 and relation 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_NUMBER designates 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 and relation

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_ERROR is raised if the current mode is OUT_

FILE. The exception END_ERROR is raised if an attempt is made to
read past the end of the file by the first form. The exception LOCK_

ERROR is raised if the element to be read is locked; this error is
possible only if the external file is being shared. The exception
EXISTENCE_ERROR is raised if the element does not exist. The
exception KEY_ERROR is raised if the size of the given key is not a

multiple of eight bits.
procedure WRITE(FILE

in FILE TYPE;

ITEM

in ELEMENT TYPE) ;

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_ERROR is raised if the current mode is
IN_FILE. The exception USE_ERROR is raised if the element
position in the file has already been written. The exception KEY_
ERROR is raised if a key has been duplicated and if duplicates are
not allowed by the external file.

procedure UPDATE(FILE

in FILE TYPE;

ITEM :

in ELEMENT TYPE) ;

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_ERROR is raised if the current mode is not
INOUT FILE. The exception USE_ERROR is raised 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_ERROR is 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 FILE TYPE);

Operates on a file of any mode. After this operation, the current
element is undefined.
procedure DELETE ELEMENT (FILE

in FILE TYPE);

Operates on a file of mode INOUT_FILE. Deletes the current
element of the file.

The exception MODE_ERROR is raised if the current mode is not
INOUT _FILE. The exception USE_ERROR is raised if the current
element is undefined at the start of this operation.
function END OF FILE(FILE

in FILE TYPE)

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 element in the file;
otherwise returns FALSE.

The exception MODE_ERROR is raised 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
IO
with

IOEXCEPTIONS;

with AUX IOEXCEPTIONS;
generic
type

package

ELEMENT TYPE is private;
INDEXED
IO

type

FILE

TYPE

limited private;

type

FILE_MODE

(IN_FILE,

type

RELATION_TYPE

function

GREATER

renames

function

File

(EQUAL NEXT,

OUT FILE);

EQUAL,

NEXT);

return RELATION TYPE

NEXT;

GREATER EQUAL

renames

——

INOUT FILE,

EQUAL

return

RELATION TYPE

NEXT;

management

procedure

CREATE (FILE

out

FILE

TYPE;

MODE : in FILE MODE := INOUT FILE;
NAME

STRING

FORM

STRING);

——

NOTE:

——

the

——

ELEMENT TYPE

——

maximum

All

procedure

information

FORM parameter
record

OPEN

keys

CREATE

size

must

(FILE

out

MODE

FILE MODE;

NAME

STRING;

FORM

STRING

(FILE

procedure

DELETE(FILE

procedure

RESET

must

provided

type,

alsq

specified.

FILE TYPE;

in out
in out

"V);

FILE TYPE);
FILE TYPE);

in FILE

TYPE;

MODE

FILE

MODE;

INTEGER

NUMBER

procedure.

(FILE
KEY

RESET

the

"";

unconstrained

(element)

procedure

(FILE

in FILE

KEY NUMBER

0);

TYPE;

INTEGER

0);

function MODE

(FILE

in FILE TYPE)

return

function NAME

FILE_ MODE;

(FILE

function FORM

in FILE

return

(FILE

STRING;

in FILE:TYPE)

return STRING;

function

IS OPEN(FILE

in FILE TYPE)

return BOOLEAN;

——

and

Input

procedure

14.2a.5

about

output

READ

TYPE)

operations

(FILE

ITEM

out

Specification of the Package Indexed_|O

FILE

TYPE;

ELEMENT

TYPE);

14-28

generic

type KEY TYPE is private;

DEFAULT#KEY_NUMBER :

BY KEY
procedure READ

procedure WRITE

INTEGER := 0O;

: in

(FILE

ITEM

FILE TYPE;

ITEM
KEY
KEY NUMBER

:
:
:

out ELEMENT_TYPE;
KEY TYPE;
in
INTEGER :=
in

RELATION

NUMBER;
KEYULT
DEFA

RELATION TYPE

in FILE TYPE;
in ELEMENT TYPE);

in FILE_TYPE;

ITEM

in ELEMENT TYPE);

procedure UNLOCK(FILE

in FILE_TYPE);

procedure UPDATE(FILE

:= EQUAL);

procedure DELETE ELEMENT (FILE

: in FILE TYPE);

function END OF FILE(FILE : in FILE_TYPE)

return BOOLEAN;

-—- Exceptions

STATUS ERROR
MODE ERROR
NAME ERROR
USE_ERROR
DEVICE ERROR
END ERROR
DATA ERROR
LOCK_ERROR
KEY ERROR

EXISTENCE ERROR

:
:
:
:
:
:
:
:
:

exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames
exception renames

IOEXCEPTIONS.STATUS_ERROR;
E
ERROR;
IOEXCEPTIONS.MOD
E
ERROR;
IOEXCEPTIONS.NAM
IOEXCEPTIONS.USE_ERRCR;
IOEXCEPTIONS.DEVICE_ERROR;
_
ERROR;
IOEXCEPTIONS.END
ERROR;
IOEXCEPTIONS.DATA
AUX IOEXCEPTIONS.LOCK_ERROR;
ERROR;
AUX IOEXCEPTIONS.KEY_

exception

renames AUX IOEXCEPTIONS.EXISTENCE_ERROR;

private

——- implementation-dependent
end

INDEX IO;

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

operations for 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. The size of the
file buffer is limited by the maximum record size of the external file.

Element input-output operations, such as READ and WRITE, provide the

means for reading a file element into the file buffer (and thus reading a

record of the associated external file), or writing the contents of the file
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 means for
transferring a value from or to the file buffer. The file buffer may contain
zero or more items of the file element. Every element transfer begins on

a byte boundary and involves the number of bits required by the type of

the item; the position or current position in the file 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 RMS record) locking is provided for RELATIVE_MIXED 10
and INDEXED_MIXED_IO. A brief explanation of how locking affects
relative and indexed files containing elements of the same type is given
at the end of section 14.2a; the same information applies to relative and

indexed files 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 RMS record 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 CREATE procedure 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 parameter of the
CREATE procedures.
procedure CREATE (FILE

in out FILE TYPE;

MODE

in FILE_MODE

NAME

STRING

"";

FORM

STRING

"");

INOUT_FILE;

——

-—-

Example:

——

procedure

CREATE (FILE

FORM =>

MY FILE;

"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

MODE

in FILE

NAME

STRING

FORM

STRING)
;

-—-

Example:

—-—

procedure

CREATE(FILE

FORM =>

FILE TYPE;
MODE
:=

INOUT FILE;

"";

MY FILE;

"KEY

0;"

"LENGTH

5;"

"POSITION

O;"

-—

"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

Iitem 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

ltem Input-Output

14.2b.2

must be instantiated with an actual type parameter for the generic parameter ITEM_TYPE. The GET_ARRAY procedure 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 determine the array to be output).
generic
type

ITEM TYPE is private;

procedure GETITEM(FILE

in FILE TYPE;

ITEM

out

ITEM TYPE);

Operates on a 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_ERROR is raised if the current mode of the
given file is OUT_FILE. The exception

LAYOUT ERROR is raised if

no more items can be read from the file buffer.
generic

type

ITEM TYPE is private;

type

INDEX

type

ITEM ARRAY

(<>);

is array

procedure GETARRAY(FILE

(INDEX range <>)

in FILE TYPE;

ITEMS

out

ITEM

LAST

out

INDEX):;

of ITEM TYPE;

ARRAY;

Operates on a file buffer for a file of mode IN_FILE or INOUT_FILE.

Gets the remaining items in the file 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
ITEMS is full or when no more items can be read from the file 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_ERROR is raised if the current mode of the
given file is OUT_FILE.
generic
type

ITEM TYPE

is private;

procedure PUT_ITEM(FILE

in FILE TYPE;

ITEM

ITEM TYPE);

Operates on a file buffer for a file of mode OUT_FILE or INOUT_
FILE. The value of the parameter ITEM is written into the file

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_ERROR is raised if the current mode of the
given file is IN_FILE. The exception LAYOUT_ERROR is raised if
the current position exceeds the file buffer size. The file buffer size
is limited by the maximum size of a record in the external file.
function END OF BUFFER(FILE

in FILE TYPE)

return BOOLEAN;

Operates on a file buffer for a file of mode IN_FILE or INOUT_FILE.
Returns TRUE if there are no more items to be read from the file
buffer. Returns FALSE otherwise.

The exception MODE_ERROR is raised if the current mode of the
given file is OUT_FILE.
procedure

SET POSITION(FILE

in FILE TYPE;

in POSITIVE_COUNT)
;

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 FILE TYPE)

return POSITIVE COUNT;

Operates on a file buffer for a file of any mode. Returns the current
position in the file buffer.
function MAX ELEMENT SIZE(FILE

in FILE TYPE)

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

ELEMENT SIZE(FILE

in FILE_TYPE)

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 the file buffer, a
value of zero is returned.

The ELEMENT _SIZE function can be used in combination with the
POSITION function to determine the number of bytes remaining
in the file 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_ERROR is raised if the mode is 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 RMS record 14.1a

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_ERROR is 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 FILE TYPE);

Operates on a file of mode IN_FILE. Reads the next sequential

element from the given file into the file buffer.

The exception MODE_ERROR is raised if the mode is not IN_FILE.
The exception END_ERROR is raised if an attempt is made to read
past the end of the file.
procedure

WRITE (FILE

FILE TYPE):;

Operates on a file of mode OUT_FILE. Writes the 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 the file.

The exception MODE_ERROR is raised if the mode is not OUT_
FILE.
function END_OF FILE(FILE

in FILE

TYPE)

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.
The exception MODE_ERROR is raised 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 10
with

IOEXCEPTIONS;

package

SEQUENTIAL MIXED IO

type

FILE

TYPE

limited private;

type

FILE

MODE

(IN FILE,

type

COUNT

range

subtype POSITIVE COUNT
-—

File

OUT FILE);

INTEGER’ LAST;

COUNT

range

COUNT'’ LAST;

management

procedure

CREATE(FILE

MODE

in FILE

NAME

STRING

FORM

STRING

OPEN

in out

in FILE

NAME

in STRING;

FORM

(FILE

DELETE(FILE

procedure

RESET

TYPE;

MODE

procedure

RESET

FILE

(FILE

procedure

out

OUT

FILE;

NN,

’
=

nu)

;

FILE TYPE;
MODE;

STRING

in out

nu)

;

FILE TYPE);

in out

FILE

TYPE);

FILE

TYPE;

(FILE

MODE

in FILE MODE) ;

(FILE

out
out

FILE

TYPE);

function MODE

(FILE

in FILE TYPE)

return

FILE

function NAME

(FILE

in FILE

TYPE)

return

STRING;

function FORM

(FILE

in FILE

TYPE)

return

STRING;

IS OPEN(FILE

in FILE

TYPE)

return

BOOLEAN;

function
-—

Item

input

and

output

MODE;

operations

generic
type

ITEM TYPE

procedure

GET

ITEM

private;

(FILE

FILE

TYPE;

ITEM

out

ITEM TYPE);

(INDEX

range

<>)

ITEM TYPE;

generic
type

ITEM TYPE

type

INDEX

(<>);

type

ITEM ARRAY

procedure

14-35

GET

private;

array

ARRAY (FILE

FILE TYPE;

ITEMS

out

ITEM ARRAY;

LAST

out

INDEX)
;

Specification of the Package Sequential_Mixed_IO

14.2b.4

generic
type ITEM TYPE

procedure PUT ITEM

is private;

in FILE_TYPE;

(FILE

ITEM :

in FILE TYPE)

function END OFBUFFER(FILE

in ITEM TYPE);

return BOOLEAN;

procedure SETPOSITION(FILE

in FILE_ TYPE;

in POSITIVE COUNT) ;

function POSITION(FILE

in FILE TYPE)

function MAX ELEMENT_ SIZE(FILE
function ELEMENT SIZE(FILE

return POSITIVE COUNT;

in FILE TYPE)

return COUNT;

—- Element input and output operations
procedure READ (FILE
procedure WRITE (FILE

:
:

in FILE TYPE);
in FILE TYPE);

function END OF FILE(FILE

in FILE TYPE)

return BOOLEAN;

—— Exceptions

STATUS _ERROR
MODE_ERROR
NAME ERRCR
USE_ERROR
DEVICE ERROR

:
:
:
:
:

exception
exception
exception
exception
exception

renames
renames
renames
renames
renames

IOEXCEPTIONS.STATUS_ERROR;
IO EXCEPTIONS.MODE_ERROR;
IOEXCEPTIONS.NAME
ERROR;
IOEXCEPTIONS.USE_ERROR;
IOEXCEPTIONS.DEVICE_ERROR;

END ERROR

exception renames

DATA ERROR

exception renames IOEXCEPTIONS.DATA_ERROR;

IOEXCEPTIONS.END_ERROR;

private

-—-

implementation-dependent

end SEQUENTIAL
MIXED IO;

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_ERROR is raised 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

procedure

READ

(FILE

FROM

in POSITIVE_ COUNT) ;

FILE TYPE;

(FILE

in FILE TYPE);

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 file buffer, the value of the element whose position is specified
by the current index of the file; finally, increases the current index
by one.
The exception MODE_ERROR is raised if the mode of the given file
is OUT_FILE. The exception END_ERROR is raised if the index to

be used exceeds the size of the external file.
procedure WRITE

procedure

WRITE

(FILE

in FILE TYPE;

(FILE

in FILE TYPE);

POSITIVE COUNT) ;

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 the file
buffer to the element whose position in the given file is specified by

the current index of the file; finally, increases the current index by
one. 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 the file.

The exception MODE_ERROR is raised if the mode of the given file
is IN_FILE.
procedure

SETINDEX(FILE

in FILE TYPE;

POSITIVE COUNT):;

Operates on a 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 the size of the file.
function

INDEX(FILE

in FILE TYPE)

return POSITIVE COUNT;

Operates on a file of any mode. Returns the current index of the
given file.

14-37

Direct Mixed Input-Output

14.2b.5

function

SIZE(FILE

in FILE TYPE)

return COUNT;

Operates on a file of any mode. Returns the number of elements
(VMS RMS records) in the file.
function END

OF FILE(FILE

in FILE TYPE)

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_ERROR is raised 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.1a

14.2b.6

Specification of the Package Direct_Mixed_IO
with

IOEXCEPTIONS;

package

DIRECT MIXED IO

type FILE TYPE

limited private;
(IN FILE,

type

FILE

MODE

COUNT

range

subtype

POSITIVE

—-—

management

procedure

COUNT

INOUT FILE,

OUT FILE);

INTEGER’LAST;

COUNT

in FILE

NAME

STRING

"";

FORM

STRING

"");

NOTE:

specified

A maximum record

——

procedure.

in the

OPEN

out

range

MODE

——

procedure

CREATE (FILE

——

procedure

14.2b.6

type

File

FILE TYPE;

MODE

(element)

INOUT FILE;

size must

FORM parameter of

(FILE

in out

MODE

in FILE MODE;

NAME

STRING;

FORM

STRING

in out

COUNT’LAST;

the

FILE TYPE;

"");

(FILE

procedure DELETE(FILE

procedure RESET

(FILE

in out FILE TYPE; MODE

procedure RESET

(FILE

out

Specification of the Package Direct_Mixed_|O

CREATE

FILE TYPE);
FILE TYPE);

FILE

in FILE MODE) ;

TYPE);

14-38

function MODE

(FILE

in FILE TYPE)

return FILE

function

NAME

(FILE

return

STRING;

function

FORM

(FILE

in FILE

return

STRING;

function

IS OPEN(FILE

in FILE TYPE)

Item

input

and

output

FILE TYPE)

TYPE)

MODE;

return BOOLEAN;

operations

generic
type

ITEM TYPE

procedure

GET

is private;

ITEM

(FILE

FILE

TYPE;

ITEM

(INDEX

range

<>)

out

ITEM TYPE);

generic

type

ITEM

TYPE

type

INDEX

type

ITEM ARRAY

procedure

is private;

(<>);
is

array

GET ARRAY (FILE

ITEMS

out

ITEM

LAST

out

INDEX);

ITEM TYPE;

FILE TYPE;
ARRAY;

generic
type

ITEM TYPE

procedure
function

PUT
END

procedure

ITEM

private;

(FILE

in FILE TYPE;

OF BUFFER(FILE

return

FILE TYPE;

POSITIVE COUNT) ;

function

MAX ELEMENT
SIZE (FILE

function

ELEMENT SIZE(FILE

procedure

TO
POSITION

Element

FILE TYPE)

SET POSITION(FILE

function

—-—

ITEM

input
READ

(FILE

and

output

FILE TYPE)
:

FILE

return
TYPE)

TYPE)

in FILE TYPE;

FROM

in POSITIVE COUNT);

(FILE

READ

procedure

WRITE(FILE
TO

in FILE TYPE;
in

in FILE TYPE);

WRITE (FILE

procedure

SET INDEX(FILE

POSITIVE
return

return

COUNT;

FILE TYPE);

procedure

BOOLEAN;

operations

(FILE

procedure

ITEM TYPE);

POSITIVE COUNT) ;

in POSITIVE COUNT) ;

FILE

TYPE;

function INDEX (FILE : in FILE_TYPE) return POSITIVE COUNT;
function

SIZE

function END

14-39

(FILE

in FILE

OF FILE(FILE

TYPE)

return

in FILE TYPE)

COUNT;

return BOOLEAN;

Specification of the Package Direct Mixed_IO

14.2b.6

-—

Exceptions

STATUS ERROR

exception renames

IOEXCEPTIONS.STATUS_ERROR;

MODE ERROR

exception renames

IOEXCEPTIONS.MODE
ERROR;

NAME ERROR

exception renames

IOEXCEPTIONS.NAME
ERROR;

USE_ERROR

exception renames

IOEXCEPTIONS.USE
ERROR;

DEVICE ERROR

exception renames

IO_EXCEPTIONS.DEVICE_ERROR;

END ERROR

exception renames

IOEXCEPTIONS.END_
ERROR;

DATA ERROR

exception renames

IOEXCEPTIONS.DATA
ERROR;

private

——

implementation—-dependent

end DIRECT MIXED IO;

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_ERROR is 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 relative mixed input
and output.
procedure READ

procedure READ

(FILE

in FILE TYPE;

FROM

in POSITIVE COUNT);

(FILE

in FILE TYPE);

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

14.2b.7

Relative Mixed Input-Output

1440

procedure READ EXISTING

(FILE

in FILE TYPE;

FROM

in POSITIVE COUNT) ;

(FILE

in FILE TYPE);

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 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_ERROR is raised if the mode of the given file
is OUT_FILE. The exception LOCK_ERROR is raised if the element
to be read is locked; this error is possible only if the external file is
being shared. The exception EXISTENCE_ERROR is raised if the
current index is beyond the end of the file, or if the end of the file is
reached before an existing element (nonempty cell) is found.
procedure WRITE

procedure WRITE

(FILE

in FILE TYPE;

in POSITIVE COUNT) ;

(FILE

in FILE TYPE);

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 given file
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 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_ERROR is raised if the mode of the given file
is IN_FILE. The exception USE_ERROR is raised if the element
position in the file has already been written.

Relative Mixed Input-Output

14.2b.7

procedure

UPDATE (FILE

FILE

TYPE);

Operates on a file of mode INOUT_FILE. Updates the current

element with the contents of the file buffer.

The exception MODE_ERROR is raised if the current mode is not
INOUT_FILE. The exception USE_ERROR is raised if the current

element is undefined at the start of this operation.
procedure

UNLOCK

(FILE

in FILE

TYPE);

Operates on a file of any mode. After this operation, the current

element is undefined.
procedure

DELETE ELEMENT (FILE

in FILE TYPE);

Operates on a file of mode INOUT_FILE. Deletes the current
element in the file.
The exception MODE_ERROR is raised if the current mode is not
INOUT_FILE. The exception USE_ERROR is raised if the current

element is undefined at the start of this operation.
procedure

SETINDEX(FILE

in FILE TYPE;

in POSITIVE COUNT) ;

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

FILE

TYPE)

return

POSITIVE COUNT;

Operates on a file of any mode. Returns the current index of the
given file.
function

END OF FILE(FILE

FILE

TYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE or INOUT _FILE. Returns
TRUE if no cell, starting at the current index, contains an element;
otherwise returns FALSE.

The exception MODE_ERROR is raised 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.1a, 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

1442

14.2b.8

IO
Specification of the Package Relative_Mixed
with

IOEXCEPTIONS;

with AUX IOEXCEPTIONS;

package RELATIVE MIXED IO is

type FILE TYPE is limited private;

type FILE MODE is (IN_FILE, INOUT FILE, OUT_FILE);
type COUNT is range O

INTEGER’LAST;

subtype POSITIVE COUNT is COUNT range 1 .. COUNT'LAST;
-—

File management

procedure CREATE (FILE

in out FILE_TYPE;

:= INOUT_FILE;

MODE

in FILE MODE

NAME

in STRING

"";

FORM

in STRING

"");

—— NOTE: A maximum record (element) size must be
-— specified in the FORM parameter of the CREATE
—-—

procedure.

(FILE

in out FILE_TYPE;

MODE

in FILE MODE;

NAME

in STRING;

FORM

in STRING

procedure CLOSE (FILE
procedure DELETE(FILE

:
:

in out FILE_TYPE);
in out FILE TYPE);

procedure OPEN

"");

procedure RESET (FILE : in out FILE TYPE; MODE : in FILE MODE) ;
in out FILE_ TYPE);

procedure RESET

(FILE

function MODE
function NAME
function FORM

(FILE
(FILE
(FILE

: in FILE TYPE)
: in FILE TYPE)
: in FILE TYPE)

return FILE MODE;
return STRING;
return STRING;

in FILE TYPE)

return BOOLEAN;

function IS OPEN(FILE

-— Item input and output operations
generic
type

ITEM TYPE is private;

procedure GETITEM(FILE : in FILE TYPE; ITEM : out ITEM TYPE);
generic

type ITEM TYPE is private;
type INDEX is (<>);

type ITEM ARRAY is array

(INDEX range <>)

in FILE TYPE;

ITEMS

out

ITEM ARRAY;

LAST

out

INDEX);

procedure GET ARRAY (FILE

of ITEM TYPE;

generic

type ITEM TYPE is private;

procedure PUT ITEM (FILE : in FILE TYPE;

1443

ITEM :

in ITEM TYPE);

Specification of the Package Relative_Mixed_I0

14.2b.8

function END OF BUFFER(FILE

procedure SETPOSITION(FILE
TO

function POSITION
function

(FILE

in FILE_TYPE)

in FILE TYPE;

in POSITIVE COUNT);

in FILE TYPE)

MAX ELEMENT SIZE(FILE

function ELEMENT
SIZE (FILE

—— Element

input

procedure READ

return POSITIVE COUNT;

in FILE_TYPE)

in FILE TYPE)

return COUNT;

and output operations
(FILE
FROM
(FILE

procedure READ

return BOOLEAN;

in FILE_TYPE;

in POSITIVE_COUNT)
;

in FILE TYPE);

procedure READ EXISTING(FILE

in FILE_TYPE;

FROM

in POSITIVE COUNT) ;

procedure READEXISTING(FILE

in FILE TYPE):;

procedure WRITE

(FILE

in FILE TYPE;

in POSITIVE_ COUNT);

(FILE

in FILE TYPE);

procedure UPDATE (FILE

in FILE TYPE):;

procedure WRITE

procedure UNLOCK

(FILE

in FILE_TYPE);

procedure DELETE ELEMENT (FILE
procedure SETINDEX(FILE
TO
function INDEX(FILE
function
——

in FILE TYPE);

in FILE_TYPE;

in POSITIVE COUNT) ;

in FILE TYPE)

END OF FILE(FILE

return POSITIVE_COUNT;

in FILE_TYPE)

return BOOLEAN;

Exceptions

STATUS_ERROR

exception renames

IO_EXCEPTIONS.STATUS_ERROR;

MODE ERROR

exception renames

IOEXCEPTIONS.MODE
ERROR;

NAME ERROR

exception renames

IO_EXCEPTIONS.NAME
ERROR;

USE_ERROR

exception renames

IOEXCEPTIONS.USE
ERROR;

DEVICE_ERROR

exception renames

IOEXCEPTIONS.DEVICE
ERROR;

END ERROR

exception renames

DATA ERROR

exception renames

IOEXCEPTIONS.DATA
ERROR;

LOCK_ERROR

exception renames AUX IOEXCEPTIONS.LOCK_ERROR

EXISTENCE ERROR

exception

renames

AUX

EXCEPTIONS.END_ ERROR;

IOEXCEPTIONS.EXISTENCE_
ERROR;

private
-—
end

14.2b.8

implementation-dependent

RELATIVE

MIXED IO;

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_ERROR is 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_KEY procedure, 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. The range of values for DEFAULT
KEY NUMBER is 0 to
254; a value of O (the default) designates the primary key.

If the RELATION parameter to the READ_BY_KEY procedure is specified,
1t must have a value of EQUAL_NEXT, EQUAL, or NEXT (the default is

EQUAL).
procedure

READ(FILE

FILE TYPE);

generic
type

KEY

TYPE

private;

DEFAUL
KEY NUMBER
T

procedure

READ

INTEGER

BY KEY (FILE
KEY

KEY

NUMBER

:= 0;
: in

FILE TYPE;

KEY TYPE;

INTEGER

DEFAU
KEY NUMBER;
LT

RELATION

1445

RELATION TYPE

EQUAL);

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, returns in 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 the file buffer the value of the
element specified by the given key information; KEY gives the key
value; KEY_NUMBER designates 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 and relation 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_ERROR is raised if the current mode is OUT_
FILE. The exception END_ERROR is raised if an attempt is made to
read past the end of the file by the first form. The exception LOCK_
ERROR is raised if the element to be read is locked; this error is
possible only if the external file is being shared. The exception
EXISTENCE_ERROR is raised if the element does not exist. The
exception KEY_ERROR is raised if the size of the given key is not a
multiple of eight bits.
procedure WRITE(FILE

in FILE TYPE);

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

UPDATE (FILE

in FILE TYPE);

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

1446

rest of the file buffer is filled with zero bits before being written to
the file.

The exception MODE_ERROR is raised if the current mode is not

INOUT_FILE. The exception USE_ERROR is raised 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_ERROR is raised if a key
has been changed or duplicated and if changes or duplicates are not
allowed by the external file.
procedure UNLOCK(FILE

FILE TYPE);

Operates on a file of any mode. After this operation, the current
element is undefined.
procedure

DELETE ELEMENT (FILE

in FILE TYPE);

Operates on a file of mode INOUT FILE. Deletes the current
element of the file.
The exception MODE_ERROR is raised if the current mode is not

INOUT_FILE. The exception USE_ERROR is raised if the current
element is undefined at the start of this operation.
function END OF FILE(FILE

in FILE TYPE)

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 element in the file;

otherwise returns FALSE.
The exception MODE_ERROR is raised if the current mode is

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

Indexed Mixed Input-Output

14.2b.9

14.2b.10

Specification of the Package Indexed_Mixed_lO
with

IOEXCEPTIONS;

with AUX

IO EXCEPTIONS;

package INDEXED MIXED IO is
type FILE TYPE is limited private;

type FILE MODE is

(IN_FILE,

type RELATION TYPE is

INOUT FILE,

(EQUAL NEXT,

OUT_FILE);

EQUAL,

NEXT);

function GREATER return RELATION_TYPE
renames

NEXT;

return RELATION_TYPE

function GREATER EQUAL
renames

EQUAL NEXT;

INTEGER'’ LAST;
type COUNT is range O
subtype POSITIVE COUNT is COUNT range 1

COUNT' LAST;

-—- File management
procedure

FILE TYPE;

in out

CREATE (FILE

FILE MODE

MODE

NAME

in STRING

FORM

INOUT_FILE;

:=
WU,

in STRING);

~— All information about the keys must be provided in the
—— FORM parameter of the CREATE procedure.
procedure OPEN

(FILE

in out

MODE

in STRING;

NAME

FORM

procedure

STRING
out

un)’.

FILE TYPE);

in out

(FILE

in FILE TYPE;

MODE

in FILE MODE;

KEY

procedure RESET

in
in

(FILE

procedure DELETE (FILE
procedure RESET

FILE_ TYPE;

FILE MODE;

NUMBER

in INTEGER

0);

(FILE
KEY NUMBER

:
:

in FILE_TYPE;
in INTEGER :=

0);

function MODE

(FILE

function NAME

(FILE

in FILE TYPE)

return

function FORM

(FILE

in FILE TYPE)

return STRING;

return BOOLEAN;

function IS OPEN (FILE

Item input and output

FILE TYPE)

return FILE MODE;
STRING;

operations

generic

type ITEM TYPE is private;
procedure GETITEM(FILE
in FILE TYPE;

14.2b.10

Specification of the Package Indexed_Mixed_lO

ITEM

out

ITEM TYPE);

1448

generic
type

ITEM

TYPE

type

INDEX

is private;

type

ITEM ARRAY

(<>);
is array

(INDEX

procedure GET ARRAY (FILE

range

<>)

ITEM TYPE;

FILE TYPE;

ITEMS

out

ITEM ARRAY;

LAST

out

INDEX):;

generic
type

ITEM

TYPE

is private;

procedure PUT ITEM(FILE

FILE

function END OF BUFFER(FILE
procedure

SET

POSITION (FILE

TO
function POSITION(FILE
function

—-

Element

procedure

input
READ

and

output

(FILE

FILE TYPE)

FILE TYPE;

POSITIVE COUNT) ;

return POSITIVE COUNT;

FILE

in FILE

ITEM TYPE);

return BOOLEAN;

FILE _TYPE)

ITEM

MAXELEMENT
SIZE (FILE

function ELEMENT SIZE(FILE

TYPE;

TYPE)

return COUNT;

operations

FILE

TYPE);

generic
type

KEY TYPE

DEFAULT KEY

procedure

is private;

NUMBER

INTEGER

READ BY KEY (FILE
KEY

KEY

NUMBER

0O;

FILE TYPE;

KEY TYPE;

INTEGER

DEFAULT
KEY NUMBER;

RELATION
procedure WRITE

(FILE

FILE TYPE);

procedure UPDATE (FILE

FILE

TYPE);

in FILE

TYPE);

procedure

UNLOCK(FILE

procedure DELETE

function

——

ELEMENT (FILE

END OF FILE (FILE

RELATION TYPE

EQUAL);

in FILE TYPE);
FILE _TYPE)

return BOOLEAN;

Exceptions

STATUS ERROR

exception

renames

IOEXCEPTIONS.STATUS
ERROR;

MODE_ERROR

exception

renames

IOEXCEPTIONS.MODE
ERROR;

NAME

exception

renames

IOEXCEPTIONS.NAME
ERROR;

USE_ERROR

exception

renames

IO_EXCEPTIONS.USE
ERROR;

DEVICE

exception

renames

IOEXCEPTIONS.DEVICE
ERROR;

END ERROR

exception

renames

IO_EXCEPTIONS.END
ERROR;

DATA

ERROR

exception

renames

IOEXCEPTIONS.DATA
ERROR;

LOCK _ERROR

exception

renames

AUX

IO_EXCEPTIONS.LOCK
ERROR;

KEY

exception

renames

AUX

IOEXCEPTIONS.KEY
ERROR;

ERROR

EXISTENCE ERROR
renames

14—49

AUX

exception
IO_EXCEPTIONS.EXISTENCE
ERROR;

Specification of the Package Indexed_Mixed_IO

14.2b.10

private

-—end

implementation-dependent

INDEX MIXED IO;

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 10, 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 gages. The specification of the package is

given below in section 14.3.10.1

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 names exist, 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 PUT are 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 sequences as their
counterparts which have a 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 input file, and each such PUT procedure
operates on an output file. If no file is specified, a default input file or a
default output file is used.

At the beginning of program execution the default input and output files are
the so-called standard input file and standard output file. These files are
open, have respectively the current modes IN_FILE and OUT_FILE, and
are associated with two implementation-defined external files. Procedures
are provided to change the current default input file and the current default
output file.

VAX Ada has two logical file names, ADASINPUT 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 ADASINPUT
and ADA$OUTPUT to refer to nonprocess-permanent files, these logical
names can be used to achieve asynchronous terminal 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
marked by a line terminator; the end of a page is marked by the combination
of a line terminator immediately followed by a page terminator; and the
end of a file is marked by the combination of a line terminator immediately
followed by a page terminator and then a file terminator. Terminators are
generated during output; either by calls of procedures provided expressly for
that purpose; or implicitly as part of other operations, for example, when a
bounded line length, a bounded page length, or both, have been specified for
a file.

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 how line, page, and file
terminators are interpreted in VAX Ada.

The characters of a line are numbered, starting from one; the number of
a character is called its column number. For a line terminator, a column
number is also defined: it is one more than the number of characters in the
line. The lines of a page, and the pages of a file, are similarly numbered.
The current column number is the column number of the next character or
line terminator to be transferred. The current line number is the number
of the current line. The current page number is the number of the current
page. These numbers are values of the subtype POSITIVE_COUNT of the
type COUNT (by convention, the value zero of the type COUNT is used to
indicate special conditions).
type COUNT is range 0

subtype

POSITIVE COUNT

implementation defined;
COUNT

range

COUNT’LAST;

In VAX Ada, the integer type COUNT is 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 new line is automatically
started before the value is output; if, further, this new line cannot fit
on the current page, for a specified maximum page length, then a new
page is automatically started before the value is output. Functions are

provided to determine the maximum line length and the maximum page
length. When a file is opened with mode OUT_FILE, both values are
zero: by convention, this means that the line lengths and page lengths

are unbounded. (Consequently, output consists of a single line if the
subprograms for explicit control of line and page structure are not used.)
The constant UNBOUNDED is provided for this purpose.
10

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 output file 14.3.2

14.3

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 subprograms given 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 page is already
terminated; then outputs a file terminator. If the new file mode is
OUT_FILE, the page and line lengths are unbounded. For all modes,

the current column, line, and page numbers are set to one.16

The exception MODE_ERROR is raised by the procedure RESET upon an

attempt to change the mode of a 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 when a file parameter is omitted from a GET, PUT or

other operation of text input-output described below. 18
procedure

SETINPUT(FILE

FILE TYPE);

Operates on a file of mode IN_FILE. Sets the current default input
file to FILE.
The exception STATUS_ERROR is raised if the given file is not open.
The exception MODE_ERROR is raised if the mode of the given file
1s not IN_FILE.
procedure

SETOUTPUT(FILE

in FILE TYPE);

Operates on a file of mode OUT_FILE. Sets the current default

output file to FILE.

The exception STATUS_ERROR is raised if the given file is not open.
The exception MODE_ERROR is raised if the mode of the given file
is not OUT FILE.
function

STANDARD

INPUT

return FILE

TYPE;

Returns the standard input file (see 14.3).
10

function

CURRENT INPUT

return FILE TYPE;

Returns the current default input file.

return FILE TYPE;

Returns the standard output file (see 14.3).

STANDARD OUTPUT

function CURRENT OUTPUT

return FILE TYPE;

Returns the current default output file.

Note:
16

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 subprograms described in this section are concerned with the line and
page structure of a file of mode OUT_FILE. They operate either on the file
given as the first parameter, or, in the absence of such a file parameter,
on the current default output file. They provide for output of text with a
specified maximum line length or page length. In these cases, line and
page terminators are output implicitly and automatically when needed.
When line and page lengths are unbounded (that is, when they have the
conventional value zero), as in the case of a newly opened file, new lines and
new pages are only started when explicitly called for.

In all cases, the exception STATUS_ERROR is raised if the file to be used
is not open; the exception MODE_ERROR is raised if the mode of the file is
not OUT_FILE.
procedure SET LINE LENGTH(FILE
procedure SET LINE LENGTH
(TO

:
:

in FILE_TYPE;
in COUNT)
;

in COUNT);

Sets the maximum line length of the specified output file to the
number of characters specified by TO. The value zero for TO specifies
an unbounded line length.

The exception USE_ERROR is raised if the specified line length is
inappropriate for the associated external file.
procedure

SET PAGE LENGTH(FILE

in FILE TYPE;

procedure

SET PAGE LENGTH
(TO

in COUNT);

Sets the maximum page length of the specified output file to the
number of lines specified by TO. The value zero for TO specifies an
unbounded page length.

The exception USE_ERROR is raised if the specified page length is
inappropriate for the associated external file.
function LINE LENGTH(FILE
function LINE LENGTH
10

14-55

in FILE TYPE)

return COUNT;

Returns the maximum line length currently set for the specified
output file, or zero if the line length is unbounded.
function PAGE LENGTH(FILE
function PAGE LENGTH

return COUNT;

in FILE TYPE)

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 subprograms described in this section provide for explicit control of
line and page structure; they operate either on the file given as the first
parameter, or, in the absence of such a file parameter, on the appropriate

(input or output) current default file.1? The exception STATUS_ERROR is
raised by any of these subprograms if the file to be used is not open.
procedure

procedure

NEWLINE(FILE

in FILE TYPE;

SPACING

in POSITIVE COUNT

1);

NEW_LINE (SPACING

in POSITIVE COUNT

1);

Operates on a file of mode OUT_FILE.
For a SPACING of one: Outputs a line terminator and sets the
current column number to one. Then increments the current line

number by one, except in the case that the current line number is
already greater than or equal to the maximum page length, for a
bounded page length; in that case a page terminator is output, the
current page number is incremented by one, and the current line

number is set to one.
For a SPACING greater than one, the above actions are performed

SPACING times.
The exception MODE_ERROR is raised if the mode is not

OUT_FILE.
procedure

procedure

SKIP LINE (FILE

FILE TYPE;

SPACING

POSITIVE

COUNT

1);

SKIP_LINE (SPACING

POSITIVE COUNT

1);

Operates on a file of mode IN_FILE.
For a SPACING of one: Reads and discards all characters until a

line terminator has been read, and then sets the current column
number to one. If the line terminator is not immediately followed by
a page terminator, the current line number is incremented by one.

Otherwise, if the line terminator is immediately followed by a page
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
number is incremented by one, and the current line number is set
to one.

For a SPACING greater than one, the above actions are performed
SPACING times.
10

The exception MODE_ERROR is raised if the mode is not IN_FILE.
The exception END_ERROR is raised if an attempt is made to read
a file terminator.
function END OF LINE(FILE
function END
OF LINE

in FILE_TYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUE if a line
terminator or a file terminator is next; otherwise returns FALSE.
13

The exception MODE_ERROR is raised if the mode is not IN_FILE.
procedure NEW PAGE (FILE

in FILE TYPE);

procedure NEW PAGE;
15

Operates on a file of mode OUT_FILE. Outputs a line terminator if
the current line is not terminated, or if the current page is empty
(that is, if the current column and line numbers are both equal to
one). Then outputs a page terminator, which terminates the current
page. Adds one to the current page number and sets the current
column and line numbers to one.

The exception MODE_ERROR is raised if the mode is not
OUT_FILE.
procedure

SKIP PAGE (FILE:

procedure

SKIP_ PAGE;

in FILE TYPE);

Operates on a file of mode IN_FILE. Reads and discards all characters and line terminators until a page terminator has been read.
Then adds one to the current page number, and sets the current
column and line numbers to one.
19

The exception MODE_ERROR is raised if the mode is not IN_FILE.
The exception END_ERROR is raised if an attempt is made to read
a file terminator.
function END OF PAGE(FILE
function END
OF PAGE

14-57

in FILE TYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUE if the combination of a line terminator and a page terminator is next, or if a file
terminator is next; otherwise returns FALSE.

Operations on Columns, Lines, and Pages

14.3.4

The exception MODE_ERROR is raised if the mode is not IN_FILE.

function

END OF FILE(FILE

function END
OF FILE

in FILE TYPE)

return BOOLEAN;

Operates on a file of mode IN_FILE. Returns TRUE if a file ter-

minator is next, or if the combination of a line, a page, and a file
terminator is next; otherwise returns FALSE.
25

The exception MODE_ERROR is raised if the mode is not IN_FILE.

The following subprograms provide for the control of the current position of
reading or writing in a file. In all cases, the default file is the current output
file.

procedure

SETCOL(FILE

in FILE TYPE;

procedure

SET COL(TO

in POSITIVE COUNT) ;

in POSITIVE_ COUNT) ;

If the file mode is OUT_FILE:

If the value specified by TO is greater than the current column

number, outputs spaces, adding one to the current column number
after each space, until the current column number equals the
specified value. If the value specified by TO is equal to the current
column number, there is no effect. If the value specified by TO is
less than the current column number, has the effect of calling NEW_
LINE (with a spacing of one), then outputs (TO — 1) spaces, and sets '
the current column number to the specified value.
30

The exception LAYOUT_ERROR is raised if the value specified by

TO exceeds LINE_LENGTH when the line length is bounded (that
is, when it does not have the conventional value zero).
31

If the file mode is IN_FILE:

Reads (and discards) individual characters, line terminators, and
page terminators, until the next character to be read has a column

number that equals the value specified by TO; there is no effect

if the current column number already equals this value. Each
transfer of a character or terminator maintains the current column,

line, and page numbers in the same way as a GET procedure (see
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_ERROR is raised if an attempt is made to read
a file terminator.

procedure

SET LINE(FILE

procedure

SET LINE (TO

in FILE

TYPE;

in POSITIVE COUNT) ;

: in POSITIVE COUNT) ;

If the file mode 1s OUT_FILE:

If the value specified by TO is greater than the current line number,
has the effect of repeatedly calling NEW_LINE (with a spacing of

one), until the current line number equals the specified value. If the
value specified by TO is equal to the current line number, there is
no effect. If the value specified by TO is less than the current line
number, has the effect of calling NEW_PAGE followed by a call of
NEW_LINE with a spacing equal to (TO — 1).
37

The exception

LAYOUT ERROR

is raised if the value specified by

TO exceeds PAGE_LENGTH when the page length is bounded (that
is, when it does not have the conventional value zero).

If the mode 1s IN_FILE:

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

The exception END_ERROR is raised if an attempt is made to read
a file terminator.

function

COL(FILE

function

COL

in FILE TYPE)

return

POSITIVE COUNT;

return POSITIVE COUNT;

Returns the current column number.

The exception LAYOUT_ERROR is raised if this number exceeds
COUNT"' LAST.

14-59

function

LINE(FILE

function

LINE

in FILE

TYPE)

return POSITIVE COUNT;

Returns the current line number.

Operations on Columns, Lines, and Pages

14.3.4

The exception LAYOUT_ERROR is raised if this number exceeds
COUNT' LAST.

function PAGE (FILE
function PAGE

in FILE TYPE)

return POSITIVE_COUNT;

POSITIVE COUNT;

Returns the current page number.

The exception LAYOUT_ERROR is raised if this number exceeds
COUNT" LAST.

return

The column number, line number, or page number are allowed to exceed
COUNT' LAST (as a consequence of the input or output of sufficiently many
characters, lines, or pages). These events do not cause any exception to
be raised. However, a call of COL, LINE, or PAGE raises the exception
LAYOUT_ERROR if the corresponding number exceeds COUNT’ LAST.
Note:

A page terminator is always skipped whenever the preceding line terminator
is skipped. An implementation may represent the combination of these

terminators by a single character, provided that it is properly recognized at
input.
The interpretation of these terminators is 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.3, 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
1

The procedures GET and PUT for 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 procedures for items of type

CHARACTER and STRING deal with individual character values; the GET
and PUT procedures for numeric and enumeration types treat the items as

lexical elements.

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 a file of mode
OUT_FILE.

All procedures GET and PUT maintain the current column, line, and
page numbers of the specified file: the effect of each of these procedures
upon these numbers is the 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 number to one and adds one to
the current line number. Each output of a page terminator sets the current
column and line numbers to one and adds one to the current page number.
For input, each skipping of a line terminator sets the current column
number to one and adds one to the current line number; each skipping of
a page terminator sets the current column and line numbers to one and
adds one to the current page number. Similar considerations apply to the

procedures GET_LINE, PUT_LINE, and SET_COL.%°

Several GET and PUT procedures, for numeric and enumeration types, have

format parameters which specify field lengths; these parameters are of the
nonnegative subtype FIELD of the type INTEGER.
5

Input-output of enumeration values uses the syntax of the corresponding

lexical elements. Any GET procedure for an enumeration type begins by
skipping any leading blanks, or line or page terminators; 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.

For a numeric type, the GET procedures have a format parameter called
WIDTH. If the value given for this parameter is zero, the GET procedure
proceeds in the same manner as for enumeration types, but using the syntax

of numeric literals instead of that of enumeration literals. If a nonzero value
is given, then exactly WIDTH characters are input, or the characters up

to a line terminator, whichever comes first; any skipped leading blanks are
included in the count. The syntax used for numeric literals is an extended
syntax that allows a leading sign (but no intervening blanks, or line or page
terminators).

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 numeric literal, identifier, or character
literal, as appropriate. This is preceded by leading spaces if required by

the format parameters WIDTH or FORE (as described in later sections),
and then a minus sign for a negative value; for an enumeration type, the
spaces follow instead of leading. The format given for a PUT procedure is

overridden if it is insufficiently wide2!
8

Two further cases arise for PUT procedures for numeric and enumeration
types, if the line length of the specified output file is bounded (that is, if it

does not have the conventional value zero). If the number of characters to
be output does not exceed the maximum line length, but is such that they

cannot fit on the current line, starting from the current column, then (in
effect) NEW_LINE is called (with a spacing of one) before output of the item.
Otherwise, if the number of characters exceeds the maximum line length,

then the exception LAYOUT_ERROR is raised and no characters are output.
9

The exception STATUS_ERROR is raised by any of the procedures GET,
GET_LINE, PUT, and PUT_LINE if the file to be used is not open. The

exception MODE_ERROR is raised by the procedures GET and GET_LINE
if the mode of the file to be used is not IN_FILE; and by the procedures PUT
and PUT_LINE, if the mode is not

OUT _FILE.

The exception END_ERROR is raised by a GET procedure if an attempt
is made to skip a file terminator. The exception DATA_ERROR is raised

by a GET procedure if the sequence finally input is not a lexical element
corresponding to the type, in particular if no characters were input; for this

test, leading blanks are ignored; for an item of a numeric type, when a sign
is input, this rule applies to the succeeding numeric literal. The exception

LAYOUT_ERROR is 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.
11

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

input

Sequence

——

bb-12535b

-—

bbl2

535E1b

535E1

bbl2

535E;

535E

input

Value

-12535

of N

-12535

125350
(none)

DATA ERROR

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.3, 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 CHARACTER the following procedures are provided:
procedure

procedure

GET (FILE

in FILE TYPE;

ITEM

out

CHARACTER);

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_ERROR is raised if an attempt is made to skip a

file terminator.
procedure

PUT(FILE

FILE TYPE;

procedure

PUT(ITEM

CHARACTER);

ITEM

CHARACTER);

If the line length of the specified output file is bounded (that is,

does not have the conventional value zero), and the current column
number exceeds it, has the effect of calling NEW_LINE with a
spacing of one. Then, or otherwise, outputs the given character to
the file.

14-63

Input-Output of Characters and Strings

14.3.6

For an item of type STRING the following procedures are provided:
procedure

GET (FILE

in FILE

procedure

GET (ITEM

out

TYPE;

ITEM

out

STRING);

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

procedure PUT(FILE

in FILE TYPE;

procedure

PUT (ITEM

ITEM

STRING);

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 performed if the string is null).
12

procedure

GET_LINE(FILE

in FILE_TYPE;

ITEM

out

STRING;

LAST

out

NATURAL);

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

The exception END_ERROR is raised if an attempt is made to skip a
file terminator.
|
procedure PUTLINE(FILE

in FILE

procedure

PUTLINE(ITEM

TYPE;

ITEM

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:

In a literal string parameter of PUT, the enclosing string bracket characters
are not output. Each doubled string bracket character in the enclosed string
is output as a single string bracket character, as a consequence of the rule
for string literals (see 2.6).

A string 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.3, 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 the specification).

Values are output as decimal or based literals, without underline characters
or exponent, and preceded by a minus sign if negative. The format (which
includes any leading spaces and minus sign) can be specified by an optional
field width parameter. Values of widths of fields in output formats are of

the nonnegative integer subtype FIELD. Values of bases are of the integer
subtype NUMBER_BASE.
subtype NUMBER BASE

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

WIDTH

FIELD

DEFAULT

BASE

NUMBER BASE

NUM’WIDTH;

10;

The following procedures are provided:

procedure GET (FILE

in FILE TYPE;

ITEM

out

WIDTH

in FIELD

out NUM;

WIDTH

procedure GET (ITEM

14—65

NUM;

0);

in FIELD

0);

If the value of the parameter WIDTH is zero, skips any leading
blanks, line terminators, or page terminators, then reads a plus or
a minus sign if present, then reads according to the syntax of an
integer literal (which may be a based literal). If a nonzero value of
WIDTH is 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

comes first; any skipped leading blanks are included in the count.?3

Returns, in the parameter ITEM, the value of type NUM that

corresponds to the sequence input.
8

The exception DATA_ERROR is raised if the sequence input does

not have the required syntax or if the value obtained is not of the
subtype NUM.
9

procedure PUT(FILE

in FILE TYPE;

ITEM

in NUM;

WIDTH

BASE

in NUMBER BASE

procedure

PUT(ITEM

FIELD

DEFAULT WIDTH;

in NUM;

WIDTH

in FIELD

BASE

in NUMBER BASE

:= DEFAULT BASE);

DEFAULT WIDTH;

:= DEFAULT BASE);

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
WIDTH characters, then leading spaces are first output to make up

the difference.
12

Uses the syntax for decimal literal if the parameter BASE has the

value ten (either explicitly or through DEFAULT_BASE); otherwise,

uses the syntax for based literal, with any letters in upper case.
13

procedure

GET (FROM

STRING;

ITEM

out

NUM;

LAST

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

The exception DATA_ERROR is raised 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

ITEM

in NUM;

STRING;

BASE

in NUMBER BASE

DEFAULT BASE);

Outputs the value of the parameter ITEM to the given string,
following the same rule as for output to a file, using the length of the
given string as the value for WIDTH.
18

Examples:
package

INT

-—

default

format

-—

DEFAULT

WIDTH

new

INTEGER
IO (SMALL INT); use

used at
=

DEFAULT BASE

PUT (126) ;
PUT (=126,

7):

PUT (126,

WIDTH =>

13,

INT IO;

instantiation,

BASE =>

2);

-—

"bl26"

—-—

"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
10 and

FIXED_IO, which must be instantiated for the appropriate floating point or
fixed point type respectively (indicated by NUM in the specifications).
Values are output as decimal literals without underline characters. The

format of each value output consists of a FORE field, a decimal point, an
AF'T field, and (if a nonzero EXP parameter is supplied) the letter E and an
EXP field. The two possible formats thus correspond to:
FORE

AFT

and to:
FORE

EXP

without any spaces between these fields. The FORE field may include

leading spaces, and a minus sign for negative values. The AFT field includes
only decimal digits (possibly with trailing zeros). The EXP field includes the

sign (plus or minus) and the exponent (possibly with leading zeros).
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

DEFAULT

FORE

FIELD

DEFAULT AFT

FIELD

NUM'DIGITS-1;

DEFAULT

FIELD

EXP

For fixed point types, the default lengths of these fields are defined by the
following variables that are declared in the generic package FIXED_IO:
DEFAULT

FORE

FIELD

NUM'FORE;

DEFAULT

AFT

FIELD

NUM'AFT;

DEFAULT EXP

FIELD

The following procedures are provided:

procedure

GET(FILE

in FILE TYPE;

ITEM

out

WIDTH

in FIELD

out

in FIELD

GET (ITEM

WIDTH

NUM;

0);

NUM;

If the value of the parameter WIDTH is zero, skips any leading

blanks, line terminators, or page terminators, then reads a plus
or a minus sign if present, then reads according to the syntax of
a real literal (which may be a based literal). If a nonzero value of
WIDTH is supplied, then exactly WIDTH characters are input, or
the characters (possibly none) up to a line terminator, whichever

comes first; any skipped leading blanks are included in the count?2°

Returns, in the parameter ITEM, the value of type NUM that
corresponds to the sequence input.

The exception DATA_ERROR is raised if the sequence input does
not have the required syntax or if the value obtained is not of the

procedure

PUT(FILE

in FILE TYPE;

ITEM

in NUM;

FORE

in FIELD

AFT

in FIELD

EXP

in FIELD

PUT(ITEM

in NUM;

FIELD

nmno

subtype NUM.

DEFAULT

FORE;

DEFAULT AFT;

DEFAULT

EXP);

FORE

AFT

in FIELD

:= DEFAULT AFT;

DEFAULT FORE;

EXP

in FIELD

DEFAULT EXP);

Outputs the value of the parameter ITEM as a decimal literal with

the format defined by FORE, AFT and EXP. If the value is negative,
a minus sign 1s 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
FORE if 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 number of
digits of the fractional part is given by AFT, or is one if AFT equals
zero. The value is rounded; a value of exactly one half in the last
place may be rounded either 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

NUM;

LAST

out

POSITIVE);

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 read2®

The exception DATA_ERROR is raised 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

ITEM

in NUM;

STRING;

AFT

in FIELD

EXP

: in FIELD := DEFAULT
EXP) ;27

DEFAULT AFT;

Outputs the value of the parameter ITEM to the given string,
following the same rule as for output to a file, using a value for

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
-—
X

REAL IO

default
:

REAL

format

new FLOAT IO(REAL);
used

-123.4567;

PUT (X) ;
PUT (X,

FORE

PUT (X,

AFT

use

instantiation,

digits

——

default

EXP

REAL IO;

DEFAULT EXP

(see

format

"-1.2345670E+02"

2);

0);

3.5.7)

——

"bbb-1.235E4+2"

——

"b-123.457"

Note:
23

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

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

Values are output using either upper or lower case letters for identifiers.

This is specified by the parameter SET, which is of the enumeration type
TYPE_SET.
type

TYPE SET

(LOWER _CASE,

UPPER CASE);

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

WIDTH

DEFAULT_SETTING

14.3.9

FIELD

0O;

TYPE SET

Input-Output for Enumeration Types

UPPER_CASE;

14-70

The following procedures are provided:
procedure

GET (FILE

in FILE TYPE;

procedure

GET (ITEM

out

ITEM

out

ENUM);

ENUM)
;

After skipping any leading blanks, line terminators, or page terminators, reads an identifier according to the syntax of this lexical
element (lower and upper case being considered equivalent), or

a character literal according to the syntax of this lexical element
(including the apostrophes). Returns, in the parameter ITEM, the

value of type ENUM that corresponds to the sequence input. 28

The exception DATA_ERROR is raised 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.
8

procedure PUT(FILE

in FILE TYPE;

ITEM

in ENUM;

WIDTH

FIELD

SET

TYPE SET

procedure PUT(ITEM

in ENUM;

WIDTH

FIELD

SET

TYPE SET

DEFAULT WIDTH;

:= DEFAULT_ SETTING);

DEFAULT WIDTH;

:= DEFAULT SETTING);

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

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 of the string as
a file terminator. Returns, in the parameter ITEM, the value of type
ENUM that corresponds to the sequence input. Returns in LAST the

index value such that FROM(LAST) is the last character read.3°

28 See also Appendix G, AI-00239, A1-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_ERROR is raised 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

out

ITEM

in ENUM;

STRING;

SET

TYPE SET

:= DEFAULT SETTING);

Outputs the value of the parameter ITEM to the given string,
following the same rule as for output to a file, using the length of the
given string as the value for WIDTH.

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

There is a difference between PUT defined for characters, and for enumeration values. Thus
TEXTTIO.PUT('A’");

package

CHAR IO

outputs

is new TEXT

CHARTIO.PUT(’A’);

-—-

the

character

IO.ENUMERATION IO (CHARACTER) ;

outputs

the

——

between

single

character

’'A’,

quotes

The type BOOLEAN is an enumeration type, hence ENUMERATION_IO
can be instantiated for this type.
When a 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 10
with

IOEXCEPTIONS;

package

TEXT IO

type

FILE

TYPE

limited private;

type

FILE

MODE

(IN FILE,

type

COUNT

range

subtype

POSITIVE COUNT

UNBOUNDED

constant

OUT FILE);

implementation defined;

COUNT

range

COUNT

line

COUNT’LAST;

and

page

length

subtype

FIELD

INTEGER range

implementation defined;

subtype

NUMBER BASE

INTEGER range

16;

type

TYPE SET

(LOWER CASE,

UPPER CASE):;

File Management

procedure

CREATE

OPEN

(FILE

out

MODE

FILE

FILE TYPE;

OUT FILE;

NAME

STRING

FORM

STRING

MODE

(FILE

out

MODE

FILE MODE;

FILE TYPE;

NAME

STRING;

FORM

STRING

"");

procedure

(FILE

in out

FILE TYPE);

procedure

DELETE

(FILE

out

FILE TYPE):;

procedure

RESET

(FILE

out

FILE TYPE;

MODE

in FILE MODE) ;

in out

procedure

RESET

(FILE

function

MODE

(FILE

FILE

TYPE)

return

FILE MODE;

function

NAME

(FILE

in FILE

TYPE)

return

STRING;

function

FORM

(FILE

in FILE TYPE)

return

STRING;

function

IS OPEN(FILE

in FILE TYPE)

return BOOLEAN;

-—

Control

default

input

FILE TYPE);

and

output

files

procedure

SET

(FILE

in FILE TYPE);

procedure

SETOUTPUT(FILE

in FILE TYPE);

function

STANDARD

return

FILE

function

STANDARD_ OUTPUT

return

FILE TYPE;

function

CURRENT INPUT

return

FILE_ TYPE;

function

CURRENT_OUTPUT

return FILE TYPE;

-—

INPUT

Specification

procedure
procedure

14-73

INPUT

line

and page

SET LINE LENGTH(FILE

TYPE;

lengths

in FILE TYPE;

in COUNT);

SET LINE LENGTH
(TO

in COUNT);

Specification of the Package Text_
IO

14.3.10

procedure

SET PAGE LENGTH(FILE

in FILE TYPE;

in COUNT)
;

procedure

SET PAGE LENGTH(TO

in COUNT);

function

LINE LENGTH(FILE

function

LINE LENGTH

function

PAGE LENGTH(FILE

function

PAGE_LENGTH

——

Column,

procedure

Line,

return COUNT;

in FILE TYPE)

return COUNT;

Control

(FILE

in FILE TYPE;

SPACING

in POSITIVE COUNT

1);

procedure

NEW LINE

(SPACING

in POSITIVE COUNT

1);

procedure

SKIP

(FILE

in FILE_TYPE;

SPACING

in POSITIVE COUNT

1);

(SPACING

in POSITIVE COUNT

1);

LINE

procedure

SKIP

function

END OF LINE(FILE

function

END
OF LINE

return BOOLEAN;

procedure

NEW PAGE

(FILE

in FILE

procedure

NEW PAGE;

procedure

SKIP

(FILE

in FILE TYPE);

procedure

SKIP PAGE;

function

END OF PAGE(FILE

in FILE TYPE)

function

END
OF PAGE

function

END OF FILE(FILE

function

END
OF FILE

procedure

SET COL

LINE

PAGE

in FILE TYPE)

TYPE);

return BOOLEAN;

in FILE TYPE)

return BOOLEAN;

(FILE

in FILE TYPE;

(TO

in POSITIVE COUNT) ;
in POSITIVE_COUNT);

SET COL

procedure

SET LINE (FILE

in FILE TYPE;

in POSITIVE COUNT) ;

SET LINE (TO

in POSITIVE COUNT) ;

function COL

(FILE

function COL

return POSITIVE COUNT;

function LINE(FILE

function LINE

function PAGE
Character

in FILE TYPE)

in FILE_TYPE)

return POSITIVE COUNT;

return POSITIVE_COUNT;

return POSITIVE COUNT;

function PAGE (FILE

——

return BOOLEAN;

procedure

14.3.10

in FILE TYPE)

return COUNT;

and Page

NEW LINE

return COUNT;

in FILE TYPE)

return POSITIVE COUNT;

return POSITIVE COUNT;
Input-Output

Specification of the Package Text_IO

1474

procedure

FILE_TYPE;

ITEM

out

CHARACTER)
;

procedure

GET (ITEM

out

CHARACTER)
;

procedure

PUT (FILE

FILE TYPE;

ITEM

CHARACTER)
;

procedure

PUT(ITEM

——

Input-Output

String

procedure

GET (FILE

CHARACTER);

GET(FILE

FILE TYPE;

ITEM

out

STRING):;

procedure

GET (ITEM

out

STRING);

procedure

PUT (FILE

FILE TYPE;

ITEM

procedure

PUT(ITEM

procedure

GET LINE(FILE

ITEM

out

STRING;

LAST

out

NATURAL);

procedure
procedure
procedure

—-—

STRING)
;
STRING);
FILE TYPE;

GET LINE (ITEM

out

STRING;

LAST

out

NATURAL);

PUT LINE(FILE

ITEM

PUT_LINE(ITEM

Generic package

for

FILE TYPE;

STRING)
;
STRING)
;

Input-Output

Integer Types

generic

type
package

NUM is

range

INTEGER
IO

DEFAULT

FIELD

WIDTH

NUM’'WIDTH;

NUMBER BASE

DEFAULT BASE

procedure

<>;

GET (FILE
ITEM

WIDTH

10;

FILE TYPE;

out

NUM;

in FIELD

procedure

PUT(FILE

in FILE TYPE;

ITEM

in NUM;

WIDTH

in FIELD

BASE

in NUMBER BASE

PUT (ITEM

in NUM;

WIDTH

in FIELD

BASE

in NUMBER BASE

procedure

NUM;

WIDTH

14-75

Generic

STRING;

ITEM

out

NUM;

LAST

out

POSITIVE);

out

STRING;

ITEM

in NUM;

BASE

in NUMBER BASE

packages

FIELD

0);

:= DEFAULT BASE) ;

DEFAULT WIDTH;

GET (FROM

PUT (TO

DEFAULT WIDTH;

end INTEGER IO;
—--

0);

GET (ITEM

procedure

out

procedure

:= DEFAULT BASE);

DEFAULT BASE);

|
for

Input-Output

Real

Types

Specification of the Package Text
IO

14.3.10

generic
type NUM is

digits

package FLOAT
IO

<>;

DEFAULT FORE

FIELD

DEFAULT AFT

FIELD

NUM'DIGITS-1;

FIELD

DEFAULT EXP

procedure

GET (FILE

in FILE TYPE;

ITEM

out

WIDTH

in FIELD

GET (ITEM

procedure PUT (FILE

out
:

ITEM

0);
:

in FIELD

in FILE_TYPE;

FORE

in FIELD

:= DEFAULT FORE;

in FIELD

:= DEFAULT AFT;

:= DEFAULT EXP):;

FIELD

in NUM;

FORE

AFT

in FIELD

:= DEFAULT AFT;

in FIELD

:= DEFAULT EXP);

EXP

end

WIDTH

AFT
EXP

procedure

NUM;

in NUM;

procedure PUT (ITEM

procedure

NUM;

GET (FROM

FIELD

STRING;

ITEM

out

NUM;

LAST

out

PUT (TO

out

DEFAULT FORE;

POSITIVE);

STRING;

ITEM

in NUM;

AFT

in FIELD

:= DEFAULT AFT;

EXP

in FIELD

:= DEFAULT EXP);

delta

<>;

FLOAT IO;

generic
type NUM is

package FIXED
IO

DEFAULT FORE

FIELD

NUM’FORE;

DEFAULT

AFT

FIELD

NUM'AFT;

DEFAULT

EXP

FIELD

procedure

GET (FILE

ITEM

WIDTH

NUM;

FIELD

NUM;

0);

procedure

GET (ITEM

out

procedure

PUT(FILE

in FILE TYPE;

WIDTH

in FIELD

ITEM

in NUM;

FORE

in FIELD

AFT

in FIELD

:= DEFAULT AFT;

EXP

procedure

14.3.10

FILE TYPE;

out

PUT (ITEM

FIELD

DEFAULT FORE;
DEFAULT EXP);

in NUM;

FORE

in FIELD

DEFAULT FORE;

ART

in FIELD

DEFAULT AFT;

EXP

in FIELD

:= DEFAULT EXP);

Specification of the Package Text_IO

procedure

GET (FROM

STRING;

ITEM

out

NUM;

LAST

out

POSITIVE):;

out

STRING;

PUT (TO

in NUM;

ITEM
AFT

in FIELD

DEFAULT_AFT;

EXP

in FIELD

DEFAULT_EXP);

end FIXED IO;
——

Generic

package

for

Input-Output

of Enumeration Types

generic

type ENUM is (<>);
ENUMERATION
IO

package

DEFAULT

WIDTH

DEFAULT SETTING

FIELD

TYPE SET

procedure

GET (FILE

procedure

GET (ITEM

out

procedure

PUT (FILE

ITEM

procedure

TYPE;

ITEM

out

ENUM)
;

ENUM)
;
FILE TYPE;

in ENUM;

WIDTH

in FIELD

= DEFAULT WIDTH;

SET

:= DEFAULT SETTING) ;

procedure PUT (ITEM

procedure

FILE

UPPER CASE;

TYPE SET

in ENUM;

WIDTH

in FIELD

SET

in TYPE SET

:= DEFAULT SETTING) ;

GET (FROM

STRING;

ITEM

out

ENUM;

LAST

out

POSITIVE)
;

PUT (TO

out

STRING;

ITEM

ENUM;

SET

TYPE SET

DEFAULT WIDTH;

DEFAULT SETTING) ;

end ENUMERATION
IO;
—-—-

Exceptions

STATUS_ERROR

exception

renames

IOEXCEPTIONS .STATUS ERROR;

MODE_ERROR

exception

renames

IOEXCEPTIONS .MODE_ERROR;

NAME ERROR

exception

renames

USE_ERROR

exception renames

IO EXCEPTIONS .NAME_ERROR;

IOEXCEPTIONS .USE_ERROR;

DEVICE _ERROR

exception renames

IOEXCEPTIONS .DEVICE_ERROR;

END ERROR

exception

renames

IOEXCEPTIONS .END_ERROR;

DATA ERROR

exception

renames

IOEXCEPTIONS .DATA ERROR;

LAYOUT ERROR : exception renames IOEXCEPTIONS .LAYOUT ERROR;

private
——

implementation-dependent

end TEXT IO;

1477

Specification of the Package Text_1I0

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 named in 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_ERROR are raised;
for full details see Appendix F. If more than one error condition exists, the
corresponding exception that appears earliest in the following list is the one
that is raised.

In VAX Ada, DEVICE_ERROR is 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_ERROR are raised; Appendix F summarizes these conditions.
2

The exception STATUS_ERROR is raised by an attempt to operate upon a
file that is not open, and by an attempt to open a file that is already open.

The exception MODE_ERROR is raised by an attempt to read from, or test
for the end of, a file whose current mode is OUT_FILE, and also by an

attempt to write to a file whose current mode is IN_FILE. In the case of
TEXT_IO, the exception MODE_ERROR is also raised by specifying a file

whose current mode is OUT_FILE in a call of SET_INPUT, SKIP_LINE,
END_OF_LINE, SKIP_PAGE, or END_OF_PAGE; and by specifying a file
whose current mode is IN_FILE in a call of SET_OUTPUT, SET _LINE_
LENGTH, SET_PAGE_LENGTH, LINE_LENGTH, PAGE_LENGTH, NEW_
LINE, or NEW_PAGE.
4

The exception NAME_ERROR is raised by a call of CREATE or OPEN if the
string given for the parameter NAME does not allow the identification of an

external file. For example, this exception is raised if the string is improper,
or, alternatively, if either none or more than one external file corresponds to

the string3!
5

The exception USE_ERROR is raised 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 external file with the given name already exists and overwriting is not

allowed.32

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_ERROR is raised if an input-output operation
cannot be completed because of a malfunction of the underlying system.

The exception DEVICE_ERROR is never raised in VAX Ada. Any devicerelated errors will raise the exception USE_ERROR.

The exception END_ERROR is raised by an attempt to skip (read past) the
end of a file.

The exception DATA_ERROR may be raised 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_
I0) if the input character sequence fails to satisfy the required syntax, or if
the value input does not belong to the range of the required type or subtype.
The exception LAYOUT_ERROR is raised (in text input-output) by COL,
LINE, or PAGE if the value returned exceeds COUNT' LAST. The exception
LAYOUT_ERROR is 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 unbounded cases). It is also raised by an attempt
to PUT too many characters to a string.

The exception LAYOUT_ERROR may also be raised in VAX Ada by the
GET_ITEM and PUT _ITEM procedures in the mixed-type packages.
LAYOUT ERROR is 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 may also 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 named in the context clause for the
packages RELATIVE_IO, RELATIVE_MIXED_IO, INDEXED_IO, and
INDEXED_MIXED_IO.

The exception LOCK_ERROR is raised by the READ or READ_EXISTING
procedures if the result is a locked record error in a relative or indexed file.
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_ERROR is raised by the READ or READ_
EXISTING procedures if the element to be read cannot be found in a
relative or indexed file.

The exception KEY_ERROR is raised in an indexed file if the key has been
changed or duplicated and changes or duplicates are not permitted. The
exception KEY_ERROR is also raised by the READ_BY_KEY procedures if
the size of the given key is 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 IO_Exceptions
1

This package defines the exceptions needed by the packages SEQUENTIAL
_
I0, DIRECT_IO, and TEXT _IO.

package

IOEXCEPTIONS

STATUS_ERROR

exception;

MODE ERROR

exception;

NAME ERROR

exception;

USE_ERROR

exception;

DEVICE
END

end

ERROR

exception;

DATA ERROR

exception;

LAYOUT _ERROR

exception;

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

LOCK_ERROR

EXISTENCE ERROR

exception;

KEY ERROR

exception;

end AUX

14.5a

IOEXCEPTIONS

exception;

IOEXCEPTIONS;

Specification of the Package Aux_IO_Exceptions

14-80

14.6

Low Level Input-Output
VAX Ada does not provide the package LOW_LEVEL_IO. The library
packages STARLET and TASKING_SERVICES provide related 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.

A procedure SEND_CONTROL may be used to send control information to a
physical device. A procedure RECEIVE_CONTROL may be 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 procedures is outlined as
follows:

package LOWLEVEL
IO is
—-—
declarations of the possible types

for DEVICE and DATA;
——
declarations of overloaded procedures for these types:
procedure SEND CONTROL
(DEVICE : device type;

procedure RECEIVE CONTROL

DATA

in out

(DEVICE

device_type;

data type);

DATA

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,_
I0. These procedure bodies may be written with code statements.

33 SQee 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 responds by giving the number of items of

that color available in stock, according to an inventory. The default input
and output files 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 TEXT IO;
procedure

type

use

TEXT IO;

DIALOGUE

COLOR

package

(WHITE,

COLOR IO

RED,

package NUMBER
IO is
use

COLOR_TIO,

INVENTORY

CHOICE

ORANGE,

YELLOW,

GREEN,

new ENUMERATION
IO (ENUM =>

new

BLUE,

BROWN)
;

COLOR)
;

INTEGE
IO (INTEGER)
R
;

NUMBER_ IO;

array

(COLOR)

INTEGER

(20,

17,

28,

173,

COLOR)

43,

10,

87);

COLOR;

procedure

ENTER_COLOR

(SELECTION

out

begin
loop

begin
PUT ("Color

selected:

");

GET (SELECTION) ;

prompts

user

—-—

accepts

color

——

oOr

raises

typed,

exception

return;

exception
when DATA ERROR

PUT ("Invalid

color,

——

typed

user

has

try
new

again.

");

line

NEW _LINE (2) ;

—-—

completes

execution

the

statement

the

block

statement

end;

end loop;

repeats

block

until

color

end;
begin

statements

accepte

DIALOGUE;

NUMBER IO.DEFAULT WIDTH

loop
ENTER COLOR (CHOICE);

user

types

SET_COL(5);

PUT(CHOICE);

SET

COL(40);

PUT(INVENTORY (CHOICE));

NEW

LINE;

PUT("

items

color

and

new

line

available:");
--

default

width

end loop;
end DITALOGUE;

14.7

Example of Input-Output

14-82

Example of an interaction (characters typed by the user are italicized):
Color

selected:

Black

Invalid color,
Color

selected:

BLUE
Color

try again.

items

Blue

available:

selected:

173

Yellow

YELLOW items avallable:

14.7a

Example of Additional VAX Ada Input-Output
This example shows the use of the additional VAX Ada input-output package
SEQUENTIAL_MIXED
IO. This program reads values of mixed types from
different records and then processes the values for output to an array.
with SEQUENTIAL MIXED IO;

use SEQUENTIAL MIXED IO;

procedure READ FILE (FILE NAME

type FLOAT ARRAY is array
F_ARRAY

FLOAT

F2,

F3,

FLOAT;

I1,

I5,

INTEGER;

FILE

Instantiate

procedure

STRING)

(INTEGER range <>)

ARRAY (1l

LAST

of FLOAT;

100);

TYPE;

GET ITEM for each type

GET INTEGER is

in the

file.

new GET ITEM(INTEGER)
;

procedure GET FLOAT is new GET ITEM (FLOAT);
procedure

~—

GET STRING

Instantiate

new GET_ITEM(STRING)
;

GET ARRAY

for a

procedure GET FLOAT ARRAY
new

—-—

GET

ARRAY (FLOAT,

Procedure

procedure

sequence

floating values.

INTEGER,

FLOAT ARRAY)

for processing the values

PROCESS

ARRAY (FA

LAST

FLOAT

INTEGER)

ARRAY;

is separate;

begin

OPEN(FILE,

IN FILE,

—— Read the

first

FILE_ NAME);

record consisting of an

integer and two

floating values.

READ (FILE) ;

GET INTEGER(FILE,

GET

14-83

I1);

FLOAT (FILE,

F2);

GET _FLOAT (FILE,

F3);

Example of Additional VAX Ada Input-Output

14.7a

——

Read the

-—-

1integers.

second

record

consisting

floating

value

and

two

READ (FILE) ;

GETFLOAT(FILE,

F4);

GET INTEGER (FILE,

I5);

GETINTEGER(FILE,

I6);

——

The

——

(each

which

contains

-—

values),

which

are

remainder

the

file
a

consists

variable

number

100

processed

number
at

records

Ffloating

time.

READ (FILE) ;

loop
if

END_OF BUFFER(FILE)

then

READ (FILE) ;

end if;
GET_FLOAT_ARRAY (FILE,

F_ARRAY,

PROCE
ARRAY (F SS
ARRAY,

LAST);

end loop;
CLOSE (FILE) ;

exception
when END

ERROR

CLOSE (FILE);

end READ FILE;

14.7a

Example of Additional VAX Ada Input-Output

14—84

Annex A

Predefined Language Attributes

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 the first 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 ADDRESS defined in
the package SYSTEM. (See 13.7.2.)

P’ AFT

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’ DELTA is 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

PAST _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 the first bit of the storage
for the object P. The value of this attribute is
of the type universal_integer. (See 13.7.2.)
5

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

P CONSTRAINED

For a prefix P that denotes an object of a type

with discriminants:
Yields the value TRUE if 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 Language Attributes

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 subtype is 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 number of entry calls presently
queued on the entry (if the attribute is

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 universal_integer. (See 9.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.)
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 numbers of 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 universal_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 number above, for the subtype

P. The value of this attribute is of the type
universal_real. (See 3.5.8.)
13

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 component of 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.)
17

P'FORE

For a prefix P that denotes a fixed point
subtype:
Yields the minimum number of 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 image of an integer

value is the corresponding decimal literal;
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 character literal (including
the two apostrophes); neither leading nor

trailing spaces are included. The image of a
character other than a graphic character is
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.)
20

P’ LAST

For a prefix P that denotes a scalar type, or a

subtype of a scalar type:

Yields the upper bound of P. The value of this
attribute has the same type as 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 bound of the first index
range. The value of this attribute has the
same type as this upper bound. (See 3.6.2

and 3.8.2.)
22

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 universal_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 number of values of the first index
range (zero for a null range). The value of

this attribute is of the type universal_integer.
(See 3.6.2.)

P LENGTH(N)

For a prefix P that is appropriate for an array

type, or that denotes a constrained array

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

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

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 value of this attribute
is of the type universal_integer. (See 13.7.3.)
P MACHINE_MANTISSA

For a prefix P that denotes a floating point
type or subtype:

Yields the number of 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'MACHINE OVERFLOWS

For a 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_ERROR in overflow
situations; yields the value FALSE otherwise.
The value of this attribute is of the predefined
type BOOLEAN. (See 13.7.3.)
so

P'MACHINE_RADIX

For a prefix P that denotes a floating point
type or subtype:

Yields the value of the radix used by the
machine representation of the base type of
P. The value of this attribute is of the type
universal_integer. (See 13.7.3.)
31

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 machine bits 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 attribute is of the type universal_integer.

(See 13.7.2.)
22

P MANTISSA

For a prefix P that denotes a real subtype:

Yields the number of binary digits in the
binary mantissa of model numbers of 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.)
PNULL_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.)

PrPOS

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 number of the value of the actual
parameter. (See 3.5.5.)

s«

P’POSITION

For a prefix P that denotes a component of a

record object: 1

Yields the offset, from the start of the first
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.)

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 number is one less than that
of X. The exception CONSTRAINT_ERROR is

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

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 of P, 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
number E of section 3.5.7.) The value of this
attribute is of the type universal_integer.
(See 3.5.8.)
39

P'SAFE_LARGE

For a prefix P that denotes a real type or

subtype:
Yields the largest positive safe number of the

base type of P. The value of this attribute is
of the type universal_real. (See 3.5.8

and 3.5.10.)
40

P'SAFE_SMALL

For a prefix P that denotes a real type or

subtype:
Yields the smallest positive (nonzero) safe

number of the base type of P. The value of
this attribute is of the type universal_real.
(See 3.5.8 and 3.5.10.)
41

P’ SIZE

For a prefix P that denotes an object:

Yields the number of bits allocated to hold

the object. The value of this attribute is of
the type universal_integer. (See 13.7.2.)
42

P’ SIZE

For a prefix P that denotes any type or
subtype:

A-10

Predefined Language Attributes

Yields the minimum number of bits 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
untversal_integer. (See 13.7.2.)
43

P'SMALL

For a prefix P that denotes a real subtype:
Yields the smallest positive (nonzero) 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.)
44

P'STORAGE_SIZE

For a prefix P that denotes an access type or
subtype:

Yields the total number of storage units
reserved for the collection associated with the
base type of P. The value of this attribute is

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

PSUCC

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 number is one greater
than that of X. The exception CONSTRAINT
_

ERROR is 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 TRUE if 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_CLASS in the package SYSTEM.
(See 13.7a.2.)
s

PrVAL

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 number is the universal_integer
value corresponding to X. The exception
CONSTRAINT_ERROR is 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.)
a3

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 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 P, the result is this
value. In any other case, the exception
CONSTRAINT_ERROR is raised. (See 3.5.5.)

A-12

Predefined Language Attributes

P'WIDTH

For a prefix P that denotes a discrete subtype:
Yields the maximum image length 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 |

Anhex

Predefined Language Pragmas

This annex defines the pragmas LIST, PAGE, and OPTIMIZE, and

summarizes the definitions given elsewhere of the remaining languagedefined pragmas.

The VAX Ada pragmas IDENT and TITLE are also defined in this annex.

Pragma

Meaning

AST _ENTRY

Takes the simple name of a single entry
as the single argument; at most one

AST_ENTRY pragma is 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 VMS asynchronous
system trap (AST) resulting from a VMS
system service call. The pragma does
not affect normal use of the entry (see
9.12a).
2

CONTROLLED

Takes the simple name of 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
pragma specifies 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).
s

ELABORATE

Takes one or more simple names

denoting library units as arguments.
This pragma is 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 name of a library unit
mentioned by the context clause. This
pragma specifies 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

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 pragma is 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
B—2

Predefined Language Pragmas

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 name of a
VMS Linker global symbol), parameter
types, and result type as arguments.

This pragma is 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 pragma is only
allowed after the function declaration
and before any subsequent compilation
unit. This pragma is 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
VMS Linker global symbol whose value
is the size, in bytes, of the exported
object) as arguments. This pragma is
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 pragma is not allowed for objects

declared with a renaming declaration,
and is not allowed in a generic unit.
This pragma permits an Ada object to
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 pragma is
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 pragma is only allowed

after the procedure declaration and
before any subsequent compilation

unit. This pragma is 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 pragma is

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 pragma is 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 is

not allowed for a procedure declared
with a renaming declaration and is 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 causes side effects

on its parameters when it 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 IDENT has the following form:
pragma

IDENT

(string literal);

This pragma is 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

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 is allowed only when the
form is VMS (the default if the form
1s not specified). This pragma is 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. 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 name of a
VMS Linker global symbol), parameter

Predefined Language Pragmas

B-5

types, parameter mechanisms, result

mechanism, and a first optional
parameter as arguments. The pragma

INTERFACE must be used with this
pragma (see 13.9). This pragma is 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 pragma is only allowed after

the function declaration and before

any subsequent compilation unit.
This pragma is allowed for a function
declared with a renaming declaration;
it is not allowed for a generic function
or a generic 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 value is the size

in bytes of the imported object) as
arguments. This pragma is 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 pragma is 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, and a first
optional parameter as arguments. The
pragma INTERFACE must be used with
this pragma (see 13.9). This pragma is

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 pragma is only allowed after
the procedure declaration and before

any subsequent compilation unit. This
pragma is 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, and a first
optional parameter as arguments. The
pragma INTERFACE must be used with
this pragma (see 13.9). This pragma is
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 pragma is 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 causes side effects
on its parameters to be used as an Ada

procedure (see 13.9a.1.1).
4

INLINE

Takes one or more names as arguments;
each name is either the name of a

subprogram or the name of 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
expanded inline at each call whenever
possible; in the case of a generic
subprogram, the pragma applies to calls
of its instantiations (see 6.3.2).

INLINE_GENERIC

Takes one or more names as arguments;
each name is either the name of a

generic declaration or the name of an

instance of a generic declaration. 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. 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
inline expansion of the generic body
is desired for each instantiation of the
named generic declarations or of the
particular named instances; the pragma

B-8

Predefined Language Pragmas

does not apply to calls of instances of

generic subprograms (see 12.1a).
5

INTERFACE

Takes a language name and a

subprogram name as arguments. This
pragma is 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 pragma is 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_PROCEDURE when any of
those pragmas are used (see 13.9a.1).
6

LIST

Takes one of the identifiers ON or

OFF as the single argument. This
pragma is allowed anywhere a pragma

1s allowed. It specifies that listing of

the compilation is to be continued or
suspended until a LIST pragma with the
opposite argument is given within the
same compilation. The pragma itself is

always listed if the compiler is producing
a listing.

LONG_FLOAT

Takes either D_FLOAT or G_FLOAT
as the single argument. The default is
G_FLOAT. This pragma is 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_FLOAT in the
package STANDARD, and for floating
point type declarations with digits

specified in the range 7..15 (see 3.5.7a).
MAIN_STORAGE

Takes one or two nonnegative static
simple expressions of some integer type
as arguments. This pragma is only

allowed in the outermost declarative
part of a library subprogram; at most
one such pragma is 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
number of 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 pages is rounded
up to an integral number of 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).
7

MEMORY_SIZE

Takes a numeric literal as the single
argument. This pragma is 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 MEMORY_SIZE (see 13.7).
8

OPTIMIZE

Takes one of the identifiers TIME

or SPACE as the single argument.
This pragma is only allowed within a
declarative part and it applies to the

block or body enclosing the declarative

B-10

Predefined Language Pragmas

part. It specifies whether time or space
is the primary optimization criterion.

In VAX Ada, this pragma is only allowed
immediately within a declarative part of
a body declaration.
9

PACK

Takes the simple name of a record or
array type as the single argument. The
allowed positions for this pragma, and
the restrictions on the named type,
are governed by the same rules 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).

PAGE

This pragma has no argument, and is
allowed anywhere a pragma is allowed.
It specifies that the program text which
follows the pragma should start on a
new page (if the compiler is currently
producing a listing).

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 Linker global
symbol whose value is interpreted as the
size, in bytes, of the exported/imported
object) as arguments. This pragma is
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 pragma is 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).

SHARED

Takes the simple name of a variable as
the single argument. This pragma is
allowed only for a variable declared by
an object declaration and whose type
1s 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. 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 pragma is
allowed to objects for which each of
direct reading and direct updating is
implemented as an indivisible operation

(see 9.11).
SHARE_GENERIC

Takes one or more names as arguments;

each name is either the name of a
generic declaration or the name of an
instance of a generic declaration. 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. 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.
B-12

Predefined Language Pragmas

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 pragma is 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 pragma is 8 (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 pragma is 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 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 named object
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 and is
only allowed following a compilation
unit. This pragma specifies that all runtime checks in the unit are suppressed
(see 11.7).

SYSTEM_NAME

Takes an enumeration literal as the
single argument. This pragma is 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 enumeration
literal with the specified identifier for
the definition of the constant SYSTEM_
NAME. This pragma is only allowed if
the specified identifier corresponds to
one of the literals of the type NAME

declared in the package SYSTEM
(see 13.7).

TASK_STORAGE

B-14

Predefined Language Pragmas

Takes the simple name of a task
type and a static expression of some
integer type as arguments. This
pragma is 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 must both 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 number of 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 pragma to be ignored (see 13.2a).

TIME_SLICE

Takes a static expression of the
predefined fixed point type DURATION
(in the package STANDARD) as the

single argument. This pragma is only
allowed in the outermost declarative

part of a library subprogram, and at
most one such pragma is 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 specifies the nominal
amount of elapsed time permitted for
the execution of a task when other tasks
of the same priority 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 a title or a subtitle string, or both,
as arguments. The pragma TITLE has

the following form:
pragma

TITLE

(titling-option

[,titling-optionl);

titling-option
[TITLE

=>]

[SUBTITLE

:=
string literal

=>]

string literal

This pragma is allowed anywhere a
pragma is allowed; the given strings

supersede the default title and/or

subtitle portions of a compilation listing.
VOLATILE

Takes the simple name of 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 name of

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 VOLATILE specifies
that the variable may be modified
asynchronously. This pragma instructs

the compiler to obtain the value of a
variable from memory each time it is

used (see 9.11).

B-16

Predefined Language Pragmas

Annex

Predefined Language Environment

This annex outlines the specification of the package STANDARD containing

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
STANDARD are given in comments since they are implicitly declared.
Italics are used for pseudo-names of anonymous types (such as universal_
real) and for undefined information (such as implementation_defined and
any_fixed_point_type).
package

STANDARD

type BOOLEAN is

(FALSE,

TRUE);

-—

The predefined relational

~-—

-—

function

"="

(LEFT,

RIGHT

BOOLEAN)

-—

function

"/="

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-—

function

"<"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

——

function

"<="

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-—

function

">"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-—

function

">="

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

—-—

The predefined logical

—-—

negation

operator

-—

function

"and"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

—-—

function

"or"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

-—

function

"xor"

(LEFT,

RIGHT

BOOLEAN)

return BOOLEAN;

—-—

function

"not"

(RIGHT

-—

The universal type

type
-—

operators

for this

type are

follows:

are

operators
as

return BOOLEAN;

and the predefined logical

follows:

BOOLEAN)

return BOOLEAN;

universal integer is predefined.

INTEGER is implementation defined;

The predefined operators

for this type

are

follows:

Predefined Language Environment

C-1

function

(LEF'T,

RIGHT

INTEGER)

return BOOLEAN;

function

" /__..u

(LEFT,

RIGHT

INTEGER)

return

function

nen

(LEFT,

RIGHT

INTEGER)

return BOOLEAN;

function

(LEF'T,

RIGHT

INTEGER)

return BOOLEAN;

function

s
n

(LEF'T,

RIGHT

INTEGER)

return BOOLEAN;

function

(LEE'T,

RIGHT

INTEGER)

return

function

l'+||

function

INTEGER)

return

INTEGER;

(RIGHT

INTEGER)

return

INTEGER;

INTEGER)

return

INTEGER;

function

w abs n

(RIGHT

function

"+"

(LEF'T,

RIGHT

INTEGER)

return

INTEGER;

function

(LEF'T,

RIGHT

INTEGER)

return

INTEGER;

function

MmN

(LEFT,

RIGHT

INTEGER)

return

INTEGER;

function

" / n

(LEFT,

RIGHT

INTEGER)

return

INTEGER;

function

11 remn

(LEF'T,

RIGHT

INTEGER)

return

INTEGER;

function

llmodll

(LEFT,

RIGHT

INTEGER)

return

INTEGER;

function

(LEF'T

INTEGER;

RIGHT

INTEGER)

implementation may provide

with

recommended that
INTEGER as

cation of
any

the

each operator

INTEGER

the

name

for the

right

operand of

the

SHORT INTEGER is

type

SHORT_SHORT_INTEGER is

type FLOAT

type

type
in

the

type

predefined

such additional
LONG_INTEGER.

type

INTEGER;

integer types

types
The

universal integer,
is

the

obtained by

except

for

replacing

specification of

INTEGER,

end

specifi-

the

for the

exponentiating operator.

type

universal

integer type,

the

operator

return

additional

names

SHORT INTEGER

additional predefined

corresponding

implementation defined;

universal real

predefined.

implementation defined;

The predefined operators

for this

type

are

follows:

function

Wit

(LEFT,

RIGHT

FLOAT)

return BOOLEAN;

function

" /zn

(LEFT,

RIGHT

FLOAT)

return

BOOLEAN;

function

Hen

(LEFT,

RIGHT

FLOAT)

return

BOOLEAN;

function

Ng=mn

(LEFT,

RIGHT

FLOAT)

return BOOLEAN;

function

wsn

(LEFT,

RIGHT

FLOAT)

return

function

(LEFT,

RIGHT

FLOAT)

return BOOLEAN;

function

"+|l

(RIGHT

function

C—2

BOOLEAN;

(RIGHT

The

BOOLEAN;

FLOAT)

return

FLOAT;

(RIGHT

FLOAT)

return

FLOAT;

FLOAT)

return FLOAT;

BOOLEAN;

function

" abs "

(RIGHT

function

"+||

(LEF'T,

RIGHT

FLOAT)

return FLOAT;

function

(LEF'T,

RIGHT

FLOAT)

return

function

"
n

(LEFT,

RIGHT

FLOAT)

return FLOAT;

function

n/n

(LEFT,

RIGHT

FLOAT)

return

function

Mk it

(LEF'T

Predefined Language Environment

FLOAT;

RIGHT

FLOAT;

INTEGER)

return FLOAT;

An implementation may provide additional predefined floating point
types. It is recommended that the names of such additional types
of

each

operator

predefined
the

name

The

in SHORT FLOAT or LONG_FLOAT.

end with FLOAT as

for

the type

universal real,

specification

or for any additional

floating point type, is obtained by replacing FLOAT by
type in the specification of the corresponding

the

operator of the

type

FLOAT.

type LONG FLOAT is implementation_defined;
type LONG LONG FLOAT is implementation_ defined;
In addition,
universal

the

following operators are predefined for

types:

-- function "*"

(LEFT

universal integer;

-— function "*"

RIGHT
(LEFT
RIGHT

universal real)
universal real;
universal integer)

(LEFT

universal real;

-—

function

"/"

-— The type

universal fixed is predefined.

—— declared

for this

—-—

function

return

universal real;

return

universal real;

The

only

operators

type are

(LEFT

any fixed point type;

RIGHT

any fixed point type)

-return universal fixed;
-— function "/" (LEFT
any fixed point type;

RIGHT

-The

return

any fixed point_type)

universal fixed;

following characters

form the

standard ASCII

character

set.

literals corresponding to control characters are not
identifiers;
they are indicated in italics in this definition.

Character

type CHARACTER is

(nul,

soh,

stx,

etx,

eot,

engq,

ack,

bs,

ht,

1f,

vt,

ff,

cr,

S0,

dle,

dcl,

dec2,

dc3,

can,

em,

sub,

esc,

fs,

gs,

l!l’

Illl,

I#l’

I$I,

l%lr

l&l”

III,

I(l’

l)l,

r*r’

r+r,

r’r’

I_I,

r.r

l/l,

IOI’

IlI’

l’

I4l’

I5I,

I6I’

I7I’

I8I’

191’

I:l'

I;I,

I<I,

I.._...I’

I>I'

I?I’

I@l’

lAl,

IBI’

ICI’

IDI’

IEI'

IFI’

fGl,

IHI,

III’

IJI,

IKI’

ILI’

IMI,

IN”

IOI'

IPl’

IQI,

IRI’

ISI’

ITI

IUI’

IVI,

IWI’

IXI,

IYI’

IZI’

l[l’

I\l’

I]I’

IAI'

I——I

I\I'

IaI,

IbI’

’C’,

de’

fe!,

lfI’

IgI’

lhI,

IiI’

Ijl’

IkI’

llI’

Iml,

InI,

lol,

IpI’

Iql,

Irl,

ISI,

ltl’

IuI'

’V’,

’W’,

’X’,

Iyr’

’Z’,

l{l’

III,

I}I,

I~I,

del);

;

dc4,

nak,

syn,
rs,

bel,

si,
etb,
us,

Predefined Language Environment

C-3

for

CHARACTER use

(0,

128
5,

for CHARACTER'’SIZE use
The

predefined operators

the

type

constant

CHARACTER

nul;

SOH

constant

CHARACTER

characters:

NUL

soh;

STX

constant

CHARACTER

stx;

ETX

constant

CHARACTER

etx;

EOT

constant

CHARACTER

eot;

ENQ

constant

CHARACTER

enq;

CHARACTER

ack;

constant

CHARACTER

bel;

constant

CHARACTER

constant

CHARACTER

constant

BEL

bs;

ACK

ht;

constant

CHARACTER

constant

CHARACTER

constant

CHARACTER

constant

CHARACTER

constant

CHARACTER

constant

CHARACTER

sSi;

DLE

constant

CHARACTER

dle;

1f;
vt;

f££f;
cr;
S0;

constant

CHARACTER

dcl;

constant

CHARACTER

dcZ2;

DC3

constant

CHARACTER

DC4

constant

CHARACTER

NAK

constant

CHARACTER

SYN

constant

CHARACTER

syn;

ETB

constant

CHARACTER

etb;

CAN

constant

CHARACTER

constant

CHARACTER

nak;

can;

dc3;
dc4;

em;

SUB

constant

CHARACTER

sub;

ESC

constant

CHARACTER

DC1

DC2

esc;

constant

CHARACTER

£s;

constant

CHARACTER

constant

CHARACTER

gs;

constant

CHARACTER

DEL

constant

CHARACTER

—-—

C-4

for

Control

QOther

characters:

Predefined Language Environment

without

holes

for any enumeration type.

package ASCII

set

127);

126,

——

-- as

character

125,

rs;

ASCII
.,

us;

del;

CHARACTER

are

the

same

EXCLAM

constant

CHARACTER

QUOTATION

constant

CHARACTER

"1/;
"""/,

SHARP

constant

CHARACTER

'#’;

DOLLAR

constant

CHARACTER

’$’;

PERCENT

constant

CHARACTER

5%/

AMPERSAND

constant

CHARACTER

’"&’;

COLON

constant

CHARACTER

’":/;

SEMICOLON

constant

CHARACTER

’;';

QUERY

constant

CHARACTER

’'7?/;

SIGN

constant

CHARACTER

’'@’;

L BRACKET

constant

CHARACTER

' [’;

BACK_SLASH

constant

CHARACTER

'\’;

R BRACKET

constant

CHARACTER

’]/';

CIRCUMFLEX

constant

CHARACTER

’'"/;

UNDERLINE

constant

CHARACTER

rr;

GRAVE

constant

CHARACTER

7 ‘/;

constant

CHARACTER

' {’;

BAR

BRACE

constant

CHARACTER

' |';

R_BRACE

constant

CHARACTER

'}';

TILDE

constant

CHARACTER

’'~';

——

Lower

case

letters:

LC A

constant

CHARACTER

’"a’;

constant

CHARACTER

'z’;

end ASCII;
~—

Predefined

subtypes:

subtype NATURAL

INTEGER

range

INTEGER’ LAST;

subtype

INTEGER

range

INTEGER" LAST;

——

POSITIVE

Predefined

type

STRING

pragma

string

type:

array(POSITIVE

range

<>)

CHARACTER;

PACK (STRING) ;

The predefined operators

for this type

are

follows:

——

function

"="

(LEFT,

RIGHT

STRING)

——

function

"/="

(LEFT,

RIGHT

STRING)

return BOOLEAN;

——

function

"<"

(LEFT,

RIGHT

STRING)

return

—-—

function

"<="

(LEFT,

RIGHT

STRING)

return BOOLEAN;

——

function

">"

(LEFT,

RIGHT

STRING)

return BOOLEAN;

——

function

">="

(LEFT,

RIGHT

STRING)

return BOQOLEAN;

—-—

function

"&"

——

STRING)

"&"

(LEFT

CHARACTER;

RIGHT

STRING)

function

"&"

(LEFT

STRING;

RIGHT

CHARACTER)

function

"&"

(LEFT

CHARACTER;

—-—

STRING;

RIGHT
.:

function

——

(LEFT

RIGHT : CHARACTER)

return BOOLEAN:;
BOOLEAN;

return

STRING;

return

STRING;

return

STRING;

return STRING;

Predefined Language Environment

C-5

type

DURATION

range

delta

implementation defined

implementation defined;

for DURATION’SIZE use

32;

——- The predefined operators
—-20

——-

The

for

any

fixed point

for the type DURATION are the

same

type.

predefined exceptions:

CONSTRAINT ERROR

exception;

NUMERIC_ERROR

exception;

PROGRAM ERROR

exception;

STORAGE ERROR

exception;

TASKING ERROR

exception;

end STANDARD;

Certain aspects of the predefined entities cannot be completely described in

the language itself. For example, although the enumeration type BOOLEAN
can be written showing the two enumeration literals FALSE and TRUE, the

short-circuit control forms cannot be expressed in the language.
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

Glossary

This appendix is informative and is 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.
Access type.

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 are all 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 must lie in the correct index range.
Assignment.

Assignment is the operation that replaces the current value of a variable
by a new value. An assignment statement specifies a variable on the left,
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 VMS system services to transfer control to a
user-specified procedure when an asynchronous event 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
named entity; 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 statement is 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 formal types.
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 means of one or more with clauses.
Component.
A component is 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 value is a 32-bit value used to uniquely identify a VAX
exception condition.

Constant.
See object.

Contiguous array.
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 f{ype. 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 where it 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 name is said to denote the associated entity.
Declarative Parti.

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 values are 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 needed to 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 ordered set of 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
achieves its 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 is called; its internal behavior is specified
by one or more accept statements specifying the actions to be performed
when the entry 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 name has the 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 name of 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 subprograms or for a set

of packages. A subprogram or package created using the template is
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 parameter is 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 VMS Linker resolves global symbols (that is, the linker matches
references with definitions).

Handler.

See exception.
Index.

See array type.

D-6

Gilossary

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 may also 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 r.epresent 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

Membership test.
A membership test 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 number is 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 and of their
operations are the minimal properties preserved by all implementations

of the real type.
Name.
A name is 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 named association specifies the association of an item with one or

more positions in a list, by naming the positions.

Noncontiguous array.
A noncontiguous array is a VAX descriptor class. A noncontiguous array

is one in which the storage of the array components may be allocated
with a fixed, nonzero number of 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

Gilossary

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 parameter is one of the named entities 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 named entity 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
whether the 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 subprogram 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 management attributes. Program sections
with the same attributes are gathered by the VMS Linker to form an

1mage section.
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 18
specified by giving the lower and upper bounds for the values. A value
in the range is said to belong to the range.

Range constraint.

A range constraint of a fype 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 number of 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 the record.

Renaming declaration.

A renaming declaration declares another name for an entity.

Glossary

D-11

Rendezvous.
A rendezvous is 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 lype, an object, or a task onto features of the underlying
machine that executes a program. In some cases, 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 component is 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 simple record type is one that does not have a variant part and in
which any constraint for each component and subcomponent is static.
A simple record subtype is either a simple record type or a static
constrained subtype of a record type (with discriminants) in which any
constraint for each component and subcomponent of 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 VMS routine to
indicate whether or not the routine completed successfully.

Subcomponent.

A subcomponent is 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 and satisfies 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

number of 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 fype 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 name in 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

Syntax Summary

NOTE
This syntax summary is not part of the standard definition of the
Ada programming language.
2.1
graphic character
|

::= basic graphic_ character

lower
case letter

basic graphic character
|

other special character

::=

upper
case letter

digit

special character

space character

basic character

::=

basic graphic character

format

effector

2.3
identifier

letter

::=

{[underline]

letter
or digit
letter

::=

letter
or digit}

letter

upper
case letter

digit
|

lower
case letter

24
numeric literal

::=

decimal

literal

::=

integer

[.integer]

based literal

2.4.1:
decimal literal

integer
exponent

::= digit
::= E

[+]

{[underline]
integer

[exponent]

digit}
-

integer

Syntax Summary

E-1

2.4.2:
based literal

base
base

::=

# based integer

::=

[.based integer]

[exponent]

integer

based integer

::=

extended digit
extended digit

{[underline]

::= digit

extended_digit}

letter

2.5
character literal

::=

’'graphic_character’

2.6
string literal

::=

"{graphic character}"”

2.8
pragma

::=

pragma identifier

[ (argument_association
{,

argument association
|

argument association})];

::=

[argument identifier =>]

name

[argument identifier =>]

expression

3.1
basic_declaration

::=

object declaration

type declaration

number declaration

subtype declaration

subprogram declaration

package declaration

task declaration

generic_declaration

|
|

exception declaration
renaming declaration

|
|

generic_instantiation
deferred constant declaration

3.2
object declaration ::=
identifier list :

[constant]

subtype indication

[:= expression];

identifier list

number declaration

E-2

Syntax Summary

::=

[constant] constrained array_definition
[:= expression];

::=

identifier list
identifier list

constant

universal
static _expression;

identifier

identifier}

3.3.1:
type_declaration
|
full

full

type declaration

type

identifier

type definition
|

::=

type declaration

incomplete_type declaration

private
type declaration

::=

[discriminant part]

type definition;

::=

enumeration_type_definition

integer
type ‘definition

real

array type definition

access
type definition

type definition

record
type definition

derived
type definition

3.3.2:
subtype declaration
subtype

subtype_indication
type

mark

::=

identifier

::=

constraint

::=

type name

subtype

indication;

type mark

[constraint]

name

subtype

::=

range constraint

floating
point constraint

fixedpoint_constraint

index constraint

discriminant constraint

34
derived_type definition

::= new

subtype indication

3.5
range constraint
range

::=

range

range attribute

simple expression

3.5.1:
enumeration
type definition

::=

(enumer
literal ation
specification
{,

enumeration
literal specification})

enumeration_literal specification
enumeration

literal

::=

identifier

enumeration literal
character literal

3.5.4:
integer_type definition

::=

range constraint

Syntax Summary

E-3

3.5.6:
real type definition

::=

floating
point constraint

fixed point_constraint

3.5.7:
::=

floating_point_constraint

floating accuracy definition

floating accuracy definition
digits

[range_constraint]

::=

static simple expression

3.5.9:
fixed point constraint

::=

fixed accuracy definition

[range constraint]

::=

delta static simple expression

3.6
array type definition

::=
unconstrained
array definition
ned
array definition
constrai

unconstrained
array definition ::=
array (index subtype definition
{, index subtype definition})
component subtype indication
ned
array definition
constrai

::=

array index constraint of component_subtype_indication
index subtype definition

index constraint
discrete range

::=

::= type mark range <>

(discrete_range

discrete_range})

::= discrete subtype_ indication

range

3.7
record
type definition

::=

record

component list
end

record

component list

::=

component declaration {component declaration}
{component declaration} variant_ part

null;

component declaration

identifier list

::=
component subtype definition

[:= expression];

component subtype definition
E-4

Syntax Summary

::=

subtype_indication

3.7.1:
discriminant
part

::=

(discriminant_specification

discriminant specification
identifier list

type

{;

discriminant

[:=

expression]

specification})

::=
mark

3.7.2:
discriminant constraint

::=

(discriminant association
discriminant

association

discriminant association})

discriminant_simple
name}

::=

[discriminant_simple
name

=>]

expression

3.7.3:
variant part
case

::=

discriminant

simple name

variant
{variant}

end case;
variant
when

::=
choice

{]|

choice}

component list

choice
|

::=

simple expression

discrete

range

others

component simple name

3.8
access_type_definition

::=

access

subtype

indication

3.8.1:
incomplete
type declaration
type

identifier

::=

[discriminant part];

3.9
declarative
part

::=

{basic_declarative_item}
basic_declarati
item
ve
|

::=

representation_clause

later declarative
item

::=

{later declarative
item}
basic declaration
|

use clause

body

subprogram_declaration

package declaration

task declaration

generic

use clause

generic instantiation

declaration

Syntax Summary

E-5

body

::= proper body

proper body

body stub

subprogram body

package body

task_body

4.1
name

::=

simple name

character literal

indexed component

slice

selected component

attribute

::=

simple name

prefix

::= name

operator_ symbol

identifier

function call

41.1:
indexed component

:= prefix (expression

({,

expression})

4.1.2:
slice

::= prefix(discrete range)

4.1.3:
:= prefix.selector

selected component
selector

::=

simple name

character literal

operator symbol

all

4.1.4:
attribute

::= prefix’attribute designator

attribute designator

simple name

::=

[ (universal
static expression)]

4.3
aggregate

::=

(component association
component

component association})

association

[choice {|

choice}

]

expression

4.4
expression

E-6

::=

relation
relation

{and relation}
{or relation}

relation

{xor

Syntax Summary

relation}

|
|

relation
relation

{and then relation}
{or else relation}

relation

::=

simple expression

[relational operator

simple expression

[not]

simple expression

[not]

in type mark

simple expression

::=

[unary adding operator]
term

::=

factor

::=

primary

simple expression]

range

term

{multiplying

primary

[**

{binary adding operator

operator

primary]

term}

factor}

abs primary

not

primary

::=

numeric_literal

null

name

qualified expression

allocator

aggregate

function_call

string literal

type

conversion

(expression)

4.5
logical operator

::=

relational operator

and
::=

binary adding operator
unary adding operator

::=

multiplying operator

::=

highest precedence operator

xor

::=

mod

rem

abs

::=

not

4.6
type_conversion

::=

type

mark (expression)

4.7
qualified expression

::=

type_mark’ (expression)

type mark’aggregate

new

4.8
allocator
new

::=

subtype_ indication

qualified expression

5.1
sequence_of statements
statement

{label}

::=

statement

{statement}

::=

simple statement

{label}

compound statement

::= null statement

assignment_ statement

procedu
call statement
re

exit statement

goto_statement

return statement
entry call_statement

delay statement

abort statement

raise statement

code statement

Syntax Summary

E-7

::=

compound statement

if statement

case statement

loop statement

accept statement

block statement
select_statement

label

::= <<label simple name>>

null statement

::= null;

5.2
assignment statement

::=

:= expression;

variable name

5.3
if statement

::=

if condition then
sequence_of statements
{elsif condition then

nce
of statements}
seque
[else

nce
of statements]
seque
end if;

condition

::= boolean expression

5.4
case statement

::=

case expression is
case statement alternative
{case statement alternative}
end case;

case statement_alternative
when choice

choice

}

::=
=>

sequence_of statements

5.5
loop statement

::=

[loop simple name:]
[iteration scheme] loop
ce
of statements
sequen

end loop

[loop simple name];

iteration scheme ::= while condition
| for loop parameter specification

E-8

Syntax Summary

loop parameter specification

identifier

[reverse]

::=

discrete range

5.6
block statement

::=

[block simple name:]
[declare
declarative part]

begin
sequence
of statements

[exception
exception handler
{exception handler}]
end

[block simple name];

5.7
exit statement

::=

[when condition];

[loop name]

exit
5.8
return

statement

::=

return

[expression];

5.9
goto statement

::=

goto

label

name;

6.1
subprogram declaration

::=

subprogram specification
procedure
|

function

designator

identifier
designator

::=

identifier

operator symbol
formal

part

::=

subprogram specification;

::=
[formal

part]

[formal

part]

operator symbol

::=

parameter specification ::=
identifier list
::=

type mark

string literal

(parameter specification

mode

return

[in]

mode

out

{;

parameter specification})

type mark

[:=

expression]

out

Syntax Summary

E-9

6.3
subprogram body

::=

subprogram specification is
[declarative part]
begin
sequence
of statements

[exception

exception handler
{exception handler}]

end

[designator];

6.4
procedure
call statement

procedure name
function call

::=

function name

[actual_ parameter part]

actual parameter part

::=

(parameter association
parameter association
[formal

parameter

expression

parameter association})

::=

parameter =>]

formal parameter
actual

::=

[actual parameter_ part];

actual parameter

::= parameter_ simple name
::=

variable name

type mark(variable
name)

7.1
package declaration

::= package_specification;

package specification

::=

package identifier is
{basic_declarative_item}
[private

{basic_declarative
item}]
end

E-10

Syntax Summary

[package simple name]

package body

::=

package body package simple name

[declarative part]
[begin
sequence
of statements

[exception
exception handler
{exception handler}]]
end

[package simple name];

7.4
private
type declaration
type

identifier

::=

[discriminant part]

deferred constant declaration
identifier

list

constant

[limited]

private;

::=
type mark;

8.4
use clause

::= use package name

package name};

8.5
renaming declaration

::=

identifier

type mark

renames

object

identifier

exception

renames

exception name;

package

subprogram specification

identifier

name;

renames package name;
renames

subprogram
or entry name;

9.1
task_declaration

::= taskspecification;

taskspecification
task

[type]

::=

identifier

[is

{entry declaration}
{representation clause}

end

[task simple name]]

task body

::=

task body

tasksimple
name

[declarative part]
begin
sequence
of statements

[exception
exception handler
{exception handler}]
end

[task simple name];

9.5
entry declaration

entry

::=

identifier

[(discrete_range)]

[formal part];

Syntax Summary

E-11

entry
call statement
entry
accept

name

statement

::=

[actual

parameter part];

::=

entry simple

name

[(entry

index)]

[formal

sequence_
of statements

end

[entry simple

entry index

::=

namel];

expression

9.6
delay statement

::=

delay

simple expression;

9.7
select

statement

::=

selective wait

conditional
entry call

timed entry call

9.7.1:
selective wait

::=

select

select alternative
{ox
select

alternative}

[else
sequence
of statements]
end

select;

select alternative
[when

condition

::=
=>]

selective
wait alternative

selective
wait alternative
|

delay alternative

accept alternative
accept

statement

delay alternative
delay statement

::=

::=
[sequence
of statements]

terminate_alternative

::= terminate;

conditional
entry call

9.7.2:

select
entry call statement

[sequence
of statements]

else
sequence
of statements

end select;

E-12

Syntax Summary

accept alternative

terminate alternative

part]

[do

9.7.3:
timed entry call

::=

select
entry call statement
[sequence
of statements]
or

delay alternative
end

select;

9.10
abort_ statement

::=

abort

task

name

task name};

10.1
compilation

::=

{compilation unit}

compilation
unit
|

::=

context

clause

library unit

context

clause

secondary unit

library unit

::=

subprogram declaration

package declaration

generic

subprogram body

declaration

secondary unit

::=

library unit_body

library
unit body
::=

instantiation

subprogram body

subunit
|

package body

10.1.1:
context clause
with clause
with

::=

{with clause

{use clause}}

::=

unit simple
name

unit

simple name};

10.2
body stub

::=

subprogram specification

separate;

package body package simple name

task body

subunit

::=

tasksimple
name

separate

separate;

(parent
unit name)

proper body

11.1
exception declaration

::=

identifier list

exception;

11.2
exception
when

handler

::=

exception choice

exception choice}

sequence
of statements

exception choice

::=

exception name

others

Syntax Summary

E-13

113
raise statement

::=

raise

[exception name];

12.1
generic_declaration

::=

generic_specification

generic_ specification;

::=

generic formal part

subprogram specification

generic

package specification

formal

generic_ formal part

generic

part
::=

{generic parameter declaration}

generic parameter declaration
identifier list
|

type

[in

identifier is

::=

[out]]

type mark

private
type declaration

with

with subprogram specification

subprogram specification

generic
type definition
(<>)

range

[:= expression];

generic
type definition;
[is

namel;

[is <>];

::=
digits

array type definition

delta

access_type definition

12.3
generic instantiation
package

::=

identifier

new generic package name
|

procedure

identifier

function designator

[generic actual part];

new generic procedure name
new generic function
generic_actual
part

name

generic association})

::=

[generic
formal parameter =>]
generic formal parameter

parameter simple name
generic_actual parameter
|

[generic actual part];

::=

(generic_association
generic_association

[generic_actual part];

subprogram name

generic actual parameter

::=

operator symbol

::=

entry

expression
name

variable name

type mark

13.1
representation clause

::=

type representation
clause

E-14

Syntax Summary

address clause

type representation_clause

::=

length_clause

enumeration representation clause

recordrepresentation
clause

13.2
length clause

::= for attribute use simple_expression;

13.2b
main_storage_option ::=
[WORKING STORAGE =>]

[TOP_GUARD =>]

static_simple_expression

13.3
enumeration representation_clause
for

::=

type simple name use aggregate;

13.4
recordrepresentation
clause
for

::=

type simple name use
record

[alignment clause]

{component clause}
end record;

alignment clause

::= at mod static simple expression;

component clause

::=

component name at

static_simple expression

range

static range;

13.5
address_ clause

for

::=

simple name use at

simple expression;

13.8
code statement

::= type mark’record aggregate;

13.9a
external designator

::=

external symbol

identifier

internal name

::=

[EXTERNAL =>]

external symbol

string_ literal

::=

[INTERNAL =>]

simple name

[INTERNAL =>]

operation symbol

-- Can be used only for
—-=

IMPORT FUNCTION

Syntax Summary

E-15

13.9a.1.1
class

name

mechanism

::=

UBS

UBSB

UBA

::= mechanism name

mechanism name

(mechanism

name

NCA
{,

mechanism name}

::=

VALUE

REFERENCE

DESCRIPTOR

parameter

types

[ ([CLASS

=>]

::=

null

class_name)
]

type

mark

type

mark}

B (pragma TITLE)
titling option
[TITLE
|

::=

=>]

[SUBTITLE

string literal
=>]

string literal

Syntax Cross Reference
In the list given below each syntactic category is followed by the section
number where it is defined. For example:

adding_operator

4.5

In addition, each syntactic category is followed by the names of other
categories in whose definition it appears. For example, adding_operator

appears in the definition of simple_expression:
adding_operator
simple_expression

4.5
44

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

abort_statement

9.10

simple_statement

5.1

factor

4.4

highest_precedence_operator

4.5

abs

accept
accept_statement

accept_alternative

selective_wait_alternative

E-16

9.10

Syntax Summary

..
9.5

9.7.1

accept_statement

9.5

accept_alternative

9.7.1

compound_statement

5.1

access

access_type_definition
access_type_definition

3.8
3.8

generic_type_definition

12.1

type_definition

3.3.1

actual_parameter
parameter_association

actual_parameter_part

6.4
6.4
6.4

entry_call_statement

9.5

function_call

6.4

procedure_call_statement

6.4

address_clause
representation_clause
aggregate

code_statement

13.5

13.1
4.3
13.8

enumeration_representation_clause

13.3

primary

4.4

qualified_expression

4.7

alignment_clause

record_representation_clause

13.4

all

selector
allocator

4.1.3
4.8

primary

4.4

and

expression

4.4

logical_operator

4.5

argument_association

2.8

pragma

2.8

constrained_array_definition

3.6

unconstrained_array_definition

3.6

array

array_type_definition

3.6

generic_type_definition

12.1

type_definition

3.3.1

assignment_statement
simple_statement

5.2
5.1

Syntax Summary E-17

address_clause
alignment_clause

13.5

component_clause

13.4

attribute
length_clause
name

4.14
13.2
4.1

range

3.5

attribute_designator
attribute

4.14
414

base

2.4.2
2.4.2

based_literal
based_integer

based_literal

based_literal
numeric_literal

2.4.2
2.4.2

2.4.2
24

basic_character

2.1

basic_declaration
basic_declarative_item

3.1
3.9

basic_declarative_item
declarative_part
package_specification

3.9
3.9
7.1

basic_graphic_character

2.1

basic_character

2.1

graphic_character

2.1

block_statement

...
5.6

begin
package_body

7.1

subprogram_body

6.3

task_body

9.1

binary_adding operator

4.5

simple_expression

4.4

block_statement

compound_statement
body

5.6

5.1
3.9

later_declarative_item

3.9

body_stub

10.2

body

E-18

134

..
package_body

7.1

task_body

9.1

Syntax Summary

body_stub

10.2

body

3.9

case_statement

5.4

case

variant_part

3.7.3

case-statement

5.4

compound_statement

5.1

case_statement_alternative

5.4

case_statement

5.4

character_literal

2.5

enumeration_literal

3.5.1

name

4.1

selector

4.1.3

choice

3.7.3
case_statement_alternative

5.4

component_association

4.3

variant

3.7.3

class_name

13.9a.1.1

code_statement

13.8

simple_statement

compilation

5.1
10.1

compilation_unit

10.1

compilation

10.1

component_association

4.3

aggregate

4.3

component_clause

13.4

record_representation_clause
component_declaration
component_list

component_list

13.4

3.7
3.7

3.7

record_type_definition

3.7

variant

3.7.3

component_subtype_definition

3.7

component_declaration

3.7

compound_statement

5.1

statement

5.1

Syntax Summary

E-19

condition
exit_statement

5.7

if statement

5.3

iteration_scheme

5.5

select_alternative

9.7.1

conditional_entry_call
select_statement
constant

deferred_constant_declaration

9.7.2
9.7
.

7.4

number_declaration

3.2

object_declaration

3.2

constrained_array_definition

3.6

array_type_definition

3.6

object_declaration

3.2

constraint

subtype_indication
context_clause

compilation_unit
decimal_literal

numeric_literal
declarative_part

block_statement

3.3.2

3.3.2
10.1.1

10.1
2.4.1

2.4
3.9

5.6

package_body

7.1

subprogram_body

6.3

task_body

9.1

declare

...

block_statement

5.6

deferred_constant_declaration

7.4

basic_declaration

3.1

delay_statement

9.6

delay

delay_alternative

selective_wait_alternative
timed_entry_call
delay_statement

9.7.1

9.7.1
9.7.3
9.6

delay_alternative

9.7.1

simple_statement

5.1

fixed_accuracy_definition
generic_type_definition

3.5.9
12.1

delta

E-20

5.3

Syntax Summary

derived_type_definition
type_definition
designator

3.4
3.3.1

6.1

generic_instantiation

12.3

subprogram_body

6.3

subprogram_specification

6.1

basic_graphic_character

2.1

digit
extended_digit

2.4.2

integer

2.4.1

letter_or_digit

2.3

floating_accuracy_definition

3.5.7

digits

generic_type_definition
discrete_range

12.1
3.6

choice

3.7.3

entry_declaration

9.5

index_constraint

3.6

loop_parameter_specification

5.5

slice

4.1.2

discriminant_association
disecriminant_constraint

3.7.2
3.7.2

discriminant_constraint

3.7.2

constraint

3.3.2

discriminant_part

3.7.1

full_type_declaration

3.3.1

incomplete_type_declaration

3.8.1

private_type_declaration

7.4

discriminant_specification

3.7.1

discriminant_part

3.7.1

accept_statement

9.5

exponent

24.1

do
E

else

conditional_entry_call

9.7.2

expression

4.4

if_statement

5.3

selective_wait

9.71

ifstatement

5.3

elsif

Syntax Summary

E-21

end

accept_statement

9.5

block_statement

5.6

case_statement

5.4

conditional_entry_call

9.7.2

if_statement

5.3

loop_statement

5.5

package_body

7.1

package_specification

7.1

record_representation_clause

13.4

record_type_definition

3.7

selective_wait

subprogram_body

9.7.1
6.3

task_body

9.1

task_specification
timed_entry_call
variant_part

9.1
9.7.3
3.7.3

entry_declaration

9.5

entry

...

entry_call_statement

9.7.2

simple_statement

5.1

timed_entry_call

9.7.3

entry_declaration

task_specification
entry_index
accept_statement

enumeration_literal

enumeration_literal_specification

9.5

9.1
9.5
9.5

3.5.1

enumeration_literal_specification
enumeration_type_definition

3.5.1
3.5.1

enumeration_representation_clause

13.3

type_representation_clause

enumeration_type_definition
type_definition
exception

block_statement

E-22

9.5

conditional_entry_call

13.1

3.5.1
3.3.1
e

5.6

exception_declaration

11.1

package_body

7.1

renaming_declaration
subprogram_body

8.5
6.3

task_body

9.1

Syntax Summary

exception_choice
exception_handler
exception_declaration

basic_declaration
exception_handler

block_statement

11.2

11.2
11.1

3.1
11.2

5.6

package_body

7.1

subprogram_body

6.3

task_body

9.1

exit_statement

5.7

exit

exit_statement

simple_statement
exponent

5.7
5.1

24.1

based_literal

2.4.2

decimal_literal

24.1

expression

4.4

actual_parameter

6.4

argument_association

2.8

assignment_statement

5.2

attribute_designator

4.1.4

case_statement

5.4

component_association

4.3

component_declaration

3.7

condition

9.3

discriminant_association

3.7.2

discriminant_specification

3.7.1

entry_index

9.5

generic_actual_parameter

12.3

generic_parameter_declaration

12.1

indexed_component

4.1.1

number_declaration

3.2

object_declaration

3.2

parameter_specification

6.1

primary

4.4

qualified_expression

4.7

return_statement

5.8

type_conversion

4.6

extended_digit

2.4.2

based_integer

2.4.2

external_designator

13.9a

external_symbol

13.9a

Syntax Summary

E-23

factor

4.4

term

fixed_accuracy_definition
fixed_point_constraint

3.5.9
3.5.9

fixed_point_constraint

3.5.9

constraint
real_type_definition

3.3.2
3.5.6

floating_accuracy_definition
floating_point_constraint

3.5.7
3.5.7

floating_point_constraint

3.5.7

constraint
real_type_definition

3.3.2
3.5.6

address_clause

13.5

for

enumeration_representation_clause

13.3

iteration_scheme

5.5

length_clause

13.2

record_representation_clause

13.4

formal_parameter
parameter_association

formal_part

6.4
6.4

6.1

accept_statement

9.5

entry_declaration

9.5

subprogram_specification

6.1

format_effector
basic_character

full_type_declaration
type_declaration

function
generic_instantiation

subprogram_specification
function_call
prefix
primary

..
2.1

3.3.1
3.3.1

...
12.3

6.1
6.4
4.1
4.4

generic
generic_formal_part

..
12.1

generic_actual_parameter

12.3

generic_association

12.3

generic_actual_part
generic_instantiation

E-24

4.4

Syntax Summary

12.3
12.3

generic_association

generic_actual_part
generic_declaration

12.3
12.3

12.1

basic_declaration

3.1

later_declarative_item

3.9

library_unit

10.1

generic_formal_parameter

12.3

generic_association
generic_formal_part

generic_specification
generic_instantiation

12.3
12.1

12.1
12.3

basic_declaration

3.1

later_declarative_item

3.9

library_unit

10.1

generic_parameter_declaration

12.1

generic_formal_part

12.1

generic_specification
generic_declaration
generic_type_definition

12.1

generic_parameter_declaration

12.1

goto_statement

5.9

goto

goto_statement

simple_statement
graphic_character

5.9

5.1
2.1

character_literal

2.5

string_literal

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

renaming_declaration
simple_name
subprogram_specification
subtype_declaration
task_specification

identifier_list
component_declaration

deferred_constant_declaration
discriminant_specification

2.8

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

8.5
4.1
6.1
3.3.2
9.1

3.2
3.7

7.4
3.7.1

exception_declaration

11.1

generic_parameter_declaration

12.1

number_declaration

3.2

object_declaration

3.2

parameter_specification

6.1

if_statement

5.3

if_statement
compound_statement
import_export_pragma_name
in

generic_parameter_declaration
loop_parameter_specification

5.3
5.1
13.9a
e

12.1

5.5

mode

6.1

relation

4.4

incomplete_type_declaration

3.8.1

type_declaration

3.3.1

index_constraint
constrained_array_definition

constraint

E-26

2.3

Syntax Summary

3.6
3.6

3.3.2

index_subtype_definition

unconstrained_array_definition
indexed_component
name

integer

3.6
3.6

4.1.1
4.1
241

base
decimal_literal

2.4.2

exponent

2.4.1

integer_type_definition

3.5.4

type_definition
internal_name

24.1

3.3.1
13.9a

is
body_stub

10.2

case_statement

5.4

full_type_declaration

3.3.1

generic_instantiation

12.3

generic_parameter_declaration

12.1

package_body

7.1

package_specification

7.1

private_type_declaration

7.4

subprogram_body

6.3

subtype_declaration

3.3.2

task_body

9.1

task_specification

9.1

variant_part

3.7.3

1iteration_scheme
loop_statement

5.5
5.5

0.1

label
statement

5.1

later_declarative_item

3.9

declarative_part

3.9

length_clause

type_representation_clause

13.2

13.1
2.3

letter

extended_digit

2.4.2

identifier
letter_or_digit

letter_or_digit
identifier

library_unit
compilation_unit

2.3

10.1
10.1

Syntax Summary

E-27

library_unit_body

secondary_unit

10.1

limited
private_type_declaration

e
7.4

logical_operator

4.5

loop

..
loop_statement

5.5

loop_parameter_specification

5.5

iteration_scheme

5.5

loop_statement
compound_statement

lower_case_letter

5.5
5.1

graphic_character

2.1

letter

2.3

main_storage_option

13.2b

mechanism

13.9a.1.1

mechanism_name

13.9a.1.1

mod

...

alignment_clause
multiplying operator
mode

134
4.5
6.1

parameter_specification
multiplying_operator
term

E-28

10.1

Syntax Summary

6.1
4.5
4.4

4.1

name

abort_statement

9.10

actual_parameter

6.4

argument_association

2.8

assignment_statement

5.2

component_clause

13.4

entry_call_statement

9.5

exception_choice

11.2

exit_statement

5.7

function_call

6.4

generic_actual_parameter

12.3

generic_instantiation

12.3

generic_parameter_declaration

12.1

goto_statement

5.9

prefix

4.1

primary

4.4

procedure_call_statement

6.4

raise_statement

11.3

renaming_declaration

8.5

subunit

10.2

type_mark

3.3.2

use_clause

8.4

allocator

4.8

derived_type_definition

3.4

generic_instantiation

12.3

factor

4.4

highest_precedence_operator

4.5

relation

4.4

component_list

3.7

new

not

null

null_statement

5.1

primary

4.4

null statement

5.1

simple_statement

number_declaration
basic_declaration

5.1

3.2
3.1

numeric_literal

2.4

primary

4.4

object_declaration
basic_declaration

3.2
3.1

Syntax Summary

E-29

constrained_array_definition
unconstrained_array_definition

operator_symbol

designator
generic_formal_parameter

3.6
3.6

6.1

6.1
12.3

name

4.1

selector

4.1.3

expression

4.4

...

logical_operator
selective_wait
timed_entry_call
other_special_character
graphic_character
others

4.5
9.7.1
9.7.3
...
2.1
..

choice

3.7.3

exception_choice

11.2

generic_parameter_declaration

12.1

mode

6.1

out

package

body_stub

10.2

generic_instantiation

12.3

package_body

package_specification
renaming declaration

package_body

library_unit_body
proper_body
package_declaration

basic_declaration

later_declarative_item
library_unit
package_specification
generic_specification
package_declaration

parameter_association

actual_parameter_part
parameter_types

E-30

Syntax Summary

7.1

7.1
8.5

7.1

10.1
3.9
7.1

3.1

3.9
10.1
7.1
12.1
7.1

6.4

6.4
13.9a.1.1

parameter_specification
formal_part
pragma

6.1

6.1
2.8

pragma
pragma

2.8

4.1

prefix

attribute
indexed_component
selected_component
slice
primary

factor

private

4.1.4
4.1.1
413

4.1.2
4.4

4.4

package_specification
private_type_declaration

7.1

private_type_declaration
generic_parameter_declaration
type_declaration

7.4

procedure
generic_instantiation
subprogram_specification

7.4

12.1
3.3.1
12.3

6.1

procedure_call_statement
simple_statement

6.4

proper_body

3.9

5.1

body
subunit

3.9

qualified_expression
allocator

4.7

primary

4.4

raise_statement

11.3

raise
raise_statement

simple_statement

10.2

11.3
5.1

3.5

range

component_clause

13.4

discrete_range

range_constraint

3.5

relation

4.4

Syntax Summary

E-31

range

component_clause

3.6

range_constraint

3.5

range_constraint

constraint
fixed_point_constraint

floating point_constraint
integer_type_definition

real_type_definition
type_definition
record
record_representation_clause

record_type_definition
record_representation_clause
type_representation_clause

record_type_definition
type_definition
relation
expression

relational_operator
relation
rem

12.1

3.5

3.3.2
3.5.9

3.5.7
3.5.4

3.5.6
3.3.1
.
13.4

3.7
13.4
13.1

3.7
3.3.1
4.4
4.4

4.5
44
-

multiplying_operator
renames

renaming_declaration
renaming declaration
basic_declaration
representation_clause

basic_declarative_item

task_specification
return
return_statement

subprogram_specification
return_statement
simple_statement
reverse

loop_parameter_specification

E-32

13.4

generic_type_definition
index_subtype_definition

Syntax Summary

4.5
..

8.5
8.5
3.1
13.1

3.9

9.1
5.8

6.1
0.8
5.1
..

5.5

secondary_unit

compilation_unit

10.1

select

conditional_entry_call

9.7.2

selective_wait

9.7.1

timed_entry_call

9.7.3

select_alternative

selective_wait

select_statement
compound_statement

selected_component
name

selective_wait

select_statement
selective_wait_alternative
select_alternative

selector
selected_component

9.7.1

9.7
5.1

4.1.3
4.1

9.7.1
9.7
9.7.1
9.7.1

4.1.3
4.1.3

separate

body_stub

10.2

subunit

10.2

sequence_of_statements

5.1

accept_alternative

9.7.1

accept_statement

9.5

block_statement

5.6

case_statement_alternative

5.4

conditional_entry_call

9.7.2

delay_alternative

9.7.1

exception_handler

11.2

if_statement

5.3

loop_statement

9.5

package_body

7.1

selective_wait

9.7.1

subprogram_body

6.3

task_body

9.1

timed_entry_call

9.7.3

Syntax Summary

E-33

simple_expression

4.4

address_clause

13.5

alignment_clause
choice

3.7.3

134

component_clause

13.4

delay_statement

9.6

fixed_accuracy_definition
floating_accuracy_definition

3.56.7

3.5.9

length_clause

13.2

range

3.5

relation

4.4

simple_name
accept_statement

4.1
9.5

address_clause

13.5

attribute_designator
block_statement
body_stub

4.1.4

5.6

choice

3.7.3

discriminant_association
enumeration_representation_clause

3.7.2

formal_parameter

6.4

10.2

13.3

generic_formal_parameter

12.3

label

5.1

loop_statement

5.5

name

4.1

package_body
package_specification
record_representation_clause

7.1

selector

4.1.3

task_body

9.1

task_specification

9.1

variant_part

3.7.3

with_clause

simple__statement
statement

7.1
13.4

10.1.1
5.1

5.1
4.1.2

slice
name

4.1

space_character

basic_graphic_character

2.1

special_character
basic_graphic_character

2.1

statement

5.1

sequence_of_statements

E-34

Syntax Summary

5.1

string_literal

2.6

operator_symbol

6.1

primary

4.4

subprogram_body
library_unit

6.3
10.1

library_unit_body

10.1

proper_body

3.9

subprogram_declaration

6.1

basic_declaration

3.1

later_declarative_item

3.9

library_unit

10.1

subprogram_specification

6.1

body_stub

10.2

generic_parameter_declaration

12.1

generic_specification

12.1

renaming_declaration

8.5

subprogram_body

subprogram_declaration

6.1

subtype

subtype_declaration
subtype_declaration

basic_declaration
subtype_indication

3.3.2
3.3.2

3.1
3.3.2

access_type_definition

3.8

allocator

4.8

component_subtype_definition

3.7

constrained_array_definition

3.6

derived_type_definition

3.4

discrete_range

3.6

object_declaration

3.2

subtype_declaration

3.3.2

unconstrained_array_definition

3.6

subunit
secondary_unit

10.2

10.1

task

body_stub

10.2

task_body

9.1

task_specification
task_body

proper_body

9.1
9.1

3.9

Syntax Summary

E-35

task_declaration

9.1

basic_declaration

3.1
3.9

later_declarative_item

task_specification

9.1

task_declaration

9.1

simple_expression

4.4

term

4.4

terminate

terminate_alternative

9.7.1

terminate_alternative
selective_wait_alternative

9.7.1
9.7.1

then

e
expression

4.4

if statement

5.3

timed_entry_call

9.7.3

select_statement

9.7

titling_option

B (pragma TITLE)

type

full_type_declaration

3.3.1

generic_parameter_declaration

12.1

incomplete_type_declaration
private_type_declaration

3.8.1
7.4

task_specification

9.1

type_conversion

4.6

primary

type_declaration
basic_declaration

type_definition
full_type_declaration

E-36

Syntax Summary

4.4

3.3.1
3.1

3.3.1
3.3.1

type_mark

actual_parameter

3.3.2
6.4

code_statement

13.8

deferred_constant_declaration

7.4

discriminant_specification

3.7.1

generic_actual_parameter

12.3

generic_parameter_declaration

12.1

index_subtype_definition

3.6

parameter_specification

6.1

qualified_expression

4.7

relation

4.4

renaming_declaration

8.5

subprogram_specification

6.1

subtype_indication

3.3.2

type_conversion

4.6

type_representation_clause

representation_clause

unary_adding_operator

13.1

13.1
4.5

simple_expression

4.4

unconstrained_array_definition

3.6

array_type_definition

3.6

underline

based_integer

2.4.2

identifier

2.3

integer

2.4.1

upper_case_letter

basic_graphic_character

2.1

letter

2.3

address_clause

13.5

use

enumeration_representation_clause

13.3

length_clause

13.2

record_representation_clause

13.4

use_clause

8.4

use_clause

basic_declarative_item

8.4

3.9

context_clause

10.1.1

later_declarative_item

3.9

variant

variant_part

variant_part
component_list

3.7.3
3.7.3

3.7.3
3.7

Syntax Summary

E-37

when

case_statement_alternative

5.4

exception_handler

11.2

exit_statement

5.7

select_alternative

9.7.1

variant

3.7.3

iteration_scheme

5.5

generic_parameter_declaration

12.1

while

with
with_clause

with_clause

10.1.1
10.1.1

context_clause

10.1.1

Xor

expression

4.4

logical_operator

4.5

string_literal

2.6

based_literal

2.4.2

binary_adding_operator

4.5

attribute

4.14

character_literal

2.5

E-38

code_statement

13.8

qualified_expression

4.7

Syntax Summary

)
accept_statement

actual_parameter
actual_parameter_part

9.5
6.4

6.4

aggregate

4.3

attribute_designator

4.1.4

discriminant_constraint
discriminant_part

3.7.2
3.7.1

entry_declaration

9.5

enumeration_type_definition

3.5.1

formal_part

6.1

generic_actual_part

12.3

generic_type_definition

12.1

index_constraint

3.6

indexed_component

4.1.1

pragma

primary

qualified_expression

slice

2.8
4.4

4.7
4.1.2

subunit

10.2

type_conversion

4.6

unconstrained_array_definition

3.6

multiplying_operator

4.5

factor

4.4

highest_precedence_operator

4.5

binary_adding operator

4.5

¥k

exponent

24.1

unary_adding_operator

4.5

Syntax Summary

E-39

abort_statement

9.10

actual_parameter_part

6.4

aggregate

4.3

discriminant_constraint
enumeration_type_definition
generic_actual_part

3.5.1

3.7.2
12.3

identifier_list

3.2

index_constraint
indexed_component

3.6
4.1.1

pragma

2.8

unconstrained_array_definition

3.6

use_clause

8.4

with_clause

10.1.1

binary_adding_operator

4.5

exponent

24.1

unary_adding_operator

4.5

based_literal

2.4.2

decimal_literal
selected_component

4.1.3

range

3.5

multiplying_operator

4.5

relational_operator

4.5

block_statement

5.6

component_declaration
deferred_constant_declaration
discriminant_specification
exception_declaration
generic_parameter_declaration

3.7

loop_statement

5.5

number_declaration

3.2

object_declaration

3.2

parameter_specification
renaming_declaration

6.1

Syntax Summary

2.4.1

7.4
3.7.1
11.1
12.1

8.5

assignment_statement

5.2

component_declaration

3.7

discriminant_specification

3.7.1

generic_parameter_declaration

12.1

number_declaration

3.2
3.2
6.1

object_declaration
parameter_specification

abort_statement

9.10

accept_statement

9.5

address_clause

13.5

alignment_clause

13.4

assignment_statement

5.2

block_statement

5.6

body_stub

10.2

case_statement

5.4

code_statement

13.8

component_clause

13.4

component_declaration

3.7

component_list

3.7

conditional_entry_call

9.7.2

deferred_constant_declaration

7.4

delay_statement

9.6

discriminant_part

3.7.1

entry_call_statement

9.5

entry_declaration

9.5

enumeration_representation_clause

13.3

exception_declaration

11.1

exit_statement

5.7

formal_part

6.1

full_type_declaration

3.3.1

generic_declaration

12.1

generic_instantiation

12.3

generic_parameter_declaration

12.1

goto_statement

5.9

if_statement
incomplete_type_declaration

3.8.1

Syntax Summary

E—41

length_clause

13.2

loop_statement

5.5

null_statement

5.1

number_declaration

3.2

object_declaration

3.2

package_body

7.1

package_declaration

7.1

pragma

2.8

private_type_declaration

procedure_call_statement

6.4

raise_statement

11.3

record_representation_clause

13.4

renaming_declaration

8.5

return_statement

5.8

selective_wait

9.7.1

subprogram_body

6.3

subprogram_declaration

6.1

subtype_declaration

3.3.2

task_body

9.1

task_declaration

9.1

terminate_alternative

9.71

timed_entry_call

9.7.3

use_clause
variant_part

3.7.3

with_clause

10.1.1

relational_operator

label

5.1

relational_operator

generic_parameter_declaration

12.1

generic_type_definition

E—-42

12.1

index_subtype_definition

3.6

relational_operator

4.5

Syntax Summary

argument_association

2.8

case_statement_alternative

5.4

component_association

4.3

discriminant_association

3.7.2

exception_handler

11.2

generic_association

12.3

parameter_association

select_alternative

9.7.1

variant

3.7.3

relational_operator

4.5

relational_operator

4.5

label

5.1

case_statement_alternative

0.4

component_association

4.3

discriminant_association

3.7.2

exception_handler

11.2

variant

3.7.3

Syntax Summary

E-43

Appendix

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:

Lists of the VAX Ada pragmas and attributes.

The specification of the package SYSTEM.

The restrictions on representation clauses and unchecked type
conversions.

The conventions for names denoting implementation-dependent
components in record representation clauses.

The interpretation of expressions in address clauses.

The implementation-dependent characteristics of the input-output
packages.

F.1

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

AST ENTRY (see 9.12a).

EXPORT EXCEPTION

EXPORT FUNCTION (see 13.9a.1.4).

(see 13.9a.3.2).

Implementation-Dependent Characteristics

F~1

F.2

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

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

Implementation-Dependent Attributes
VAX Ada provides the following attributes, which are defined elsewhere in
the text. See Annex A for a descriptive attribute summary.
e

AST ENTRY (see 9.12a).

BIT (see 13.7.2).

MACHINE_SIZE (see 13.7.2).

NULL_PARAMETER (see 13.9a.1.3).

F-2

TYPE_CLASS (see 13.7a.2).

Implementation-Dependent Characteristics

F.3

Specification of the Package System

package

SYSTEM is

type NAME

for NAME

use

(VAX VMS,
(1,

VAXELN)
;

2);

SYSTEM NAME

constant

NAME

STORAGE UNIT

constant

VAX VMS;

MEMORY SIZE

constant

2**31-1;

MAX INT

constant

2**31-~-1;

MAX DIGITS

constant

—(2**31);

constant

33;

MAX MANTISSA

constant

31;

FINE

constant

2.0**(-31)
;

constant

10.0** (-2) ;

MIN

INT

DELTA

TICK

subtype

PRIORITY

Address

type

INTEGER range

type ADDRESS

is private;

ADDRESS_ZERO

constant

15;

ADDRESS;

function

|l+"

(LEFT

ADDRESS;

RIGHT

INTEGER)

return ADDRESS;

function

"+"

(LEFT

INTEGER;

RIGHT

ADDRESS)

return ADDRESS:;

function

(LEFT

ADDRESS;

RIGHT

ADDRESS)

return

function

(LEFT

ADDRESS;

RIGHT

INTEGER)

return ADDRESS;

function

"n..n

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

function

n /=n

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

function

nen

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

function

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

function

nsn

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

function

(LEFT,

RIGHT

ADDRESS)

return

BOOLEAN;

a private

type

Note that

the
do

because

functions
not

have

"="

to be

ADDRESS

and

"/="

are

explicitly

already

available

INTEGER;

and

defined

generic
type

TARGET

is private;

function FETCH
FROM ADDRESS

ADDRESS)

return

procedure ASSIGN
TO ADDRESS

ADDRESS;

VAX Ada

declarations

TARGET;

generic

type

hardware

TARGET

is private;

floating point
floating

point

type
data

for

TARGET)
;

the VAX

types

type

F_FLOAT

implementation defined;

type

D_FLOAT

implementation defined;

type

G_FLOAT

implementation defined;

type

HFLOAT

implementation defined;

Implementation-Dependent Characteristics

F-3

type

TYPE

CLASS

(TYPE CLASS ENUMERATION,
TYPE CLASS_INTEGER,

TYPE_CLASS
FIXED POINT,
TYPE CLASS_FLOATING
POINT,

TYPE CLASS_ARRAY,
TYPE CLASS_RECORD,
TYPE CLASS_ACCESS,

TYPE CLASS_TASK,
TYPE CLASS_ADDRESS)
;

AST

type

handler

AST

type

HANDLER

NO AST HANDLER

Non-Ada

limited private;

constant

HANDLER;

exception;

hardware-oriented types

type

BIT

pragma

PACK(BIT

ARRAY

array

and

functions

(INTEGER

range

<>)

is BIT ARRAY
is BIT ARRAY

(0
(0

..
..

7);
15);

subtype BITMARRAY_BZ

BIT

ARRAY

31);

subtype

BIT ARRAY

63);

range

255;

wuse

subtype

BIT ARRAY
BIT

BOOLEAN;

ARRAY);

subtype BIT ARRAY 8
le6

ARRAY 64

type

UNSIGNED

for

UNSIGNED BYTE’SIZE

BYTE

function

"not"

(LEFT

UNSIGNED BYTE)

return

UNSIGNED BYTE;

function

"and"

(LEFT,

RIGHT

UNSIGNED BYTE)

return

UNSIGNED BYTE;

function

"or"

(LEFT,

RIGHT

UNSIGNED_BYTE)

return UNSIGNED BYTE;

function

"xor"

(LEFT,

RIGHT

UNSIGNED BYTE)

return UNSIGNED BYTE;

function

TOUNSIGNED
BYTE

function

TO BITARRAY
8

BIT

UNSIGNED_BYTE

ARRAY

type

UNSIGNED WORD

range

for

UNSIGNED

use

16;

WORD'SIZE

ARRAY

return

UNSIGNED BYTE)

type

array
..

(INTEGER

UNSIGNED BYTE;

return BIT ARRAY 8;
range

<>)

UNSIGNED BYTE;

65535;

function

"not"

(LEFT

UNSIGNED WORD)

function

"and"

(LEFT,

RIGHT

UNSIGNED WORD)

return UNSIGNED WORD;

function

"or"

(LEFT,

RIGHT

UNSIGNED

return UNSIGNED

(LEFT,

RIGHT

UNSIGNED WORD)

return UNSIGNED:WORD;

BIT ARRAY
16)

return UNSIGNED WORD;

function "xor"
function

TOUNSIGNED

WORD

function TO BITARRAY
16

type

array

type

for

F—4

AST

exception

NON_
ADA ERROR
VAX

UNSIGNED
WORD ARRAY
UNSIGNED LONGWORD

UNSIGNED

LONGWORD’SIZE

UNSIGNED

range

use

Implementation-Dependent Characteristics

WORD)

WORD;

return BITARRAY
16;

(INTEGER range

MIN INT

32;

WORD)

return UNSIGNED WORD;

<>)

MAX INT;

UNSIGNED

WORD;

function

"not"

(LEFT

UNSIGNED LONGWORD)

return

UNSIGNED

LONGWORD;

function

"and"

(LEFT,

RIGHT

UNSIGNED

LONGWORD)

return

UNSIGNED

LONGWORD;

function

"or"

(LEFT,

RIGHT

UNSIGNED

LONGWORD)

return

UNSIGNED LONGWORD;

function

"xor"

(LEFT,

RIGHT

UNSIGNED LONGWORD)

return

UNSIGNED

function

TO_UNSIGNED

return

BITARRAY
32;

return

function
type

LONGWORD

BITARRAY
32)

LONGWORD;

TO_BIT ARRAY 32

UNSIGNED LONGWORD)

UNSIGNED LONGWORD ARRAY

array

type

UNSIGNED

LONGWORD;

(INTEGER

range

UNSIGNED_ QUADWORD

<>)

is
of

UNSIGNED LONGWORD;

record

UNSIGNED

UNSIGNEDmLONGWORD;

LONGWORD;

end record;
for

UNSIGNED

QUADWORD’SIZE

use

64;

function

llnot "

(LEFT

UNSIGNED QUADWORD)

return

UNSIGNED QUADWORD;

function

" and"

(LEFT,

RIGHT

UNSIGNED QUADWORD)

return

UNSIGNED QUADWORD;

function

"Or“

(LEFT,

RIGHT

UNSIGNED QUADWORD)

return

UNSIGNED

QUADWORD;

function

llxorll

(LEFT,

RIGHT

UNSIGNED

return

UNSIGNED

QUADWORD;

function

TO_UNSIGNED

return

BIT ARRAY
64;

QUADWORD

function TO BIT ARRAY
64
type

UNSIGNED

UNSIGNED QUADWORD ARRAY

array

(INTEGER range

<>)

BIT ARRAY
64)

return UNSIGNED QUADWORD;

QUADWORD)

is
of

UNSIGNED QUADWORD;

function TO_ADDRESS

INTEGER)

return ADDRESS;

function TO_ADDRESS

UNSIGNED_LONGWORD)

return

function TO_ADDRESS

universal integer)

ADDRESS;

return ADDRESS;

function TOINTEGER

ADDRESS)

return

INTEGER;

function TO UNSIGNED LONGWORD

ADDRESS)

return

UNSIGNED_LONGWORD;

function TO_UNSIGNED LONGWORD

AST

return UNSIGNED LONGWORD:;

Conventional

subtypes

static

HANDLER)

names

for

subtype UNSIGNED
1

LONGWORD

range

2**

1-1;

subtype UNSIGNED
2

is UNSIGNED LONGWORD

range

2x*

2-1;

subtype UNSIGNED
3

is UNSIGNED

LONGWORD

range

2%*

3-1;

subtype

UNSIGNED
4

UNSIGNED LONGWORD

range

2*%*%

4-1;

subtype UNSIGNED
5

UNSIGNED

LONGWORD

range

2**

5-1;

UNSIGNED

of type UNSIGNED LONGWORD

subtype UNSIGNED
6

is UNSIGNED LONGWORD

range

2**

6-1;

7
subtype UNSIGNED

UNSIGNED LONGWORD

range

2%*%

T-1;

subtype UNSIGNED
8

is UNSIGNED LONGWORD

range

2**

8-1;

subtype

is UNSIGNED LONGWORD

range

2*x*

9-1;

subtype UNSIGNED
10

LONGWORD

range

2**10-1;

subtype

UNSIGNED
9

UNSIGNED

is UNSIGNED LONGWORD

range

2**11-1;

subtype UNSIGNED
12

UNSIGNED LONGWORD

range

2**x12-1;

subtype

UNSIGNED
13

UNSIGNED LONGWORD

range

2**13-1;

subtype

UNSIGNED
14

UNSIGNED

LONGWORD

range

2*x*x14~-1;

subtype

UNSIGNED
15

UNSIGNED

LONGWORD

range

2*%*15-1;

UNSIGNED
11

Implementation-Dependent Characteristics

F-5

range

UNSIGNED

LONGWORD

range

18
subtype UNSIGNED

UNSIGNED

LONGWORD

range

subtype UNSIGNED
19

UNSIGNED LONGWORD

range

subtype

UNSIGNED
20

UNSIGNED

LONGWORD

range

21
subtype UNSIGNED

UNSIGNED LONGWORD

range

subtype

UNSIGNED
22

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
23

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
24

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
25

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
26

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
27

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
28

UNSIGNED

LONGWORD

range

subtype UNSIGNED
29

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
30

UNSIGNED

LONGWORD

range

subtype

UNSIGNED
31

UNSIGNED

LONGWORD

range

Function

for

function

IMPORT VALUE

VAX

device

function

obtaining

symbol

(SYMBOL

and process
READ

retur n

global

UNSIGNED

function

READ

retur n

procedur e
procedur e

2%%21-1;

2**%22-1;
2%*23-1;

2%%24-1;

2%%25=-1;
2%%26-1;

2%%20-1;

2%*30-1;

2%*31-1;

2*%*%27-1;
2**%28-1;

return

UNSIGNED

(SOURCE

UNSIGNED WORD)

UNSIGNED

(SOURCE

LONGWORD)

LONGWORD;

WRITE REGISTER(SOURCE

UNSIGNED BYTE;

TARGET

out

TARGET

out

UNSIGNED WORD) ;

UNSIGNED LONGWORD;

out

MEFPR

(REG _NUMBER

INTEGER)

(REG_NUMBER

INTEGER;

SOURCE

UNSIGNED BYTE);

UNSIGNED WORD;

procedur e MTPR

UNSIGNED

UNSIGNED LONGWORD) ;
return

UNSIGNED

LONGWORD;

LONGWORD) ;

interlocked-instruction procedures

procedure CLEAR INTERLOCKED
procedure

SET INTERLOCKED

(BIT

in out

OLD_VALUE

out

(BIT

in out

OLD

type ALIGNED WORD

record
SHORT

VALUE

end

INTEGER;

record;

ALIGNED

WORD

use

record
at
end

LONGWORD:;

WORD;

TARGET

F-6

2%%20-1;

UNSIGNED BYTE)

procedur e WRITE

for

2**19-1;
..

VAX

2**18-1;

(SOURCE

WRITE

function

2**17-1;

READ

retur n

2**16-1;

values

STRING)

UNSIGNED BYTE;

function

OOOO0OO0O

UNSIGNED LONGWORD

OC OO0

UNSIGNED
17

OO0

UNSIGNED
16

subtype

OO0 O

subtype

mod 2;

record;

Implementation-Dependent Characteristics

VALUE

out

BOOLEAN;

BOOLEAN)
;

BOOLEAN;

;
BOOLEAN)

procedure

ADD INTERLOCKED

(ADDEND

SHORT INTEGER;

AUGEND

in out

SIGN

: out

ALIGNED

type

INSQ STATUS

(OK_NOT

type

REMQ STATUS

(OK_NOT EMPTY,

FIRST,

OK_EMPTY, FAIL

procedure

INSQHI

REMQHI

INSQTI

REMQTI

FAIL
NO LOCK,
FAIL

WORD;

INTEGER);

OKFIRST);

NO LOCK,

WAS EMPTY) ;

(ITEM

ADDRESS;

HEADER

ADDRESS;

STATUS

out

INSQ STATUS);

(HEADER

ADDRESS;

ITEM

out

ADDRESS;

STATUS

out

REMQ STATUS) ;

(ITEM

ADDRESS;

HEADER

ADDRESS;

STATUS

out

INSQ STATUS) ;

(HEADER

ADDRESS;

ITEM

out

ADDRESS:;

STATUS

out

REMQ STATUS) ;

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_CONVERSION with

the following restrictions on the class of types involved:
*

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 CONVERSION is 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 order bits of the value are ignored (truncated); if the size of

the source value is less than the size of the target subtype, then the value is
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.ADDRESS are interpreted 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_ENTRY attribute as
alternative mechanisms for handling asynchronous interrupts from the VMS
operating system (see 9.12a).

Implementation-Dependent Characteristics

F.8

Implementation-Dependent Characteristics of
Input-Output Packages
The VAX Ada predefined packages and their 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
10, DIRECT_IO,

TEXT IO, and IO_EXCEPTIONS,

and VAX Ada accepts VMS RMS File Definition Language (FDL) statements
in form strings. The following sections summarize the implementation-

dependent 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_I0), VAX Ada provides the following inputoutput packages:

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

INDEXED_MIXED_IO (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_IO in the

package AUX_I0_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 CREATE procedures of
each input-output package may be a string whose value is interpreted as a
sequence of statements of the VAX Record Management Services (RMS) File
Definition Language (FDL), or it may be a string whose value is interpreted
as the name of an external file containing FDL statements.
The use of the FORM parameter is 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 VMS File Definition Language Facility Manual.

F.8.4

Implementation-Dependent Input-Output Error Conditions
As specified in section 14.4, VAX Ada raises 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_ERROR to be raised.
The exception USE_ERROR is raised under the following conditions:
e

If the capacity of the external file has been exceeded.

In all CREATE operations if the mode specified is IN_FILE.

In all CREATE operations if the file attributes specified by the FORM

parameter are not supported by the package.
e

In all CREATE, OPEN, DELETE, and RESET operations if, for the
specified mode, the environment does not support the operation for an
external file.

In all NAME operations if the file has no name.

In the WRITE operations on relative or indexed files if the element in
the position indicated has already been written.

TIn the DELETE'__ELEMENT operations on relative and indexed files if
the current element is undefined at the start of the operation.

In the UPDATE operations on indexed files if the current element is
undefined or if the specified key violates the external file attributes.

F-10

Implementation-Dependent Characteristics

In the SET_LINE_LENGTH and SET_PAGE_LENGTH operations on
text files if the lengths specified are inappropriate for the external file.

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_ERROR is raised as specified in section 14.4: by a
call of a CREATE or OPEN procedure if 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 VMS file
specification or a VMS logical name (in either case, the string names an
external file). 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 under the following
conditions:
e

Ifitis a procedure with no formal parameters. In this case, the status
returned to the VMS environment upon normal completion of the
procedure is the value 1.

Jfitis a function with no formal parameters whose returned value is of a
discrete type. In this case, the status returned to the VMS environment
upon normal completion of the function is the function value.

Jfitis 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 of the first (and only)
parameter.

Note that when a main function or a main procedure declared with the
pragma EXPORT _VALUED_PROCEDURE returns 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

10, DIRECT_MIXED_IO, RELATIVE_MIXED_IO, INDEXED_MIXED
IO,
and TEXT_IO, the ranges of values for the types COUNT and POSITIVE_

COUNT are as follows:
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
F_floating value and approximate decimal equivalent

Attribute

(where applicable)

DIGITS

MANTISSA

EMAX

EPSILON

16#0.1000_000#e—4

approximately

9.53674E-07

SMALL
approximately

2.58494E-26

LARGE
approximately

16#0.8000_000#e—-21
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

F-12

16#0.7TFFF_FCO#e+32
1.70141E+38

Implementation-Dependent Characteristics

Attribute
FIRST

F_floating value and approximate decimal equivalent

(where applicable)

~16#0.7TFFF_FF8#e+32

approximately

-1.70141E+38

approximately

16#0.7FFF_FF8#e+32
1.70141E+38

LAST
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

16#0.4000_0000_0000_000#e-"7
9.3132257461548E-10

approximately

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

16#0.1000_0000_0000_000#e-31
2.9387358770557TE-39

approximately
SAFE_LARGE
approximately
FIRST

16#0.7FFF_FFFF_0000_000#e+32
1.7014118338124E+38
—16#0.7FFF_FFFF_FFFF_FF8#e+32

approximately

—1.7014118346047E+38

approximately

16#0.7FFF_FFFF_FFFF_FF8#e+32
1.7014118346047E+38

LAST
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_EO#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_F0O#e+256
8.988465674312E+307

FIRST
approximately

~16#0.7FFF_FFFF_FFFF_FC#e+256
—8.988465674312E+307

LAST

16#0.7FFF_FFFF_FFFF_FC#e+256
8.988465674312E+307

approximately

MACHINE_RADIX

MACHINE_MANTISSA

MACHINE_EMAX

1023

MACHINE_EMIN

-1023

MACHINE_ROUNDS

True

MACHINE_OVERFLOWS

True

F-14

Implementation-Dependent Characteristics

H_floating value and approximate decimal equivalent

Attribute

(where applicable)

DIGITS

MANTISSA

111

EMAX

444

EPSILON

approximately

16#0.4000_0000_0000_0000_0000_0000_0000_0#e—27

1.703719777548943412223911770339 7TE-34

SMALL
approximately

16#0.8000_0000_0000_0000_0000_0000_0000_0#e-111
1.1006568214637918210934318020936E—134

LARGE

16#0. FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFE_O#e+111
4.5427420268475430659332737993000E+133

approximately

SAFE_EMAX

16383

SAFE_SMALL

16#0.1000_0000_0000_0000_0000_0000_0000_0#e—4095
8.4052578577802337656566945433044E—4933

approximately
SAFE_LARGE
approximately
FIRST

16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF
0#e+4096
5.9486574767861588254287966331400E+4931
-16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF
C#e+4096

approximately

—5.9486574767861588254287966331400E+4931

approximately

16#0.7FFF_FFFF_FFFF_FFFF_FFFF_FFF_C#e+4096
F_FFFF
5.9486574767861588254287966331400E+4931

LAST
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 DURATION are as
follows:

DURATION’' DELTA

1.00000E-04

DURATION’ SMALL

214

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 number of formal parameters in a subprogram or entry
declaration that are of an unconstrained record type

255

Maximum identifier length (number of characters)

255

Maximum number of characters in a source line

245

Maximum number of discriminants for a record type

246

Maximum number of formal parameters in an entry or subprogram
declaration

255

Maximum number of dimensions in an array type

4095

Maximum number of library units and subunits in a compilation
closure’

16383

Maximum number of library units and subunits in an execution
closure”

32757

Maximum number of objects declared with the pragma PSECT_
OBJECT

65535

Maximum number of enumeration literals in an enumeration type

65535

Maximum number of characters in a value of the predefined type

definition
STRING

65535

Maximum number of frames that an exception can propagate

65534

Maximum number of lines in a source file

231 _ 1

Maximum number of bits in any object

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

Ada Language Interpretations

Under the rules of the American National Standards Institute (ANSI),

the Ada Joint Program Office (AJPO) of the United States Department of
Defense, as the sponsor of the United States Ada language standard, is
responsible for the ongoing maintenance and interpretation of that standard.

Under the rules of the International Standards Organization (ISO),
ISO-IEC/JTC1/SC22/WG9 (WG9) 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 number of 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 (AdalC).

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:
AdalC
3D139 (1211 Fern St., C-107)
The Pentagon
Washington, DC 20301-3081
(703) 685-1477

AdalC
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 homographs for 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 homograph of the literal. 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)]

When a 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 subcomponent constraint, 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 recommended interpretation 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 Language Interpretations

and its full declaration is given in the package body; in this case, a discriminant 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).

When the initial values of discriminants are given by the evaluation of default expressions, the corresponding constraint is checked for compatibility.
Al-00008/05: Negative exponents in based notation [02.04.02 (04)]

The exponent of a based literal must not have a minus sign 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: When the prefix of - ADDRESS contains a function name
[04.01.04 (03), 13.07.02 (06)]

The name of an attribute designator can be taken into account when deciding whether the prefix of an attribute is a name or a function call, but the

attribute designator cannot be considered when resolving 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 the prefix.

Al-00016/10: Using a renamed package prefix inside a package
[04.01.03 (15), 04.01.03 (18)]
An expanded name is legal if the prefix denotes a package and the selector
is a simple name declared within the visible part of the package, regardless

of whether the 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 belongs to
an index subtype can be made before 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 performed before or after all subcomponent
expressions have been evaluated.
Al-00019/07: Checking for too many components in positional aggregates
[04.03.02 (11)]

CONSTRAINT_ERROR is 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 real literal 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

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 CONSTRAINED attribute
[07.04.02 (09)]
After the full declaration of a private type P, P CONSTRAINED is 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 mark that occurs in an explicit conversion or in a qualified expression must denote a visible declaration.

Al1-00030/07: All guards need not be evaluated first [09.07.01 (05)]

In the execution of a selective wait statement, the evaluation of conditions,
delay expressions, and entry indices is performed in some order that is
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 found to be true.

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 pragma has no effect.
Al-00032/09: Preemptive scheduling is required [09.08 (04)]
If an implementation supports more than one priority level, or interrupts,
then it must also support a preemptive scheduling policy.

Al-00034/06: Value of COUNT in 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 COUNT attribute, its value is not affected by what member of the
family is eventually determined to be called.
Al-00035/06: Body stubs are 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 Language Interpretations

G-5

Al-00038/06: Declarations associated with default names [12.03.06 (02)]
The normal visibility rules apply to identifiers used in default subpro-

gram names, i.e., these identifiers are associated with declarations visible
at the point of the generic declaratlon not those visible at each place of
instantiation.

Al-00039/1 2: Forcing occurrences and premature uses of a type
[13.01 (06), 13.01 (07), 07.04. 01 (04)]

Each operand of a relational operator (and similarly, the operand of a type
conversion
or membership test) is considered to be implicitly qualified with

the name of 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 name is 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)).

AI-00040/07 Multiple specnflcatlon of T'SIZE, T’ STORAGE SIZE

T SMALL [13.01 (03), 13.06 (01)]

For a given type, the' SIZE, - STORAGE_SIZE, and ' SMALL attributes 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—statlc 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
closing it.

2) The NAME function is allowed to raise USE_ERROR if its argument is
associated with an external file that has no name, in part1cular a temporary

file.

Al-00047/07: Effect of RESET on line and page Iengt'h [14.03.01 (04)]
Calling RESET resets the line and page lengths to UNBOUNDED.

G-6

Ada Language Interpretations

Al-00048/12: Default files can be closed, deleted, and re-opened [14.03.02
(01), 14.03.01 (05)]
The CLOSE operation can be applied to 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 have the effect of opening the default file
as well. Similarly, a DELETE operation can be applied to a file object that is
serving as the default file.
The exception MODE_ERROR is raised by OPEN if the specified mode is

OUT_FILE and the file object being opened is serving as the default input
file. Similarly, MODE_ERROR is raised if the specified mode is IN_FILE
and the file object being opened is serving as the default output file.
Al-00050/11: When does GET_LINE call SKIP_LINE? [14.03.06 (13)]

GET_LINE reads characters until either the end of the string is met or until
END_OF_LINE is true. If the end of the string has been met, SKIP_LINE
is not called even if END_OF_LINE is true. In particular, no characters are

read if the string is null.
Al-00051/07: Reading “integer literals” [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_ERROR if the characters read do not form a legal integer literal. For example, if integer GET
attempts to read 0.3, 0E—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_ERROR is also raised 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 numbers are (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 Language Interpretations

G-7

Al-00113/12: A subunit’s with clause can name its ancestor library 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 membership tests 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 component clauses [13.04 (07)]

A record component clause 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 subcomponent constraint is 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_SIZE of a task type, for SIZE (of
any type), or for SMALL of 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 Language Interpretations

Al-00139/04: The declaration of “additional operations” for access types

[07.04.02 (07)]
A consequence of the rule in 7.4.2(7, 8) is that an object A1l can be declared

such that the name A1(1) is illegal when Al.all(1) would be legal. Similar
examples exist for slices, for the attributes ' FIRST, 'LAST, - LENGTH, and

RANGE, and for selection of a record component (e.g., R1.C1 can be illegal
when R1.all.C1 is legal).
Al-00143/04: Model numbers for delta 1.0 range —7.0 .. 8.0 [03.05.09 (06)]

Given
type

delta

1.0

range

-7.0

8.0;

The model numbers for F do not include the value 8.0 and Fr 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

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 - MANTISSA for fixed point subtypes
[03.05.09 (14)]
If F is a non-static fixed point subtype, F 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
type

constant
FRACTION

:=
is

1.0/2*%*(WORD LENGTH
delta

DEL

range

-1.0

1);

1.0

|
-

DEL;

Ada Language Interpretations

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, constrained 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. The possibility

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
INTEGER range —1..10 or declare —1 as a constant and use the constant
name in place of the expression, —1; often it will be appropriate to use the
attribute ' RANGE in 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 made to activate a task before its body has been elaborated,
PROGRAM_ERROR is raised.
If more than one task is to be activated, the check for unelaborated bodies is
performed before an attempt is made to activate any task. Consequently, if

PROGRAM_ERROR is raised, no tasks have been activated.

Al-00150/04: Allocated objects belong to the designated subtype
[04.08 (05)]
CONSTRAINT _ERROR is raised 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 name that 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 Language Interpretations

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 erroneous if the name of 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 name occurs as the 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 named notation if they contain

a single component association (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 before it is called [10.05 (01)]
The main program is elaborated before it is called.
Al-00163/05: Implicit conversion preserves staticness [04.09 (06)]

A static expression is static even if an implicit conversion is applied to it.
Al-00167/04: 1t 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 renaming is prohibited for any of its
components.

Ada Language Interpretations

G-11

Al-00172/06: GET_LINE for 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 terminator is 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 exception is
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_ERROR is 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 i1s 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

FORE is 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 before it is called.

G-12

Ada Language Interpretations

Al-00181/04: NUMERIC_ERROR for nonstatic universal operands
[04.10 (05)]
When evaluating a nonstatic universal expression,

NUMERIC_ERROR can

be raised if any operand or the result 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 not force default
representation [13.01 (06), 02.08 (09)]

The intent of 2.8(9) is that an invalid pragma have the same effect 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 name or expression that forces the determination of the default repre-

sentation 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 decl 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, ag-

gregates 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 names of library units [08.06 (02)]
The name of a library unit cannot be a homograph of a name that is already

declared in package STANDARD.

Ada Language Interpretations

G-13

Al-00193/05: The value of ' FIRST’s argument in 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)]

CLOCK returns a value that 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_OF is called with a seconds value of 86_400.0, the value returned is
equal to TIME_OF for the next day with a seconds value of 0.0. In addition,
the SECONDS function 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
named in 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 never activated.
If PROGRAM_ERROR is raised 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 body is interpreted as a
library unit.

Successfully compiling a subprogram body that is a library unit means the
unit is added to the library, replacing any previously existing library unit
having the same identifier. (The previously existing library unit can only be
a package declaration, a generic package declaration, a generic instantiation,

or a previously compiled subprogram body that is a library unit.)

G-14

Ada Language Interpretations

Al-00200/08: Dependences created by inline 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 dependence of the calling unit on

the subprogram body; when such a dependence exists, 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.

Al-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.TICK requires justification in terms of

AI-00325.

Al-00205/06: The formula for MANTISSA is correct [03.05.07 (06)]
The number of 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)1og(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 name in an exit statement as an expanded name
[05.07 (02)]
An expanded name is allowed as the loop name in 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 Language Interpretations

G-15

Al-00217/05: The safe numbers of a floating point subtype [03.05.07 (09)]

The safe numbers of a floating point subtype are the safe numbers of its
base type.

Al-00219/06: Use of & and 'IMAGE in 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 same identifier as
a library unit and the library unit is a generic subprogram declaration, then
the subprogram body is 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 diseriminant 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
1S 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 ELABORATE for 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 ELABORATE that names such a package is 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 when the 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_IO is an instantiation of ENUMERATION_IO for a character type
that contains a non-graphic character, e.g.,
package

ENUM IO

new

ENUMERATION
IO

(CHARACTER)
;

then for each non-graphic character (such as ASCII.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_CASE and WIDTH is 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 ' IMAGE for 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 when attempting 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 may incorporate this interpretation.

Ada Language Interpretations

G—-17

Al-00240/05: Integer type definitions cannot contain a RANGE attribute
[03.05.04 (03)]

A range attribute is not allowed in an integer type definition.

Al-00242/09: Subprogram names allowed in pragma INLINE [06.03.02 (03),
02.08 (09)]

If the pragma INLINE appears at 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 appears after a given library unit, the pragma
must contain just the name of 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 name in the pragma is overloaded,
the pragma applies just to those subprograms whose declarations occur
(explicitly) earlier in the same declarative part or package specification. If a
name in a pragma INLINE is 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 (whether the 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 renaming declaration.

Al-00243/05: Overriding width format in TEXT_IO [14.03.05 (07)]
If the specification of WIDTH or FORE in a 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 component association having multiple choices
denoting components of the same type 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)]

When a 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 name given as the type mark (in the type conversion) must conform to
the name given for the corresponding parameter of the denoted subprogram
or entry (not the name given in the renaming declaration).

G—18

Ada Language Interpretations

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 argument be given to

CREATE and/or OPEN by raising USE_ERROR if 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: ' POSITION etc. 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 1s a name denoting a record and C is the name of a

component of the record.
Al-00260/06: Limited “full typesTM [07.04.04 (04)]

A full type declaration declares a limited type if an assignment operation is
not visible for the type of some subcomponent at 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 number is not an object [03.02 (08), 13.05 (04),
13.07.03 (03), 13.07.03 (05)]

A number declaration 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 becomes the value of the named number.

Ada Language Interpretations

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

tion is the subtype defined by the corresponding discrete range.

Al-00266/09: A bbdy 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 at-

tempt to compile a package body having the same identifier as that of the
instantiation.

After instantiating a generic subprogram as a library unit, any attempt to
compile a subprogram body having the same identifier 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 made to activate the task.
Al-00276/07: Rendezvous that 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 /0 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_ERROR can
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 been started,

the only exceptions that can be propagated to the caller are the exceptions
defined in the package IO_EXCEPTIONS and the exceptions PROGRAM_
ERROR and STORAGE_ERROR. In particular, if CONSTRAINT_ERROR,
NUMERIC_ERROR, or TASKING_ERROR is not raised by the evaluation

of any argument, then none of these exceptions will be raised by the call.

G-20

Ada Language Interpretations

Furthermore, PROGRAM_ERROR can 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 subtype if
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 decl 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 same identifier as the subprogram.
Within the body of a generic subprogram, overloading is defined for the
generic subprogram declaration in the same way as for a nongeneric subprogram. In particular, overloadable declarations occurring in an outer
declarative region or made potentially 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 procedure calls (the name of the entry,
the number of parameters, the types and the order of the actual parameters,
and the names of 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, whichever is
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 name in a “separate” clause for a subunit of P
must be P and not STANDARD.P.

Ada Language Interpretations

G-21

Al-00292/05: Derived types with address clauses for 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 CONTROLLED cannot 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 ELABORATE and INTERFACE
[10.05 (04), 13.09 (03)]
A pragma ELABORATE can be applied to a library unit whose body is
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 when T 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 ADDRESS is considered to refer to the name of the task object that

designates the task currently executing the body, i.e., T ADDRESS returns
the address of the object.

Al-00306/15: Pragma INTERFACE; allowed names and illegalities
[02.08 (09), 13.09 (03)]
If a pragma INTERFACE names a language that 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 pragma has no effect if no named subprogram satisfies the

G-22

Ada Language Interpretations

requirements.) The pragma is applied to all such subprograms other than

enumeration literals and subprograms declared by generic instantiation.
If a subprogram named in the pragma was declared by a renaming declara-

tion, 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 INTERFACE to a subprogram for which a
pragma INTERFACE has already been applied.
If a pragma INTERFACE applies 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_ERROR is raised (not DATA_ERROR) when attempting to read integer, 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 a 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 discriminants is 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 ERROR is raised if 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 subtype is static and if
the corresponding index bounds were specified with a static discrete range
in the applicable index constraint.
Al-00311/06: No NUMERIC_ERROR for null strings [11.01 (06)]
When computing the upper bound of a null string literal, NUMERIC_
ERROR must not be raised, even if the lower bound has no predecessor (but
see AI-00325).

Ada Language Interpretations

G-23

Al-00312/04: NUMERIC ERROR when evaluating null aggregates and
slices [11.01 (06)]

When determining the length of a null aggregate or slice, it is usually easy
for an implementation to avoid raising NUMERIC_ERROR. This exception
should be raised in these circumstances only when relevant restrictions in
the execution or compilation environment make it 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 _ERROR

is raised if a non-null choice of an aggregate does

not belong to the corresponding index subtype.

For conversion to an unconstrained array type, CONSTRAINT_ERROR is
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

MANTISSA

EMAX

252

SAFE

EMAX

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 Language Interpretations

Al-00320/06: Sharing external files [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 change the effect of applying these operations (or the
end of 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 subcomponent of 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 whose identifier 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
1s neither an array type nor a type with discriminants.

Al-00325/04: Implementation-dependent limitations [01.01.02 (00)]
Implementation-dependent limitations must be justified. An implementationdependent limitation 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 same identifier as the enumeration literal and
the same parameter and result type profile cannot also be declared immediately within the same declarative region. Similarly, a non-overloadable
declaration of the enumeration literal’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)]

When a 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 does not affect the subtype of the allocated
(scalar) object.

Al-00332/04: NAME_ERROR or USE_ERROR raised when /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_ERROR if file

creation or opening is not allowed for any file.

Al-00336/05: Address clause for subprogram bodies [13.05 (05)]
An address clause cannot be given for a subprogram whose body acts as 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
character set (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 representations for fixed point
values as long as all model numbers are 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 replacements of
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
ELABORATE should be used if it is important that a library package’s body

be elaborated before another package is elaborated.
Al-00355/06: Pragma ELABORATE for 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_
ERROR if a required body has not been elaborated (3.9(5-8)). An implementation 1s not allowed to raise PROGRAM_ERROR for this reason, however,
if a pragma ELABORATE has been 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 name is 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 RESET of a sequential file from OUT_FILE mode
[14.02.01 (09), 14.02.01 (15)]

If a sequential input-output file having mode OUT_FILE is closed or reset,
the most recently written element since the last open or reset is the last
element that can be read from the file. If no elements have been written, the
closed or reset file is empty. (As a consequence, opening a sequential inputoutput file with mode OUT_FILE or resetting a sequential input-output file
to mode OUT_FILE has the effect of deleting the previous contents of
the file.)

Al-00358/10: Discriminant checks for non-existent subcomponents
[03.07.02 (05), 03.07 (08)]
When checking 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
component of 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.TICK for 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 subprograms in the visible part of a non-

generic 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 Language Interpretations

Al-00370/06: Visibility of subprogam names within 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 constant is erroneous
[03.02.01 (18)]

The execution of a program is erroneous if 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 may be 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 operand of a
fixed point multiplication or division operation. The possibility of adopting a
more liberal 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 clauses for entries of task types [13.05 (08)]

If an interrupt is linked to an entry of more than one task object (of the
same type), 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 Language Interpretations

G-29

Al-00387/05: Raising CONSTRAINT_ERROR instead 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_ERROR be raised (other
than by a raise statement), CONSTRAINT_ERROR should be raised instead.
This interpretation is non-binding.

Al-00388/06: Pragmas are allowed in a generic formal part [02.08 (04)]
Pragmas are 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_Q_NOW.CALL_Q.Q(Y), is to assign an
invalid value to P.Z”

the discussion should say,

“The effect of elaborating CALL_Q _NOW 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)]

When evaluating an allocator, a check is made that the designated object
belongs to the allocator’s designated subtype. CONSTRAINT_ERROR is
raised if this check fails. This check can be made any time 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 Language Interpretations

types in a generic instance are determined by the type denoted by the formal

parameter in 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 operands of a relational operator or membership test have the type
untversal_real and one or more of the operands is 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 parameters of 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)]

When assigning a fixed or floating point value to a variable, the stored
value need only be represented as a model number of 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 membership test, 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 LAST is represented
with at least the accuracy of the base type. The values of other attributes of

a real subtype are given exactly.

Ada Language Interpretations

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 names created by instantiation [12.03 (05),
04.09 (11)]

A subtype can be nonstatic in a generic template and static in a corresponding instance.

Al-00412/06: Expanded names for 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 among library units are not allowed, i.e., the library
unit being compiled cannot have the same name as a 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_ERROR is raised, even if one of the
operands has 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 parame-

terless 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

component type (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., T CALLABLE can be FALSE when T' TERMINATED is 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 COUNT attribute 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 rendezvous or that is waiting for a task to be activated. If this
occurs, the exception has no effect.

Al-00449/04: Evaluating default discriminant expressions [03.03.02 (06)]
Default discriminant expressions are not evaluated when a subtype indication 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 manner as for an exception
raised in the sequence of statements.

Ada Language Interpretations

G-33

Al-00464/05: Delay statements executed by the environment task
[09.06 (01)]
Delay statements can be executed by the environment task when a library
package is elaborated. Such statements delay the environment task.
Al-00466/04: 1/0 performed by library tasks [14.01 (07)]

The language does not define what happens to 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 the sign of the fixed point value
followed by repeated addition.
Al-00493/05: Operator symbols that represent the same operator
[06.03.01 (04)]

Two string 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 upper case rather than lower case.

Al-00508/03: The safe numbers of a fixed point subtype [03.05.09 (11)]
The safe numbers of a fixed point subtype are the safe numbers of its
base type.

Al-00516/05: The safe interval for a fixed/integer result [04.05.07 (04)]

When a 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 Language Interpretations

IndeXx

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 where it 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 that is
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 pragmal

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 of the entry; additional main entries have
been inserted directly into the existing index. All VAX Ada additions are distinguished
by colored print.

Index-1

Abandon elaboration or evaluation (of
declarations or statements)

[see: exception, raise statement]

Abnormal task 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

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

Access type 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

name in a controlled pragma 4.8
object initialization 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
with an index constraint 3.6.1
input-output of 14.1

Access type definition 3.8; 3.3.1, 12.1.2

as a generic type definition 12.1

Absolute value operation 4.5.6

Accept alternative (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
41.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

Access_check

[see: constraint_error, suppress]

[see also: address (predefined attribute); bit
(VAX Ada predefined attribute)]

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

Index-2

of a task type 9.2

Aggregate 4.3, D

that is an array aggregate 4.3.2

[see also: array aggregate, overloading

that is a loop parameter 5.5

of ..., record aggregate]

Actual parameter part 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 procedure call statement 6.4
in a timed entry call 9.7.3

Actual part
[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 Ada predefined
procedure)

[see:system.add_interlocked]
Addition operation 4.5.3
accuracy for a real type 4.5.7
ADDRESS (predefined attribute) 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 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 argument of a conversion
4.6

of a derived type 3.4
ALIGNED_WORD (VAX Ada predefined 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

as a representation clause 13.1

for a generic formal access type 12.1.2

for an entry 13.5.1

for a private type 7.4.1

ADDRESS_ZERO (VAX Ada predefined 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

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 due to 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 access file 14.2a

Index-3

as an operation of a floating point type

Alternative

[see: accept alternative, case statement

alternative, closed alternative, delay
alternative, open alternative, select alternative,
selective wait, terminate alternative]

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

Ambiguity
[see: overloading]

in an enumeration representation clause
13.3

Ampersand
[see: catenation]

Array assignment 5.2.1

character 2.1
delimiter 2.2

Array bounds

[see: bound of an array]

Ancestor library unit 10.2

Array component

And operator

[see: array type, component, indexed

[see: logical operator]

And then control form
[see: short circuit control form]

Anonymous base type

[see: first named subtype]

ANSI (american national standards institute) 2.1

component]

[see also: allocation]

Array type 3.6; 3.3, D

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

Apostrophe character 2.1
in a character literal 2.5

as a generic parameter 12.3.4
as the type of a formal parameter 6.2

Apostrophe delimiter 2.2

for a prefix of an indexed component

in an attribute 4.1.4

of a qualified expression 4.7

conversion 4.6

4.1.1

for a prefix of a slice 4.1.2

operation 3.6.2; 4.5.2, 4.5.3

Apply 10.1.1

operation on an array of boolean

Appropriate for a type 4.1

for an array type 4.1.1, 4.1.2

\éw;hza component type with discriminants

for a record type 4.1.3

with a limited component type 7.4.4

for a task type 4.1.3

Arbitrary selection of select alternatives 9.7.1
Argument association in a

pragma 2.8

Preg

Argument identifier 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

components 4.5.1, 4.5.6
b
.

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 . . . , unconstirained array

definition]

as a generic type definition 12.1

Arrow compound delimiter 2.2
:

ASCIl (american standard code for information

interchange) 2.1

ASCII (predefined library package) 3.5.2; 2.6, C

as a primary 4.4

[see also: graphical symbol]

in a length clause 13.2

in a static expression in a generic unit

Assignment compound delimiter 2.2; 5.2

12.1

in an object declaration 3.2.1

of an access type 3.5.8

of an array type 3.6.2

Assignment operation 5.2; D

of a derived type 3.4

[see also: initial value, limited type]

of a discrete type or subtype 3.5.5

as a basic operation 3.3, 3.3.3; 3.5.5,

of an entry 9.9

3.5.8, 3.5.10, 3.6.2, 3.7.4, 3.8.2, 7.4.2,

of a fixed point type 3.5.10

12.1.2

of a floating point type 3.5.8

for a generic formal type 12.1.2

of an object of a task type 9.9

not available for a limited type 7.4.4
of an array aggregate 4.3.2

of a private type 7.4.2; 3.7.4

of a record type 3.7.4

of an initial value to an object 3.2.1

of a static subtype in a static expression

to an array variable 5.2.1; 5.2

4.9

to a loop parameter 5.5

of a task type 9.9

to an object designated by an access

of a type 3.3

value 3.8

of a type as a generic actual function

to a shared variable 9.11

12.3.6

of a type with discriminants 3.7.4

Assignment statement 5.2; D

renamed as a function 8.5

[see also: statement]

that is a function 3.5.5

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

Attribute designator 4.1.4

AUX_IO_EXCEPTIONS (VAX Ada predefined inputoutput package) 14.4; 14.2a.3, 14.2a.5, 14.2b.8,

14.2b.10
specification 14.5a

statement 8.1

Association

[see: component association, discriminant
association,

generic association, parameter

association]

AST_ENTRY (VAX Ada predefined atiribute)
9.12a; A

AST_ENTRY (VAX Ada predefined pragma)
9.12a;: B

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

AST_HANDLER (VAX Ada predefined 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 a name 4.1

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: name of a base type]

of an array type 3.6.2

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 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 floating point type 3.5.7

of a private type 7.4.2

of a formal parameter of a generic formal

of a record type 3.7.4

subprogram 12.1.3

of a task type 9.9

of an integer type 3.5.4

propagating an exception 11.6

of a parent subtype 3.4
of a qualified expression 4.7

raising an exception 11.4.1
that is an attribute 4.1.4

of a type mark 3.3.2

of a type mark in a membership test 4.5.2
of the discrete range in a loop parameter
specification 5.5
of the expression in a case statement 5.4

Belong

<1)f2 t:uz result of a generic formal function

Binary adding operator 4.5; 4.5.3, C

to a range 3.5
to a subtype 3.3
to a subtype of an access type 3.8

[see also: arithmetic operator, overloading of

of the result subtype of a function 5.8

an operator]

of the subtype indication in an access

for time predefined type 9.6

type definition 3.8

in a simple expression 4.4

of the type in the declaration of a generic

overloaded 6.7

formal object 12.1.1
of the type mark in a renaming

declaration 8.5

Based literal 2.4.2; 14.3.7

Binary
Bit

[see also: colon character, sharp character]
as a numeric literal 2.4
Basic character 2.1
[see also: basic graphic character, character]

[see: storage bits]

'
BIT (VAX Ada predefined attribute) 13.7.2; A
Bit array D; 13.9a.1.2
BIT_ARRAY (VAX Ada predefined type)

Basic character set 2.1

is sufficient for a program text 2.10

operation 4.5

y op

[see: system.bit_array]

Bit string 13.9a.1.2; D

Basic declaration 3.1

as a basic declarative item 3.9
Basic declarative item 3.9

Blank skipped by a text_io procedure 14.3.5
Block name 5.6

in a package specification 7.1; 7.2

declaration 5.1
implicitly declared 3.1

Basic graphic character 2.1

[see also: basic character, digit, graphic

Block statement 5.6; D

character, space character, special character,

[see also: completed block statement,

upper case letter]

statement]

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 access type 3.8.2
Index—6

as a compound statement 5.1

as a declarative region 8.1
entity denoted by an expanded name
41.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

Bound of a scalar type 3.5

raising an exception 11.4.1, 11.4.2

Bound of a slice 4.1.2

Body 3.9; D
[see also: declaration, generic body, generic

Box compound delimiter 2.2

in a generic parameter declaration 12.1,

package body, generic subprogram body,
library unit, package body, proper body,

12.1.2, 12.1.3; 12.3.3

subprogram body, task body]

in an index subtype definition 3.6

as a later declarative item 3.9

Bracket

[see: label bracket, left parenthesis,

Body stub 10.2; D

acting as a subprogram declaration 6.3

parenthesized expression, right parenthesis,

as a body 3.9

string bracket]

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 boolean type,

predefined type]
operation 3.5.5; 4.5.1,4.52, 45.6

operation comparing real operands 4.5.7

Bound
[see: error bound, first attribute, last attribute]
Bound of an array 3.6, 3.6.1

[see also: index range, slice]
aggregate 4.3.2

ignored due to index_check suppression

CALENDAR (predefined library package) 9.6; C

Call
[see: conditional entry call, entry call
statement, function call, procedure call

statement, subprogram call, 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
Case of a letter
[see: letter, lower case letter, upper case
letter]

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,
453,456

Bound of a range 3.5; 3.5.4

of a discrete range in a slice 4.1.2
of a discrete range is of universal_integer
type 3.6.1

of a static discrete range 4.9

Case statement 5.4
[see also: statement]
as a compound statement 5.1

Case statement alternative 5.4

Catenation operation 4.5.3
for an array type 3.6.2

in a replacement of 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 access file 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
names of characters 2.1
replacement in program text 2.10

image of a nongraphic 3.5.5
CHARACTER (predefined type) 3.5.2; C

as the component type of the type string
3.6.3

Character literal 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 enumeration literal 3.5.1
as a name 4.1

as a selector 4.1.3

declared by an enumeration literal
specification 3.1
in a static expression 4.9
in homograph declarations 8.3

must be visible at the place of a string

literal 4.2

Character type 3.5.2; 2.5
operation 3.5.5

[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 Ada predefined
procedure)

[see: system.clear_interlocked]

CLOCK (predefined function) 9.6
[see also: system.tick]

CLOSE (input-output procedure)
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
in an instance of indexed_io 14.2.1;
14.2a5

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

Closed alternative (of a selective wait) 9.7.1; 11.1
[see also: alternative]
Closed file 14.1

Check

[see: suppress pragma]
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 component association 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

Class of type 3.3; 12.1.2

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: based literal]
replacing sharp character 2.10

Colon delimiter 2.2

Completed block statement 9.4

Column 14.34

Completed subprogram 9.4

Comma

Completed task 9.4; 9.9

character 2.1
delimiter 2.2
Comment 2.7; 2.2
in a conforming construct 6.3.1

Communication
between tasks [see: accept statement,
entry, rendezvous]

of values between tasks 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 sequence of 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 after library units named in its
context clause 10.3

followed by an inline pragma 6.3.2

[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
1141, 11.4.2

Component (of a composite type) 3.3; 3.6, 3.7, D

[see also: component association, component
clause, component list, 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
name starting 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

subtype itself a composite type 3.6.1,
3.7.2

that is a task object 9.3

whose type is a limited type 7.4.4

biasing of 13.4

Component association 4.3
in an aggregate 4.3

including an expression that is an array

with a context clause 10.1.1

aggregate 4.3.2

with a use clause 8.4

named component association 4.3

Compile time evaluation of expressions 10.6; 4.9
Compiler 10.4

Compiler listing
[see: list pragma, page pragma]

named component association for
selective visibility 8.3

positional component association 4.3

Component clause (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

Condition 5.3

[see also: expression]

determining an open alternative of a

having an extended scope 8.2

selective wait 9.7.1

in a component list 3.7

in an exit statement 5.7

of an array object 3.6.1

in an if statement 5.3

of a record object 3.7.2

in a while iteration scheme 5.5

visibility 8.3

Component list 3.7

Condition (VAX) handling in an Ada program
11.2, D

in a record type definition 3.7
in a variant 3.7.3

Component subtype definition 3.7
[see also: dependence on a discriminant]
in a component declaration 3.7
Component type
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 subcomponent 9.2
object initialization 3.2.1 [see also:
initial value]
of an aggregate 4.3

with a private type component 7.4.2

Compound delimiter 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]
names of delimiters 2.2

Compound statement 5.1
[see also: statement]
including the destination of a goto
statement 5.9

Concatenation
[see: catenation]

Index—-10

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 subtype indication 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 subtype indication in an allocator 4.8

not considered in overload resolution 8.7

on a derived subtype 3.4
on a formal parameter 6.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 renamed object 8.5

on a subcomponent subject to a
component clause must be static 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 parameter not in the

subtype of the formal parameter 6.4.1
raised by an allocator 4.8
raised by an assignment 5.2; 3.5.4
raised by an attribute 3.5.5
raised by a component of an array
aggregate 4.3.2

raised by a component of 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 parameter 6.4.1
raised by an index value out of bounds
411,412
raised by a logical operation on arrays of

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 the initialization 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]

Contiguous array D; 13.9a.1.2

Index-11

Control form

[see: short circuit control form]

Current element of 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, 74.2
between array types 4.6
between numeric types 3.3.3, 3.5.5, 4.6

defined and undefined 14.2
locking of 14.2

Current index of a direct access file 14.2, 14.2.1;
14.2.4

Current index of a relative access file 14.2a
Current line number 14.3; 14.3.1, 14.34, 143.5
Current mode of a file 14.1, 14.2.1; 14.2.2, 14.2.4,
14.3, 14.3.5, 14.4

from universal fixed type 4.5.5

Current page number 14.3; 14.3.1, 14.3.4, 14.3.5

of a universal type expression 5.2

Current size of a direct access file 14.2

to a derived type 3.4

CURRENT _INPUT (text_io function) 14.3.2; 14.3.10

in a static expression 4.9

of the bounds of a loop parameter 5.5

to a real type 4.5.7

Convertible universal operand 4.6

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, 144

DATA_ERROR (input-output exception) 14.4,

COUNT (VAX Ada input-output type) 14.2a
in an instance of relative_io 14.2a.3
in relative_mixed_io 14.2b.8

14.2.2, 14.2.3, 14.24, 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)
in an instance of direct_io 14.2.1; 14.2.5

Date

in an instance of sequential_io 14.2.1;

14.2.3

DAY (predefined function) 9.6

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;

Dead code elimination
[see: conditional compilation]

14.2a.1, 14.2a.5

Deallocation

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,

[see: access type, unchecked_deallocation]

Decimal literal 2.4.1; 14.3.7, 14.3.8 as a numeric

literal 2.4

14.2b.10

Decimal number (in text_io) 14.3.7

14.2b.8

Decimal point

in relative_mixed_io 14.2.1; 14.2b.1,

in sequential_mixed_io 14.2.1; 14.2b.4
Current column number 14.3; 14.3.1, 14.3.4,
14.3.5, 14.3.6

Index-12

[see: day, month, time, year]

[see: fixed point, floating point, point

character]

Declaration 3.1; D

including a suppress pragma 11.7

[see also: basic declaration, block name

including a task declaration 9.3

declaration, body, component declaration,

with implicit declarations 5.1

constant declaration, deferred constant
declaration, denote, discriminant specification,
entry declaration, enumeration literal
specification, exception declaration, exception

Declarative region 8.1; 8.2, 8.4

[see also: scope of ...

]

determining the visibility of a declaration

raised during . . . , generic declaration, generic

8.3

formal part, generic instantiation, generic

formed by the predefined package

parameter declaration, generic specification,

standard 8.6

hiding, implicit declaration, incomplete type

in which a declaration is hidden 8.3

declaration, label declaration, local declaration,

including a full type definition 7.4.2

loop name declaration, loop parameter

including a subprogram declaration 6.3

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
determined by visibility from an identifier
8.3

made directly visible by a use clause 8.4

of an enumeration literal 3.5.1
of a formal parameter 6.1

of a loop parameter 5.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 body 7.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

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]
cannot include a forcing occurrence 13.1
for a component 3.3; 7.4.3, 7.4.4

for a component of 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 component declaration 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

including an interface pragma 13.9

also: null access value]

including a representation clause 13.1

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, default initial

value, initial value]

DELETE (input-output procedure)
in an instance of direct_io 14.2.1; 14.2.5
in an instance of sequential_io 14.2.1;
14.2.3

Default mode (of a file) 14.2.1; 14.2.3, 14.2.5,

in text_io 14.2.1; 14.3.10

14.3.10

in an instance of indexed_io 14.2.1;
14.2a.5

Default_aft (field length) of fixed_io or float_io

in an instance of relative_io 14.2.1;

14.3.8; 14.3.10

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

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

DELETE_ELEMENT (VAX Ada input-output
procedure)

in an instance of indexed_io 14.2a.4,

Default_setting (letter case) of enumeration_io

14.2a.5

14.3.9; 14.3.10

in an instance of relative_io 14.2a.2,

Default_width (field length)
of enumeration_io 14.3.9; 14.3.10
of integer_io 14.3.7; 14.3.10

in indexed_mixed_io 14.2b.9, 14.2b.10
in relative_mixed_io 14.2b.7, 14.2b.8

Deferred constant 7.4.3
of a limited type 7.4.4

14.2a.3

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

Deferred constant declaration 7.4; 7.4.3

[see also: private part (of a package), visible

than, inequality, label bracket, less than or
equal, less than, minus, parenthesis, period,
plus, point, semicolon, star, vertical bar]

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 statement 5.1
in an abnormal task 9.10
in a select alternative 9.7.1

in a timed entry call 9.7.3

Index-14

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 subcomponent that is an actual

of a generic formal subprogram 12.3.6;

parameter 6.2

12.1, 12.1.3

effect on compatibility 3.7.2

of a library unit 10.1

effect on matching of components 4.5.2

overloaded 6.6

for an assignment 5.2
Dependent task 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

DEVICE_ERROR (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 Ada predefined type)
[see system.d_float]
D_floating (VAX floating point type representation)
3.5.7; 3.5.7a

as an operation 3.3.3

values of for machine-dependent

implicitly declared 3.3.3

attributes F

Derived type 3.4; D
[see also: parent type]
conversion to or from a parent type or

Digit 2.1
[see also: basic graphic character, extended

digit, letter or digit]

related type 4.6

in a based literal 2.4.2

of an access type [see: access type,

in a decimal literal 2.4.1

collection]

in an identifier 2.3

of an access type designating a task type
determining task dependence 9.4
of a boolean type 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

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 access file 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]

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 access type) 3.8

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, 1425, C

exceptions 14.4; 14.5
specification 14.2.5

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

requisite specification of FORM

parameter with 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]

Discriminant association 3.7.2
in a discriminant constraint 3.7.2

as a choice 3.7.3

named discriminant association 3.7.2
named discriminant association for

for a loop parameter 5.5

selective visibility 8.3

as a choice in an aggregate 4.3

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 parameter specification 5.5

positional discriminant association 3.7.2

Discriminant constraint 3.7.2; 3.3.2, D
[see also: dependence on a discriminant]
ignored due to access_check suppression
11.7

in a slice 4.1.2

in an allocator 4.8

of entry indices in an entry declaration

on an access type 3.8

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
as a generic formal type 12.1.2
expression in a case statement 5.4
of a discriminant 3.7.1

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

in an incomplete type declaration 3.8.1
in a private type declaration 7.4, 7.4.1

of a loop parameter 5.5
of index values of an array 3.6

in a type declaration 3.3, 3.3.1
must not include a pragma 2.8

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

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 component 3.7
having an extended scope 8.2
in a discriminant part 3.7.1

initialization in an allocator constrains the
allocated object 4.8

of a derived type 3.4

visibility 8.3

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
subcomponent of an object 3.2.1
with a default expression 3.7.1; 3.2.1

maximum number in record type F

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]

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

Dot

[see: double dot]

character 2.1 [see also: double dot, point
character]

delimiter 2.2
delimiter of a selected component 8.3;
413

Double dot compound delimiter 2.2

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

Double hyphen starting a comment 2.7

an incomplete type declaration 3.8.1

Double star compound delimiter 2.2

an integer type definition 3.5.4

[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

an index constraint 3.6.1

a library unit 10.5
a loop parameter specification 5.5

an object declaration 3.2.1
a package body 7.3

a package declaration 7.2
a parameter specification 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

Effect

a subprogram body 6.3

[see: elaboration has no other effect]

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 access type definition 3.8
an array type definition 3.6

a body stub 10.2
a component declaration 3.7
a component subtype definition 3.7

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]
Element in a file 14, 14.1; 14.2
in a direct access file 14.2.4

in a sequential access file 14.2.2
VAX Ada implementation of 14.1a

a constrained array definition 3.6
a declaration 3.1

a declarative item 3.9
a declarative part 3.9

Index-17

ELEMENT_SIZE (VAX Ada mixed-type input-output

function)

in direct_mixed_io 14.2b.2, 14.2b.6

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;

in indexed_mixed_io 14.2b.2, 14.2b.10

14.2.3

in relative_mixed_io 14.2b.2, 4.2b.8

in text_io 14.3.1, 14.3.10

in sequential_mixed_io 14.2b.2, 14.2b.4

in an instance of indexed_io 14.2a.4,
14.2a.5

ELEMENT_TYPE (generic formal type of direct_io)
14.2.5; 14.1, 1424

in an instance of relative_io 14.2a.2,
14.2a.3

ELEMENT_TYPE (generic formal type of
indexed_io) 14.2a.5; 14.2a.4
ELEMENT_TYPE (generic formal type of

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

relative_lo) 14.2a.3; 14.2a.2

END_OF_LINE (text_io function) 14.3.4; 14.3.10

ELEMENT _TYPE (generic formal type of
sequential_io) 14.2.3; 14.1, 14.2.2
Else part

raising an exception 14.4
END_OF_PAGE (text_io function) 14.3.4; 14.3.10,
14.4

of a conditional entry call 9.7.2

OI an lfl statement 5'37 i 11
of a selective wait 9.7.1; 1 .

Entry (of a task) 9.5; 9, 9.2, D

[see also: actual parameter, address attribute,
attribute of . . . , formal parameter, interrupt

EMAX (predefined attribute) 3.5.8; A

entry, overloadl'ng of ..., parameter and

[see also: machine_emax]

result type profile, parameter, subprogram]

VAX Ada floating point values for F

declared by instantiation of a generic
formal parameter 12.3

Emin

denoted by an indexed component 4.1.1

[see: machine_emin]

denoted by a selected component 4.1.3

name [see: name of an entry]
Empty string literal 2.6

name starting with a prefix 4.1

]

of a derived task type 3.4

End of line 2.2

of a task designated by an object of a

as a Separator 2.2

task type 9.5

due to a format effector 2.2

renamed 8.5

terminating a comment 2.7

subject to an address clause 13.5, 13.5.1

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, 145, 14.2a.3, 14.2a.4, 14.2a.5, 14.2b
3,
1:55?614'2&5’ 14.2b.6, 14.2b.8, 14.2b.9,

subject to a representation clause 13.1

[see also: ast.entn]
B

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]

END_OF_BUFFER (VAX Ada mixed-type input-

to an abnor'mal task 9.5, 9.10, 11.5; 9.5

output function)

to communicate values 9.11

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

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

Index—-18

Entry declaration 9.5
[see also: elaboration of . . . ]

Enumeration type 3.5.1; 3.3, 3.5, D
[see also: discrete type, scalar type]

as an overloaded declaration 8.3

as a character type 3.5.2

as part of a basic declaration 3.1

as a generic formal type 12.1.2

cannot include a forcing occurrence 13.1

as a generic parameter 12.3.3

having an extended scope 8.2

boolean 3.5.3

in a task specification 9.1

operation 3.5.5

including the name of a private type 7.4.1
visibility 8.3

Enumeration type definition 3.5.1; 3.3.1
[see also: elaboration of . .

]

Entry family 9.5

denoted by a selected component 4.1.3
name starting with a prefix 4.1

Entry index (in the name of an entry of a family)

ENUMERATION_IO (text_io inner generic package)
14.3.9; 14.3.10

Environment of a program 10.4
environment task calling the main

9.5

program 10.1

for an open accept alternative 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
count of calls in the queue 9.9

due to queued interrupts 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 image attribute 3.5.5

as the parameter for 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
renamed as 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
made directly visible by a use clause 8.4

Enumeration representation clause
13.3 as a representation clause 13.1
range of possible VAX Ada enumeration

codes for 13.3
use for achieving signed representation
of enumeration codes 13.3

EPSILON (predefined attribute) 3.5.8; A
VAX Ada floating 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.1

"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
1.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 bounds of 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 parameter 6.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
parameter 6.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]

[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

of a literal 4.2; 3.3.3

13.8

of a logical operation 4.5.1
of aname 4.1;4.1.1,4.1.2,4.1.3,4.14

selected to handle an exception 11.4.1;

of a name in an abort statement 9.10
of a name in a renaming declaration 8.5
of a name of a variable 5.2, 6.4.1, 12.3
of a primary 4.4

of a qualified expression 4.7; 4.8
of arange 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 bounds of a loop parameter 5.5
of the conditions of a selective wait 9.7.1

Index—20

Evaluation order

raising 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 dependent task 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 number of 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 character 2.1

replacing vertical bar 2.10

Exclusive disjunction

[see: logical operator]
Execution
[see: sequence of statements, statement, task

body, task]
EXISTENCE_ERROR (VAX Ada input-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 name 4.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]

Exponent of a floating point number 3.5.7; 13.7.3
Exponent part

in output of real values 14.3.8
of a based literal 2.4.1, 2.4.2

of a decimal literal 2.4.1
Exponentiating operator 4.5; 4.5.6

[see also: highest precedence operator]
in a factor 4.4

overloaded 6.7

Exponentiation compound delimiter 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.93, 13.9a.2, B

EXPORT_PROCEDURE (VAX Ada predefined
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 parameter 6.4, 6.4.1

as a condition 5.3
as a generic actual parameter 12.3;

12.3.1

as the argument of 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 parameter of 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

F_floating (VAX Ada floating point type
representation) 3.5.7, 3.5.7a
values of for machine-dependent
attributes F

in a choice in a case statement 5.4

in 2 component association 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 number declaration 3.2
in an object declaration 3.2, 3.2.1

FIELD (predefined integer subtype) 14.3.5; 14.3.7,
14.3.10

File (object of a file type) 14.1
[see also: external file]
arrangement of values in 14.1a

mixed-type elements in 14.1a, 14.2a

File Definition Language (FDL) 14.1b
File management 14.2.1 in text_io 14.3.1

in a parameter specification 6.1

File terminator 14.3; 14.3.1, 14.3.4, 14.3.5, 14.3.6,

in a primary 4.4

14.3.7, 14.3.8, 14.3.9

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 name of 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

FILE_MODE (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 instance of relative_io 14.2; 14.2a.1,
14.2.1; 14.2a.3

Extended_digit in a based literal 2.4.2

in direct_mixed_io 14.2b.1, 14.2.1;

External file 14.1

in indexed_mixed_io 14.2b.1, 14.2.1;

[see also: file]

14.2b.6
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
Factor 4.4
inaterm 4.4

FALSE boolean enumeration literal 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 Ada predefined type)
[see: system.f_float]

FILE_TYPE (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 instance of 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

Index—22

in indexed_mixed_io 14.2b.1, 14.2b.2,

Floating point constraint 3.5.7; 3.5.6

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

FINE_DELTA
[see: system.fine_delta]

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

FIRST (predefined attribute) A

as a generic actual type 12.3.3

[see also: bound]

as a generic formal type 12.1.2

for an access value 3.8.2

error bounds 4.5.7; 3.5.6

for an array type 3.6.2

operation 3.5.8; 4.5.3, 4.5.4, 45.5, 45.6

for a scalar type 3.5

result of an operation out of range of the

VAX Ada floating point values for F

type 4.5.7
representation of 3.5.7, 3.5.7a

First named subtype 13.1
[see also: anonymous base type,
representation clause]

FIRST_BIT (predefined attribute) 13.7.2; A

[see also: record representation clause]
Fixed accuracy definition 3.5.9
Fixed point constraint 3.5.9; 3.5.6
on a derived subtype 3.4

Fixed point predefined type 3.5.9
Fixed point type 3.5.9; D

[see also: basic operation of . . . , duration,
numeric type, operation of . . . , real type,

Font design of graphical symbols 2.1

For loop
[see: loop statement]
Forcing occurrence (of a name leading to default
determination of representation) 13.1

FORE (predefined attribute) for a fixed point type
3.5.10; A

Fore field of text_io input or output 14.3.8, 14.3.10;
14.3.5

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,

scalar type, small, system.fine_delta,
system.max_mantissa]

14.2.3

accuracy of an operation 4.5.7

in text_io 14.2.1; 14.3.10

as a generic actual type 12.3.3

raising an exception 14.4

as a generic formal type 12.1.2

in an instance of indexed
jo 14.2.1,

error bounds 4.5.7; 3.5.6

14.2a.5

operation 3.5.10; 4.5.3, 4.5.4, 45.5

in an instance of relative_io 14.2.1,

result of an operation out of range of the

14.2a.3

type 4.5.7

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

FIXED_IO (text_io inner generic package) 14.3.8;
14.3.10

FLOAT (predefined type) 3.5.7; C
FLOAT_IO (text_io inner generic package) 14.3.8;
14.3.10

Floating accuracy definition 3.5.7

in sequential_mixed
io 14.2.1, 14.2b.4
Form feed format effector 2.1

Form string of a file 14.1; 14.2.1, 14.2.3, 14.2.5,
14.3.10

VAX Ada interpretation of 14.1b
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 constant 3.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

whose type is an array type 3.6.1
whose type is a limited type 7.4.4
whose type is a record type 3.7.2
whose type is a task type 9.2

maximum number in a VAX Ada
subprogram or entry declaration F
Formal part 6.1; 6.4
[see also: generic formal part, parameter type
profile]

conforming to another 6.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
Formal subprogram

[see: generic formal subprogram]
Formal type

[see: generic formal type]

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

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 of line 2.2

Format of text_io input or output 14.3.5, 14.3.7,
14.3.8, 14.3.9
Formula

[see: expression]

Garbage collection 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]

Index—24

cannot be a universal_fixed operation
455

for a generic formal access type 12.3.5

Generic declaration 12.1; 12, 12.1.2, 12.2
[see also: elaboration of . . .

]

and body as a declarative region 8.1

for a generic formal array type 12.3.4
for a generic formal object 12.1.1

and proper body in the same compilation

for a generic formal private type 12.3.2

as a basic declaration 3.1

10.3

for a generic formal scalar type 12.3.3
for a generic formal subprogram 12.1.3;

as a later declarative item 3.9

12.3.6

in a package specification 7.1

as a library unit 10.1

for a generic formal type 12.1.2

recompiled 10.3

is not static 4.9

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

[see also: default expression, generic formal

that is a task type 9.2

parameter]

Generic actual part 12.3

Generic actual subprogram 12.1.3,

of an array type 3.6.1

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

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 name as 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 component type 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
formal floating 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, 122, 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

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]

raising an exception 11.4.1

Generic type definition 12.1; 12.1.2, 12.3.3,

inlining of body for 12.1a

12.3.4

sharing code generated for 12.1b

Generic instantiation 12.3; 12.1, 12.1.3, 122, 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 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 and string 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

_io 14.2b.2, 14.2b.8
in relative_mixed
in sequential_mixed_io 14.2b.2, 14.2b.4
GET_LINE (text_io procedure) 14.3.6; 14.3.10

G_FLOAT (VAX Ada predefined type)
[see: system.g_float]
G_floating (VAX Ada real type representation)

H_floating (VAX Ada floating point type
representation) 3.5.7, 3.5.7a
values of for machine-dependent
attributes F

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 symbol D; 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 case letter, other special character]
in a character literal 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
compound delimiter 2.2

operator [see: relational operator]

Guard pages for tasks 13.2a

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 comment 2.7
format effector 2.1
in text_io input 14.3.5
Hyphen character 2.1

[see also: minus character]
starting a comment 2.7

Handler
[see: exception handier, exception handling]
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 number declaration 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 a parameter specification 6.1
Identity operation 4.5.4
If statement 5.3

[see also: statement]
as a compound statement 5.1
lilegal 1.6

IMAGE (predefined attribute) 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

in its own declaration 8.3

[see also: conversion operation, explicit

in pragma system_name 13.7

conversion, subtype conversion]

of an argument of a pragma 2.8

of an integer literal to an integer type

of an enumeration value 3.5.1

3.5.4

of a formal parameter of a generic formal

of a real literal to a real type 3.5.6

subprogram 12.1.3

of a universal expression 3.5.4, 3.5.6

of a generic formal object 12.1, 12.1.1

of a universal real expression 4.5.7

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 component declaration 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 number declaration 3.2

in an object declaration 3.2

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 enumeration literal 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]

Implicit representation clause

default expression for a component 3.2.1
default expression for a discriminant 3.2.1

for a derived type 3.4

expression 4.5

Import pragmas 13.9

index constraint 3.6

library unit 10.5

IMPORT_EXCEPTION (VAX Ada predefined

parameter association 6.4

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

prefix and discrete range of a slice 4.1.2
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,

IMPORT_PROCEDURE (VAX Ada predefined

14.2a.3

pragma) 13.9a.1.1; 13.9a, 13.9a.1, B

in direct_mixed_io 14.2b.5, 14.2b.6

in relative_mixed_io 14.2b.7, 14.2b.8

IMPORT_VALUE (VAX Ada predefined function)

[see: system.import_value]
IMPORT_VALUED_PROCEDURE (VAX Ada

Index constraint 3.6, 3.6.1; D

[see also: dependence on a discriminant]

predefined pragma) 13.9a.1.1; 13.9a, 13.9a.1, B

ignored due to index_check suppression

In membership test

in an allocator 4.8

11.7

[see: membership test]

in a constrained array definition 3.6

in a subtype indication 3.3.2

In mode

on an access type 3.8

[see: mode in]
In out mode
[see: mode in out]
IN_FILE (input-output file mode enumeration literal)
14.1

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
component association of an array

violated 11.1

Index of an element in a direct access file 14.2;
14.2.4

Index in a relative access file 14.2a
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

aggregate 4.3.2

component association of a record
aggregate 4.3.1
component subtype indication 3.6

Index—29

Indexed component 4.1.1; 3.6, D

Initialization

as a basic operation 3.3.3; 3.3, 3.6.2,

[see: assignment, default expression, default

3.8.2

initialization, initial value]

as a name 4.1

as the name of an entry 9.5

INLINE (predefined pragma) 6.3.2; B
creating recompilation dependence 10.3

of a value of a generic formal array type
12.1.2

INDEXED_IO (VAX Ada predefined input-output

INLINE_GENERIC (VAX Ada predefined pragma)
12.1a; B

creating recompilation dependence 10.3

package) 14.2a.4; 14.2a, 14.2a.5
element locking in 14.2a
requisite specification of FORM
parameter with 14.1b, 14.2a.1

INDEXED_MIXED_IO (VAX Ada predefined
input-output package) 14.2b.10
requisite specification of FORM

INOUT _FILE (input-output file_mode enumeration
literal) 14.1
Input-output 14

[see also: direct_io, io_exceptions, low_level
i0, sequential_io, text_io]

at device level 14.6

parameter with 14.1b

exceptions 14.4; 145

with a direct access file 14.2.4

Indication

with a sequential file 14.2.2

[see: subtype indication]

Indivisible access of a shared variable 9.11

with a text file 14.3

Inequality compound delimiter 2.2

INSQHI (VAX Ada procedure)
[see: system.insghi]

Inequality operator 4.5; 4.5.2

INSQ_STATUS (VAX Ada type)

[see also: limited type, relational operator]
cannot be explicitly declared 6.7
for an access type 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 package 7.1

[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
Integer literal 2.4

[see also: based integer literal, universal_
integer type]

as a bound of a discrete range 9.5
as a universal_integer literal 3.5.4
in based notation 2.4.2

in decimal notation 2.4.1

of an out mode formal parameter 6.2
of a record object 3.7.2

Integer part

as a base of a based literal 2.4.2

of a decimal literal 2.4.1

Index-30

Integer predefined type 3.5.4

[see also: INTEGER, LONG_INTEGER,

IS_OPEN (input-output function)
in an instance of direct_io 14.2.1; 14.2.5

SHORT_INTEGER]
[see also: SHORT_SHORT_INTEGER]

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,

Integer subtype
[see: priority]

14.2a.5

due to an integer type definition 3.5.4

in an instance of relative_io 14.2.1,
14.2a.3

Integer type 3.5.4; 3.3, 35, D

in direct_mixed_io 14.2.1, 14.2b.6

[see also: discrete type, numeric type,

in indexed_mixed_io 14.2.1, 14.2b.10
in relative_mixed_io 14.2.1, 14.2b.8

predefined type, scalar type, system.maxint,
system.min_int, universal_integer type]

in sequential_mixed_io 14.2.1, 14.2b.4

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, 45.5, 45.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

ISO (international organization for standardization)
2.1

ISO seven bit coded character set 2.1

ltem
[see: basic declarative item, later declarative
item]

[see: integer type definition]
Integer type definition 3.5.4; 3.3.1
[see also: elaboration of . . . ]

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
10 (text_io inner generic package)
14.3.6; 14.3.10

Key in an indexed access file 14.2a

INTERFACE (predefined pragma) 13.9; B
with imported subprograms 13.9a.1.1

KEY_ERROR (VAX Ada input-output exception)

exact and inexact matching of 14.2a

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: address attribute]
[see also: ast_entry]
Interrupt queue

[see: entry queue]
I0_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: address attribute, 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 (predefined attribute) 3.5.8, 3.5.10; A
VAX Ada floating 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 Ada floating 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, 145,
14.2b.2

Leading zeros in a numeric literal 2.4.1

Left label bracket compound delimiter 2.2
Left parenthesis
character 2.1
delimiter 2.2

Legal 1.6

LENGTH (predefined attribute) 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

Length of a string literal 2.6
Length of the result
of an array comparison 4.5.1

compound delimiter 2.2
operator [see: relational operator]
Letter 2.3

[see also: lower case letter, upper case letter]
e or E in a decimal literal 2.4.1
in a based literal 2.4.2
in an identifier 2.3

Letter_or_digit 2.3

Lexical element 2, 2.2; 2.4, 25, 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
named in a with clause 10.1.1; 10.3, 10.5
recompiled 10.3
scope 8.2

of an array logical negation 4.5.6

subject to an interface pragma 13.9

of a catenation 4.5.3

that is a package 7.1
visibility due to a with clause 8.3

Length_check
[see: constraint_error, suppress]
Less than

character 2.1
delimiter 2.2

operator [see: relational operator]

Index—-32

Less than or equal

whose name is 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

Local declaration 8.1

[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, 1231, D

in a generic unit 12.3

LOCK_ERROR (VAX Ada input-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

[see also: assignment, equality operator,
inequality operator, predefined operator, task

type]

as a full type 7.4.1
component of a record 3.7
generic formal object 12.1.1
in an object declaration 3.2.1
limited record type 3.7.4

Logical negation operation 4.5.6
Logical operation 4.5.1
Logical operator 4.5; 4.4, 45.1, C
[see also: overloading of an operator,
predefined operator]

as an operation of boolean type 3.5.5

operation 7.4.4; 4.5.2

for an array type 3.6.2

parameters for explicitly declared equality

in an expression 4.4

operators 6.7

Line 14.3, 14.3.4
LINE (text_io function) 14.3.4; 14.3.10

raising an exception 14.4
Line feed format effector 2.1
Line length 14.3, 14.3.3; 14.3.1, 14.3.4, 14.3.5,
14.3.6

overloaded 6.7

Logical processor 9

LONG_FLOAT (predefined type) 3.5.7; C
LONG_FLOAT (VAX Ada predefined pragma)
3.5.7a; B

LONG_LONG_FLOAT (VAX Ada predefined type)

3.5.7;C

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: component list, identifier_list]
LIST (predefined pragma) B

Listing of program text

[see: list pragma, page pragma]
Literal 4.2; D

[see also: based literal, character literal,
decimal literal, 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: enumeration literal

specification]

LONG_INTEGER (predefined type) 3.5.4; C
Loop name 5.5

declaration 5.1
implicitly declared 3.1

in an exit statement 5.7

Loop parameter 5.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 name 4.1.3
including an exit statement 5.7

LOW_LEVEL_IO (predefined input-output package)

14.6; 14, C

Index-33

including a priority pragma 9.8

Lower bound

raising an exception 11.4.1, 11.4.2

[see: bound, first attribute]

termination 9.4
VAX Ada definition of 10.1, F

Lower case letter 2.1

[see also: graphic character]

ato fin a based literal 2.4.2
e in a decimal literal 2.4.1
in an identifier 2.3

stack and stack storage for 13.2b
MAIN_STORAGE (VAX Ada predefined pragma)
13.2b; B
MANTISSA (predefined attribute) 3.5.8, 3.5.10; A
VAX Ada floating point values of F
Mantissa

of a fixed point number 3.5.9
of a floating point number 3.5.7; 13.7.3

Machine code insertion 13.8

Machine dependent attribute 13.7.3
Machine representation

[see: representation]

MACHINE_CODE (predefined package) 13.8; C

Mark

[see: type_mark]
Master (task) 9.4

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 Ada floating point values for F

Matching generic formal
and actual parameters 12.3
access type 12.3.5

MACHINE_EMIN (predefined attribute) 13.7.3;

array type 12.3.4

3.5.8, A

default subprogram 12.3.6; 12.1.3

VAX Ada floating point values for F

object 12.3.1; 12.1.1
private type 12.3.2

MACHINE_MANTISSA (predefined attribute)

scalar type 12.3.3

13.7.3; 3.5.8, A
VAX Ada floating point values for F

subprogram 12.3.6; 12.1.3
type 12.3.2, 12.3.3, 12.3.4, 12.3.5; 12.1.2

MACHINE_OVERFLOWS (predefined attribute)

Mathematically correct result of a numeric

13.7.3; 3.5.8, 3.5.10, A
VAX Ada floating point values for F

operation 4.5; 4.5.7

MACHINE_RADIX (predefined attribute) 13.7.3;

MAX_DIGITS

3.58 A

VAX Ada floating point values for F
MACHINE_ROUNDS (predefined attribute) 13.7.3;

[see: system.max_digits]
MAX_ELEMENT_SIZE (VAX Ada mixed-type
input-output function)

in direct_mixed_io 14.2b.2, 14.2b.6

3.5.8, 3.5.10, A
VAX Ada floating point values for F

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

MACHINE_SIZE (VAX Ada predefined attribute)
13.7.2, A
MAX_INT
Main program 10.1

execution requiring elaboration of library
units 10.5
included in the predefined package
standard 8.6

Index-34

[see: system.max_int]

MAX_MANTISSA

[see: system.max_mantissa]

Maximum line length 14.3
Maximum page length 14.3

Membership test 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
MFPR (VAX Ada predefined function)

[see: system.mfpr]

Mode (of a file) 14.1; 14.2.1
of a direct access file 14.2; 14.25
of a sequential access file 14.2; 14.2.3
of a text_io file 14.3.1; 14.3.4

of an indexed access file 14.2a
of a relative access file 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
Mode in for a formal parameter 6.1, 6.2; 3.2.1
of a function 6.5
of an interrupt entry 13.5.1
Mode in for a generic formal object 12.1.1; 3.2.1,

MIN_INT

[see: system.min_int]
Minimization of storage

[see: pack predefined pragmal]

12.3, 12.3.1

Mode in 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]

Mode in out for a generic formal object 12.1.1;

character in an exponent of a numeric

3.2.1, 12.3, 12.3.1

literal 2.4.1

delimiter 2.2
operator [see: binary adding operator,
unary adding operator]

unary operation 4.5.4

Mod operator 4.5.5
[see also: multiplying operator]
MODE (input-output function)

in an instance of direct_io 14.2.1; 1425
in an instance of sequential_io 14.2.1;

Mode out for 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, 145, 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

14.2.3

Model interval of a subtype 4.5.7

in text_io 14.2.1; 14.3.3, 14.3.4, 14.3.10
in an instance of indexed_io 14.2.1,

Model number (of a real type) 3.5.6; D

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

[see also: real type, safe number]
accuracy 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

Modulus operation 4.5.5
MONTH (predefined function) 9.6

MTPR (VAX Ada predefined procedure)
[see: system.mipr]

Index-35

Multidimensional array 3.6

as a primary 4.4

Multiple

as the expression in a case statement 5.4

as the argument of a pragma 2.8

component declaration 3.7; 3.2
deferred constant declaration 7.4; 3.2
discriminant specification 3.7.1; 3.2
generic parameter declaration 12.1; 3.2

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

number declaration 3.2.2; 3.2

denoting an entity 4.1
denoting an object designated by an
access value 4.1

object declaration 3.2
parameter specification 6.1; 3.2

generated by an implementation 13.4
starting with a prefix 4.1; 4.1.1, 4.1.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]
in a term 4.4

overloaded 6.7

Must (legality requirement) 1.6
Mutually recursive types 3.8.1; 3.3.1

41.3,4.1.4

Name string (of a file) 14.1; 14.2.1, 14.2.3, 14.2.5,
14.3, 14.3.10, 144

NAME_ERROR (input-output exception) 14.4;

14.2.1, 14.2.3, 14.2.5, 14.3.10, 145, 14.2a.3,

14.2a.5, 14.2b.6, 14.2b.8, 14.2b.10
Named association 6.4.2, D

[see also: component association, discriminant
association, generic association, parameter
association]

Named block statement
[see: 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,

Named loop statement

[see: loop name]

Named number 3.2; 3.2.2
as an entity 3.1
as a primary 4.4
in a static expression 4.9

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

NATURAL (predefined integer subtype) C
Negation

[see: logical negation operation]
Negation operation (numeric) 4.5.4
Negative exponent

in a numeric literal 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 access file 14.2a

Null record 3.7
and relational operation 4.5.2

No other effect
[see: elaboration has no other effect]

NO_AST_HANDLER (VAX Ada predefined
constant) 9.12a; F

[see: system.no_ast_handler]

Null slice 4.1.2

[see also: array type]
Null statement 5.1

[see also: statement]
as a simple statement 5.1

NON_ADA_ERROR (VAX Ada predefined
exception)

[see: system.non_ada_error]

Null string literal 2.6

NULL_PARAMETER (VAX Ada predefined

Noncontiguous array D; 13.9a.1.2

attribute) 13.9a.1.3; A

Not equal

Number

compound delimiter [see: inequality

[see: based literal, decimal literal]

compound delimiter]

operator [see: relational operator]

Number declaration 3.2, 3.2.2
as a basic declaration 3.1

Not in membership test

[see: membership test]

NUMBER_BASE (predefined integer subtype)
14.3.7; 14.3.10

Not unary operator

[see: highest precedence operator]
as an operation of an array type 3.6.2

Numeric literal 2.4, 4.2, 2.2, 2.4.1, 2.4.2

[see also: universal type expression]

as an operation of boolean type 3.5.5

and an adjacent separator 2.2

in a factor 4.4

as a basic operation 3.3.3
as a primary 4.4

Not yet elaborated 3.9

Null 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 operand of a catenation 4.5.3

Null component list 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 the parameter of 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, 45.5,
4.5.6
Numeric type expression

in a length clause 13.2
Numeric value of a named number 3.2

as a choice of a variant part 3.7.3

for a loop parameter 5.5

Index-37

NUMERIC_ERROR (predefined exception) 11.1

Object declaration 3.2, 3.2.1

[see also: elaboration of ... , generic

[see also: suppress pragma]

parameter declaration]
as a basic declaration 3.1
as a full declaration 7.4.3

not raised due to lost overflow conditions
13.7.3

not raised due to optimization 11.6
raised by a numeric operator 4.5
raised by a predefined integer operation

implied by a task declaration 9.1
in a package specification 7.1
of an array object 3.6.1

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

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 access value 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

attribute 13.7.2

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 module

for a subprogram written in another

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]

Obsolete compilation unit (due to recompilation)
10.3

as an actual parameter 6.2

Occur immediately within (a declarative region)

as a generic formal parameter 12.1.1

8.1; 8.3, 84, 10.2

created by an allocator 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 number of bits in VAX Ada F

maximum number declared with PSECT_
OBJECT pragma F

Index—38

language 13.9
VMS D

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

Open alternative 9.7.1

as a name 4.1

[see also: alternative]

before arrow compound delimiter 8.3

accepting a conditional entry call 9.7.2

declared 3.1

accepting a timed entry call 9.7.3

declared in a generic unit 12.3

in a renaming declaration 8.5

Open file 14.1

in a selector 4.1.3
in a static expression 4.9

Operation 3.3, 3.3.3; D

not allowed as the designator of a library

[see also: basic operation, direct visibility,

unit 10.1

operator, predefined operation, visibility by

of a generic formal function 12.1.3, 12.3

selection, visibility]

of homograph declarations 8.3

classification 3.3.3

overloaded 6.7; 6.6

of an access type 3.8.2
of an array type 3.6.2

of a discrete type 3.5.5

Optimization 10.6

[see also: optimize pragmal]

of a fixed point type 3.5.10

and exceptions 11.6

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

OPTIMIZE (predefined pragma) B
Optional parameter

in imported subprogram 13.9a.1.3

of a private type 7.4.2; 7.4.1

of a record type 3.7.4
of a subtype 3.3

Or else control form
[see: short circuit control form]

of a subtype of a discrete type 3.5.5
of a type 3.3

of a universal type 4.10

Or operator

[see: logical operator]

propagating an exception 11.6

subject to a suppress pragma 11.7

Order
[see: lexicographic order]

Operator 4.5;4.4,C, D
[see also: binary adding operator, designator,
exponentiating operator, function, highest

Order not defined by the language

[see: incorrect order dependence]

precedence operator, logical operator,

multiplying operator, overloading of . . . ,
predefined operator, relational operator, unary

Order of application of operators in an expression
4.5

adding operator]
as an operation 3.3.3 [see also:

Order of compilation (of compilation units) 10.1,

operation]

10.3; 10.1.1, 10.4

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 symbol 6.1
[see also: direct visibility, overloading of . . . |
scope of .. ., visibility by selection, visibility]

as a designator 6.1
as a designator in a function declaration

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

4.5

Index—-39

of expressions and the name in an

Overloading 8.3; D

of operands in an expression 4.5

[see also: designator, homograph declaration,
identifier, operator symbol, scope, simple

of parameter associations in a subroutine

name, subprogram, visibility]

assignment statement 5.2

call 6.4

and visibility 8.3

of the bounds of a range 3.5

in an assignment statement 5.2

of the conditions in a selective wait 9.7.1

in an expression 4.4

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

Other effect

[see: elaboration has no other effect]
Other special character 2.1

[see also: graphic character]
Others 3.7.3

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 enumeration literal 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 membership test 4.5.2

as a choice in an array aggregate 4.3.2

an operator 4.5, 6.7; 4.4, 6.1

as a choice in a case statement

an operator symbol 6.6; 6.7

alternative 5.4

a subprogram 6.6; 6.7

as a choice in a component association

a subprogram subject to an interface

4.3

pragma 13.9

as a choice in a record aggregate 4.3.1

the expression in a case statement 5.4

as a choice in 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-output file 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]

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
named in a use clause 8.4
renamed 8.5

Overlapping slices in array assignment 5.2.1

subject to an address clause 13.5

Overlaying of objects or program units 13.5

subject to representation clause 13.1
with a separately compiled body 10.2

Index-40

Package body 7.1, 7.3; D

[see also: body stub]

Parallel execution

[see: task]

as a generic body 12.2
as a proper body 3.9

Parameter D

as a secondary unit 10.1

[see also: actual parameter, default

as a secondary unit compiled after the

expression, entry, formal parameter, formal

corresponding library unit 10.3

part, function, generic actual parameter,

in another package body 7.1

generic formal parameter, loop parameter,

including an exception handler 11.2; 11

mode, procedure, subprogram]

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 recommended for the layout of

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 parameter association 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,
parameter specification]
Parameter part

[see: actual parameter part]
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

Parameter type 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
anonymous 3.5.4, 3.5.7, 3.5.9

Parent unit (of a body stub) 10.2
compiled before its subunits 10.3

programs 1.5

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 parameter part, declarative part,
discriminant part, formal part, generic actual
part, generic formal part, variant part]

Position number

as parameter to val attribute 3.5.5
of an enumeration literal 3.5.1
of an integer value 3.5.4
of a value of a discrete type 3.5
returned by pos attribute 3.5.5

Position of a component within a record
[see: record representation clause]

Position of an element in a direct access file 14.2
Positional association 6.4; 6.4.2, D

Partial ordering of compilation 10.3

[see also: component association, discriminant
association, generic association, parameter

Percent character 2.1
[see also: string literal]
replacing quotation character 2.10

association]

Period character 2.1

[see also: dot character, point character]

Physical processor 9; 9.8

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

POSITIVE_COUNT (predefined integer subtype)
14.2.5, 14.3.10; 14.2.4, 14.3, 14.3.4

Potentially visible declaration 8.4

Plus

character 2.1
delimiter 2.2

Pound sterling character 2.1

operator [see: binary adding operator,
unary adding operator]

Power operator

unary operation 4.5.4
Point character 2.1

[see also: dot]
in a based literal 2.4.2
in a decimal literal 2.4.1
in a numeric literal 2.4
Point delimiter 2.2
Pointer

[see: access type]
Portability 1.1

of programs using real types 13.7.3; 3.5.6

POS (predefined attribute) 3.5.5; 13.3, A

[see: exponentiating operator]
Pragma 2.8; 2, D

[see also: predefined pragma]
applicable to the whole of a compilation
10.1

argument that is an overioaded
subprogram name 6.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

POSITION (predefined attribute) 13.7.2; A
[see also: record representation clause]

Precedence 4.5

POSITION (VAX Ada mixed-type input-output

Precision (numeric)
[see: delta, digits]

function)

Index—42

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

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, character literal,

enumeration literal, predefined generic
library function]
Predefined generic library function 8.6; C
[see also: unchecked_conversion]
Predefined generic library package 8.6; C

Predefined operation 3.3, 3.3.3; 8.6

[see also: operation, predefined operator]
accuracy for 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

[see also: direct io, input-output package,

of a floating point type 3.5.7

sequential_io]

of an integer type 3.5.4

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, input-

output package, io_exceptions, low_level_jo,
machine_code, system, text_io]
Predefined library subprogram

[see: predefined generic library subprogram]
Predefined named number

[see: system.fine_delta, system.max_digits,
system.max_int, system.max_mantissa,

system.memory_size, system.min_int,
system.storage_unit, system.tick]

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 subprogram 8.6; C

[see also: input-output subprogram, library

unit, predefined generic library subprogram]
Predefined subtype 8.6; C

[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 component 4.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 access file 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

Index-44

Procedure body
[see: subprogram body]
including code statements 13.8

Procedure call 6.4; 6, D
[see also: subprogram call]
Procedure call 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,
parameter type profile]
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 number of 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
pragmalj
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

Queue of entry calls
[see: entry queue]

Queue of 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 number of objects declared

with F
PUT (text_io procedure) 14.3, 14.3.5; 14.3.2,
14.3.10

for character and string 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

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 atiribute) 3.6.2; 4.1.4, A

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,38.2, 74.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

for an access value 3.8.2
Range constraint 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 subtype indication 3.5; 3.3.2

on a derived subtype 3.4
viclated 11.1

Index—45

result of an operation out of range of the

Range_check

type 4.5.7

[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

Real type definition 3.5.6; 3.3.1, 3.5.7, 3.5.9
[see also: elaboration of ... ]

RECEIVE_CONTROL (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]

in relative_mixed_io 14.2b.7, 14.2b.8

correspondence to a file element 14.1a

in sequential_mixed_io 14.2b.3, 14.2b.4

correspondence to a source line 2.2
determining number of in direct input-

READ_BY_KEY (VAX Ada input-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 Ada input-output

procedure)

output file 14.2.4

locking in a relative or indexed access file
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

in an instance of 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 Ada predefined function)
[see system.read_register]
Real literal 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

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 deciaration

[see: record type definition, type declaration]
as a declarative region 8.1

determining the visibility of another
declaration 8.3

Index—46

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_IO (VAX Ada predefined

input-output package)14.2b.7
requisite specification of FORM
parameter with 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)

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

[see: system.remghi]
REMQ_STATUS (VAX Ada predefined type)

[see: system.remq_status]
REMQTI (VAX Ada predefined procedure)

[see: system.remqti]
Renaming declaration 8.5; 4.1, 12.1.3, D
[see also: name]
as a basic declaration 3.1

of a scalar type 3.5

as a declarative region 8.1

result for real operands 4.5.7

cannot rename a universal_fixed

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 Ada input-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_IO (VAX Ada predefined input-output
package) 14.2a.2

requisite specification of FORM
parameter with 14.1.b, 14.2a.1

element locking in 14.2a

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 names 4.1.3

to overioad a library unit 10.1
to overload a subunit 10.2
to resolve an overloading ambiguity 6.6
and the pragma inline 6.3.2

and the pragma inline_generic 12.1a
and the pragma interface 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
Replacement of 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

expression that is an array aggregate

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

4.3.2

in a function body 6.5
Returned value

[see: function call]
of a function call 5.8, 6.5; 8.5
of an instance of a generic formal

as a portion of a declarative region 8.1

function 12.1.3

cannot include a forcing occurrence 13.1

of a main program 10.1

for a derived type 3.4

of an operation 3.3.3

for a private type 7.4.1
implied for a derived type 3.4

of a predefined operator of an integer
type 3.5.4

in a task specification 9.1

of a predefined operator of a real type
3.5.6, 4.5.7

Reserved word 2.9; 2.2, 2.3
RESET (input-output procedure)
in an instance of direct_io 14.2.1; 14.2.5

in an instance of sequential_io 14.2.1;

Right label bracket compound delimiter 2.2
Right parenthesis
character 2.1

14.2.3

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

Round-robin task scheduling 9.8a
Rounding

in a real-to-integer conversion 4.6

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

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 overioad resolution 6.6
Result of a function
[see: returned value]
Return

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

[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_EMAX (predefined attribute) 3.5.8; A
VAX Ada floating point values for F
SAFE_LARGE (predefined attribute) 3.5.8,

3.5.10; A

VAX Ada floating point values for F

SAFE_SMALL (predefined attribute) 3.5.8,
3.5.10; A

as the name of an entry or entry family
9.5

VAX Ada floating 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

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
whose prefix denotes a package 8.3

whose prefix denotes a record object 8.3
whose prefix 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

Scheme

[see: iteration scheme]
Scope 8.2; 8.3, D

[see also: basic operation, character literal,
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 corresponding library
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]

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
Sequence of 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 statement alternative 5.4

in a conditional entry call 9.7.2

as a compound statement 5.1

in an exception handler 11.2

in an abnormal task 9.10

in an if statement 5.3

Selected component 4.1.3; 8.3, D

[see also: direct visibility, prefix, selector,
visibility by selection, visibility]

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

as a basic operation 3.3.3; 3.3, 3.7.4,

in a timed entry call 9.7.3

3.8.2,74.2

including a raise statement 11.3

as a name 4.1

of code statements 13.8
raising an exception 11.4.1

Index—49

Sequential access file 14.2; 14.1, 14.21
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.23,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 instance of relative_io 14.2a.2,
14.2a.3

Shared variable (of two tasks) 9.11
[see also: task]

Sharp character 2.1

[see also: based literal]

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 Ada predefined

type) 3.5.4; C

in direct_mixed_io 14.2b.5, 14.2b.6

Sign of a fixed point number 3.5.9

Sign of a floating point number 3.5.7

in relative_mixed_io 14.2b.7, 14.2b.8

SET _INPUT (text_io procedure) 14.3.2; 14.3.10

Significant decimal digits 3.5.7

SET_INTERLOCKED (VAX Ada predefined
procedure)
[see: system.set_interlocked]

Simple expression 4.4
as a choice 3.7.3
as a choice in an aggregate 4.3

raising an exception 14.4

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 Ada predefined pragma)
12.1b; B

SHARED (predefined pragma) 9.11; B
[see also: volatile]

as a range bound 3.5

g);;an entry index in an accept statement
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,

visibl :;']a choice 3.7.3
.

as a formal parameter 6.4
as a label 5.1

as a name 4.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 body 7.1
in a package specification 7.1

Index—50

in a record representation clause 13.4

Source line

in a selector 4.1.3

in a VAX Ada program 2.2

in a suppress pragma 11.7

maximum number of characters in F

in a task body 9.1

in a variant part 3.7.3

Space character 2.1

[see also: basic graphic character]

in a with clause 10.1.1

as a separator 2.2

versus identifier 3.1

in a comment 2.7

Simple record (type or subtype) 13.9a.1.2; D

not allowed in an identifier 2.3
not allowed in a numeric literal 2.4.1

Simple statement 5.1

[see also: statement]
Single task 9.1

Space character literal 2.5; 2.2
Special character 2.1
[see also: basic graphic character, other

SIZE (input-output function)

special character]

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

in a delimiter 2.2

Specification

[see: declaration, discriminant specification,

[see also: storage bits]

enumeration literal specification, generic

specified by a length clause 13.2

specification, loop parameter specification,
package specification, parameter specification,

SKIP_LINE (text_io procedure) 14.3.4; 14.3.10

subprogram specification, task specification]

raising an exception 14.4

SKIP_PAGE (text_io procedure) 14.3.4; 14.3.10

STANDARD (predefined package) 8.6; C

[see also: library unit]

raising an exception 14.4

as a declarative region 8.1

enclosing the library units of a program

Slice 4.1.2

10.1.1; 10.1, 10.2

[see also: array type]

including implicit declarations of fixed

as a basic operation 3.3.3; 3.6.2, 3.8.2

point cross-multiplication and cross-

as a name 4.1

division 4.5.5

as destination of an assignment 5.2.1

implicit recompilation of 3.5.7a

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

Some order not defined by the language
[see: incorrect order dependence]

Source file
for a VAX Ada program 2.2
maximum number of lines in F

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,

address attribute, 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]

Storage address of a component 13.4
[see also: address clause]

allowed in an exception handler 11.2
as an overload resolution context 8.7

Storage bits

optimized 10.6

allocated to an object or type 13.2; 13.7.2

raising an exception 11.4.1; 11.4

[see also: size]

that cannot be reached 10.6

Statement alternative

of a record component relative to a
storage unit 13.4
size of a storage unit 13.7

[see: case statement alternative]

Static constraint 4.9

Storage deallocation
[see: unchecked_deallocation]

on a subcomponent subject to a
component clause 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 an integer 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

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

in a generic unit 12.1

raised by an allocator exceeding the

in a length clause 13.2

allocated storage 4.8; 11.1

in a number declaration 3.2, 3.2.2
in a record representation clause 13.4

raised by an elaboration of a declarative
item 11.1

in priority pragma 9.8

raised by a task activation exceeding the

whose type is a universal type 4.10

allocated storage 11.1

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;
1421, 1422, 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 minimization

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]

subject to a representation clause 13.1

subject to a suppress pragma 11.7

as the parameter of value attribute 3.5.5

with a separately compiled body 10.2

as the result of image attribute 3.5.5

exporting Ada to non-Ada programs

maximum number of characters in value

13.9a.1.4

of 3.63, F

importing non-Ada from Ada programs

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

13.9, 13.9a.1.1, 13.9a.1.2, 13.9a.1.3
Subprogram body 6.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
corresponding library unit 10.3
having dependent tasks 9.4

in a package body 7.1
including an exception handler 11.2; 11

including an exit statement 5.7

Stub
[see: body stub]

Subaggregate 4.3.2
Subcomponent 3.3; D
[see also: component, composite type, default
expression, discriminant, object]

depending on a discriminant 3.7.1; 5.2,

including a goto statement 5.9
including an implicit declaration 5.1
including a return statement 5.8

including code statements must be a
procedure body 13.8

inlined in place of each call 6.3.2
must be in the same declarative region
as the declaration 3.9, 7.1

8.5

not allowed for a subprogram subject to

of a component for which a component

an interface pragma 13.9

clause is given 13.4
renamed 8.5

that is a task object 9.2; 9.3
whose type is a limited type 7.4.4

whose type is a private type 7.4.1

Subprogram 6; D
[see also: actual parameter, completed

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, procedure call]

subprogram, derived subprogram, entry, formal

before elaboration of the body 3.9

parameter, function, library unit, overloading

statement replaced by an inlining of the

. , parameter and result type profile,

parameter, predefined subprogram, procedure,

program unit]

body 6.3.2
statement with a default actual parameter

6.4.2

as a generic instance 12.3; 12

to a derived subprogram 3.4

as a main program 10.1

to a generic instance 12

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

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

of a variable 5.2

made directly visible by a use clause 8.4

subject to a representation clause 13.1

of an operator 6.7

Subtype conversion 4.6

recompiled 10.3

[see also: conversion operation, explicit
conversion, implicit conversion, type

Subprogram specification 6.1

conversion]

and forcing occurrences 13.1

conforming to another 6.3.1

in an array assignment 5.2.1; 5.2

for a function 6.5

to a real type 4.5.7

in a body stub 10.2

Subtype declaration 3.3.2; 3.1

in a generic declaration 12.1; 12.1.3

and forcing occurrences 13.1

in a renaming declaration 8.5

as a basic declaration 3.1

in a subprogram body 6.3
including the name of a private type 7.4.1
of a derived subprogram 3.4

Subtype definition

[see: component subtype definition,
dependence on a discriminant, index subtype

Subtraction operation 4.5.3
for a real type 4.5.7

definition]

Subtype 3.3, 3.3.2; D

Subtype indication 3.3.2

[see also: attribute of . .. , base attribute,
constrained subtype, constraint, first named
subtype, operation of . .. , result subtype,
satisfy, size attribute, static subtype, type,

3.5.4,35.7,35.9

name [see: name of a subtype, type_
mark of a subtype]
not considered in overload resolution 8.7
of an access type 3.8

of an array type [see: constrained array
type, index constraint]

12.1.2

in an access type definition 3.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 an object declaration 3.2, 3.2.1
in an unconstrained array definition 3.6

including a fixed point constraint 3.5.9

of a component of an array 3.6

including a floating point constraint 3.5.7

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 parameter or result of a
renamed subprogram or entry 8.5

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

of a generic formal type 12.1.2

of an index of a generic formal array type
12.3.4

]

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

Index—54

for a subtype of a generic formal type

in a generic formal part 12.1

of an actual parameter 6.4.1

of a task type 9.2

]

as a component subtype indication 3.7

in an allocator 4.8

in a membership test 4.5.2

type, discriminant constraint]
of a scalar type 3.5

[see also: elaboration of . .
as a discrete range 3.6

unconstrained subtype]
declared by a numeric type declaration

of an object [see: elaboration of . .

including the name of a private type 7.4.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: succ attribute]

SUPPRESS (predefined pragma) 11.7; 11.1, B

SUPPRESS_ALL (VAX Ada predefined pragma)
1.7;B

SYSTEM.AST_HANDLER (VAX Ada predefined
type) 13.7a.4; 9.12a
SYSTEM.BIT_ARRAY (VAX Ada predefined 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

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 number 13.7, 13.7
1

record component 13.4
type 13.7

System services (VMS)

asynchronous 9.12a

predefined procedure) 13.7a.10

SYSTEM.FETCH_FROM_ADDRESS (VAX Ada
generic function) 13.7a.1

SYSTEM.F_FLOAT (VAX Ada predefined type)
3.5.7; 13.7a.3

SYSTEM.FINE_DELTA (predefined named number)
13.7.1

SYSTEM.G_FLOAT (VAX Ada predefined 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

calling from VAX Ada 9.12a

SYSTEM.INSQ_STATUS (VAX Ada predefined

clock interval provided by 13.7.1

type) 13.7a.10

using null_parameter (VAX Ada
predefined attribute) in calls to 13.9a.1.3

SYSTEM.INSQTI1 (VAX Ada predefined procedure)

reading volatile variables from 9.11

13.7a.10

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.MAX_DIGITS (predefined named number)
13.7.1
limit on the significant digits of a floating

point type 3.5.7

SYSTEM.MAX_INT (predefined named number)
13.7.1; 3.54

SYSTEM.ADDRESS_ZERO (VAX Ada predefined

exceeded by the value of a universal

constant) 13.7a.1; 13.7.2

expression 4.10

SYSTEM.ALIGNED_WORD (VAX Ada predefined

SYSTEM.MAX_MANTISSA (predefined named

type) 13.7a.10

number) 13.7.1

SYSTEM.ASSIGN_TO_ADDRESS (VAX Ada

SYSTEM.MEMORY_SIZE (predefined named

generic procedure) 13.7a.1

number) 13.7

Index-55

SYSTEM.MFPR (VAX Ada predefined function)

SYSTEM.TO_BIT_ARRAY_64 (VAX Ada

13.7a.9

predefined function) 13.7a.6

SYSTEM.MIN_INT (predefined named number)

SYSTEM.TO_INTEGER (VAX Ada predefined

13.7.1; 354

function) 13.7a.6

greater than the value of a universal
expression 4.10

SYSTEM.TO_UNSIGNED_BYTE (VAX Ada
predefined function) 13.7a.6

SYSTEM.MTPR (VAX Ada predefined procedure)
13.7a.9

SYSTEM.TO_UNSIGNED_LONGWORD (VAX Ada

predefined function) 13.7a.6

SYSTEM.NAME (predefined type) 13.7
SYSTEM.NO_AST HANDLER (VAX Ada

SYSTEM.TO_UNSIGNED_QUADWORD(VAX Ada

predefined function) 13.7a.6

predefined constant) 13.7a.4; 9.12a

SYSTEM.TO_UNSIGNED_WORD (VAX Ada

SYSTEM.NON_ADA_ERROR (VAX Ada predefined

predefined function) 13.7a.6

exception) 13.7a.5; 11.2
SYSTEM.TYPE_CLASS (VAX Ada predefined type)

SYSTEM.READ_REGISTER (VAX Ada predefined

13.7a.2

function) 13.7a.9

SYSTEM.UNSIGNED_BYTE (VAX Ada predefined

SYSTEM.REMQHI (VAX Ada predefined procedure)

type) 13.7a.6

13.7a.10
SYSTEM.UNSIGNED_BYTE_ARRAY (VAX Ada

SYSTEM.REMQ_STATUS (VAX Ada predefined

predefined type) 13.7a.6

type) 13.7a.10

SYSTEM.UNSIGNED_LONGWORD (VAX Ada
SYSTEM.REMQTI (VAX Ada predefined procedure)

predefined type) 13.7a.6

13.7a.10

SYSTEM.UNSIGNED_LONGWORD_ARRAY (VAX '
SYSTEM.SET_INTERLOCKED (VAX Ada
predefined procedure) 13.7a.10

Ada predefined type) 13.7a.6

static subtypes of 13.7a.7

SYSTEM.STORAGE_UNIT (predefined named

SYSTEM.UNSIGNED_QUADWORD (VAX Ada

number) 13.7; 13.4

predefined type) 13.7a.6

SYSTEM.SYSTEM_NAME (predefined constant)

SYSTEM.UNSIGNED_QUADWORD_ARRAY (VAX

13.7

Ada predefined type) 13.7a.6
[see also: system_name]

SYSTEM.UNSIGNED_WORD (VAX Ada predefined
SYSTEM.TICK (predefined named number) 13.7.1;

type) 13.7a.6

9.6

SYSTEM.UNSIGNED_WORD_ARRAY (VAX Ada
SYSTEM.TO_ADDRESS (VAX Ada predefined

predefined type) 13.7a.6

function) 13.7a.6

SYSTEM.WRITE_REGISTER (VAX Ada predefined
SYSTEM.TO_BIT_ARRAY_8 (VAX Ada predefined

procedure) 13.7a.9

function) 13.7a.6

SYSTEM_NAME (predefined pragma) 13.7; B
SYSTEM.TO_BIT_ARRAY_16 (VAX Ada

[see also: system.system_name predefined

predefined function) 13.7a.6

constant]

SYSTEM.TO_BIT_ARRAY_32 (VAX Ada
predefined function) 13.7a.6

Index—56

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]

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

calling the main program 10.1
raising an exception 11.5

scheduling 9.8 , 9.8a

Task object 9.2; 9.1, 9.5

[see also: attribute of .. . , task activation]

suspension awaiting a rendezvous 9.5

designated by an access value 9.2

suspension by a delay statement 9.6

determining task dependence 9.4

suspension by a selective wait 9.7.1

renamed 8.5

suspension of an abnormal task 9.10

[see also: main_storage pragma, task_storage
pragma, time_slice pragmal]

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

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
pragmaj

Task synchronization 9.5; 9.11

Task termination
[see: terminated task]
Task type 9.1, 9.2; D

including an implicit declaration 5.1

[see also: atfribute of . .., class of type,

must be in the same declarative region

derived type of a task type, limited type]

as the declaration 3.9, 7.1

completing an incomplete type definition

not yet elaborated at an activation 3.9

3.8.1

raising an exception 11.4.1, 11.4.2

formal parameter 6.2

specifying the execution of a task 9.2, 9.3

object initialization 3.2.1

Task communication

[see: rendezvous]

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 the visibility of

another declaration 8.3

Text of a program 2.2, 10.1
TEXT_IO (predefined input-output package) 14.3;

14, 14.1, 14.3.9, 14.3.10, C

exceptions 14.4; 14.5

including a raise statement 11.3

specification 14.3.10

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
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 by failure of an activation 9.3;
11.4.2

TICK

[see: system.tick]
TIME (predefined type) 9.6

[see also: clock, date, day, make_time, month,
system.tick, year]

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 renamed entries 8.5
subject to an address clause 13.5.1

TASK _STORAGE (VAX Ada predefined pragma)
13.2a; B

Times operator

[see: multiplying operator]

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

TITLE (VAX Ada predefined pragma) B

TO_ADDRESS (VAX Ada predefined 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 Ada predefined function)
[see: system.to_bit_array
64]

TO_INTEGER (VAX Ada predefined 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 Ada predefined

function)
[see: system.to_unsigned_word]

Transfer of control 5.1

[see also: exception, exit statement, goto
statement, return statement, terminate

alternative]

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

TRUE boolean enumeration literal 3.5.3; C

of the result of a generic formal function

Type 3.3; D

renamed 8.5

[see also: access type, appropriate for a type,

12.1.3
subject to a representation clause 13.1;

array type, attribute of . . . , base attribute,

13.6

base type, boolean type, character type,

subject to a suppress pragma 11.7

class of type, composite type, constrained

yielded by an attribute 4.1.4

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 component of 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

Type conversion 4.6

[see also: conversion operation, conversion,
explicit conversion, subtype conversion,
unchecked_conversion]

as an actual parameter 6.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]

of an index 4.1.1
of a loop parameter 5.5
of a named number 3.2, 3.2.2

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 parameter declaration 12.3.1
in an index subtype definition 3.6

in a parameter specification 6.1; 6.2
in a qualified expression 4.7

UNCHECKED_CONVERSION (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

in a relation 4.4
in a renaming declaration 8.5

12.3.2

formal parameter 6.2

in a subprogram specification 6.1

subject to a length clause 13.2

of a formal parameter of a generic formal
subprogram 12.1.3

Unconstrained subtype 3.3, 3.3.2

of a generic formal array type 12.1.2

[see also: constrained subtype, constraint,

of a static scalar subtype 4.9

subtype, type]

of the result of a generic formal function
12.1.3

Type with discriminants 3.3; 3.3.1, 3.3.2, 3.7,

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

3.7.1,7.4,7.4.1

with discriminants 6.4.1, 12.3.2

[see also: private type, record type]

as an actual to a formal private type
12.3.2

as the component type of an array that is
the operand of a conversion 4.6

Unconstrained variable 3.3, 3.6, 3.7; 12.3.1
as a subcomponent [see: subcomponent]
Undefined value
of a scalar parameter 6.2

TYPE_CLASS (VAX Ada predefined attribute)

of a scalar variable 3.2.1

13.7a.2; A
TYPE_CLASS (VAX Ada predefined type)

[see: system.type_class]

Underflow (floating point) handling in an exception
11.1

Underline character 2.1
in a based literal 2.4.2

in a decimal literal 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,

454,456, C

[see also: highest precedence operator, unary

adding operator]

Index~60

Unhandied 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 atiribute 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]

UNSIGNED_LONGWORD_ARRAY (VAX Ada
predefined type)

[see: system.unsigned_longword_array]

of a named number 3.2.2; 3.2

UNSIGNED_QUADWORD (VAX Ada predefined

result of an atiribute [see: attribute]

type)

UNIVERSAL_FIXED (predefined type) 3.5.9
result of fixed point multiplying operators

UNSIGNED_QUADWORD_ARRAY (VAX Ada

4.5.5

predefined type)

UNIVERSAL_INTEGER (predefined type) 3.5.4,
410; C

[see: system.unsigned_quadword_array]

UNSIGNED_WORD (VAX Ada predefined type)

[see: system.unsigned_word]

[see also: integer literal]
argument of 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 parameter 5.5
codes representing enumeration type

values 13.3
converted to an integer type 3.5.5
of integer literals 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 real literals 2.4, 4.2
result of an operation 4.10; 4.5

UNLOCK (VAX Ada input-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

UNSIGNED_BYTE (VAX Ada predefined type)

[see: system.unsigned_byte]
UNSIGNED_BYTE_ARRAY (VAX Ada predefined

type)

[see: system.unsigned_byte_array]

UNSIGNED_LONGWORD (VAX Ada predefined

type)

[see: system.unsigned_quadword]

[see: system.unsigned_longword]

UNSIGNED_WORD_ARRAY (VAX Ada predefined

type)

[see: system.unsigned_word_array]

UPDATE (VAX Ada input-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 case letter 2.1

[see also: basic graphic character]
A to F in a based literal 2.4.2

E in a decimal literal 2.4.1
in an identifier 2.3

Urgency of 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

Variant part 3.7.3; D

[see also: dependence on a discriminant]
in a component list 3.7

[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

in a record aggregate 4.3.1

Vertical bar character 2.1
replacement by exclamation character
2.10

of an access type [see: object

Vertical bar delimiter 2.2

designated, task object designated]

of an array type 3.6; 3.6.1 [see also:

Vertical tabulation format effector 2.1

array, slice]
of a based literal 2.4.2

Violation of a constraint
[see: constraint_error exception]

of a character literal 2.5

Visibility 8.3; 8.2, D

of a boolean type 3.5.3

of a character type 3.5.2; 2.5, 2.6

of a decimal literal 2.4.1

[see also: direct visibility, hiding, identifier,
name, operation, overloading]

of a fixed point type 3.5.9, 4.5.7

and renaming 8.5

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

determining multiple meanings of an
identifier 8.4, 8.7; 8.5
determining order of compilation 10.3

of a string literal 2.6; 2.10

due to a use clause 8.4

of a task type [see: task designated]
returned by a function call [see: returned

of a basic operation 8.3
of a character literal 8.3

value]

of a default for a generic formal

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

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 name of an exception 11.2

of an operation declared in a package
7.4.2

of an operator symbol 8.3

formal parameter 6.2

of a renaming declaration 8.5

of an array type as destination of an

6.3

7.2

in an assignment statement 5.2

assignment 5.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: component clause, record type]
in a variant part 3.7.3

of a subprogram declared in a package
of declarations in a package body 7.3
of declarations in a package specification
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]

Index—62

Visible part (of a package) 7.2; 3.2.1, 7.4, 7.4
1,

WRITE_REGISTER (VAX Ada predefined

7.4.3,D

procedure)

[see also: deferred constant declaration,
private type declaration]

expanded name denoting a declaration in

[see: system.write_register]
Writing to an output file 14.1, 14.2.2, 14.2.4

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

Xor operator

VOLATILE (VAX Ada predefined pragma) 9.11; B

Wait

[see: selective wait, task suspension]

[see: logical operator]

YEAR (predefined function) 9.6

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 Ada software, 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
Isection . . .

lversion 1983
topic . ..

The section line should include the section number, the paragraph number enclosed
in parentheses, your name or affiliation (or both), and the date in ISO standard form
(year-month-day). The paragraph number is the one given in the margin of the paper
form of this document (it is not contained in the ECLB files); paragraph numbers are

optional, but very helpful. For example, here is the section line of comment #1194 on a
previous version:

Isection 03.02.01(12)D.Taffs 82—-04—26

The version line for comments on the current standard should contain only “lversion
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 line is
essential, and you are kindly asked to avoid topics such as “Typo” or “Editorial
comment”, which will not convey any information when printed 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 including all the information of a
comment, as in the following topic line:

'topic Insert: “ ... are {implicitly} defined by a subtype declaration”
As a firllal example here is a complete comment received on a prior version of this
manual:

Isection 03.02.01(12)D.Taffs 82-04—-26

version 10
'topic Subcomponents of 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 component is

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 your electronic, 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 KAQ2/2

Alaska, or Hawaii

P.O. Box 13000

100 Herzberg Road
Kanata, Ontario, Canada K2K 2A6
International

Internal®

Local DIGITAL subsidiary or
approved distributor

SDC Order Processing - WMO/E15
or

Software Distribution Center
Digital Equipment Corporation
Westminster, Massachusetts 01473

1For 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 and are eligible to receive one under Software Performance
Report (SPR) service, submit your comments on an SPR form.
Thank you for your assistance.

Excellent
I rate this manual’s:
[
Accuracy (software works as manual says)
[]
information)
Completeness (enough
L]
Clarity (easy to understand)
O
matter)
subject
of
Organization (structure
]
Figures (useful)
[
(useful)
Examples
L]
topic)
find
to
(ability
Index
L]
Page layout (easy to find information)

Good
]
L]
]
O
O
L]
L]
O

Fair
OJ
[]
]
]
L]
[]
]
]

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

of the software this manual describes.
Dept.

Date

Company
Mailing Address
Phone

Poor
O]
O]
]
L]
]
L]
L]
L]

-——

Do Not Tear - Fold Here and Tape

——~——

e e e e e

-I-—'—l

—

dlilgiltialIfg

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

B
.

]
R

DIGITAL EQUIPMENT CORPORATION
Corporate User Publications—Spit Brook

]

ZK01-3/J35
110 SPIT BROOK ROAD

NASHUA, NH 03062-9987

Do Not Tear - Fold Here

—

-—-—

VAX Ada Language Reference Manual

Reader’s Comments

AA-EG29B-TE

Please use this postage-paid form to comment on this manual. If you require a written
reply to a software problem and are 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:

Excellent

Good

Fair

Poor

]
[
[
]
]
L]
]
]

N
[
[
]
[]
[]
L]
W

]
L]
L]
[
[l
]
]
]

O
[
]
]
[
]
[]
O

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

of the software this manual describes.
Dept.

Company

Date

Mailing Address
Phone

——~

Do Not Tear - Fold Here and Tape

—

|l
No Postage

dlilgliltial|

Necessary

if Mailed
in the

United States

.
.

]

BUSINESS REPLY MAIL
FIRST CLASS PERMIT NO. 33 MAYNARD MASS.
POSTAGE WILL BE PAID BY ADDRESSEE

]
.

I
S

]
DIGITAL EQUIPMENT CORPORATION

Corporate User Publications—Spit Brook

ZK01-3/J35
110 SPIT BROOK ROAD

NASHUA, NH 03062-9987

——=—Do Not Tear - Fold Here

]