Developing Ada Products on OpenVMS - OpenVMS Systems

478 Pages·2000·1.3 MB·English

DEC Ada
Developing Ada Programs on
OpenVMS Systems
Order Number: AA–PWGYA–TK
January 1993
This manual describes how to compile, link, and execute DEC Ada
programs. It describes the use of the DEC Ada compiler and DEC Ada
program library manager.
Revision/Update Information: This revised manual supersedes
Developing Ada Programs on VMS
Systems (Order No. AA–EF86B–TE).
Operating System and Version: VMS Version 5.4 or higher
OpenVMS AXP Version 1.0 or higher
Software Version: DEC Ada Version 3.0
Digital Equipment Corporation
Maynard, Massachusetts
February 1985
Revised, May 1989
Revised, January 1993
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.
Restricted Rights: Use, duplication, or disclosure by the U.S. Government is subject to
restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in Technical Data and Computer
Software clause at DFARS 252.227-7013.
© Digital Equipment Corporation 1985, 1989, 1993.
All Rights Reserved.
The postpaid Reader’s Comments forms at the end of this document request your critical
evaluation to assist in preparing future documentation.
The following are trademarks of Digital Equipment Corporation: AXP, DEC, DEC Ada, DECnet,
DECset VMS, Digital, OpenVMS, ULTRIX, VAX, VAX Ada, VAX Pascal, VAXcluster, VAXELN,
VAXset, VAXStation, VMS, VAX–11/780, XD Ada, and the DIGITAL logo.
ZK5577
This document is available on CD–ROM.
This document was prepared using VAX DOCUMENT, Version 2.1.
Contents
Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiii
New and Changed Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
1 Introduction to the DEC Ada Program Development
Environment
1.1 Getting Started with DEC Ada for the Experienced
Programmer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–2
1.2 Getting Started with DEC Ada for the Novice User. . . . . . . . . . . 1–3
1.2.1 Creating a Working Directory and Defining a Current
Default Directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–5
1.2.2 Creating a Source File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–6
1.2.3 Creating a Program Library. . . . . . . . . . . . . . . . . . . . . . . . . . 1–6
1.2.4 Defining the Current Program Library . . . . . . . . . . . . . . . . . 1–7
1.2.5 Compiling the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–8
1.2.6 Displaying Unit Information . . . . . . . . . . . . . . . . . . . . . . . . . 1–9
1.2.7 Linking the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–9
1.2.8 Executing the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–10
1.2.9 Debugging the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–10
1.2.10 Compiling and Recompiling a Modified Program . . . . . . . . . . 1–11
1.3 Using the DEC Ada Program Library Manager . . . . . . . . . . . . . . 1–12
1.3.1 Overview of ACS Commands . . . . . . . . . . . . . . . . . . . . . . . . . 1–12
1.3.2 Entering ACS Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–16
1.3.3 Exiting from the Program Library Manager and Interrupting
ACS Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–17
1.3.4 Defining Synonyms for ACS Commands . . . . . . . . . . . . . . . . 1–17
1.3.5 Using DCL Commands with Program Libraries. . . . . . . . . . . 1–18
1.4 Concepts and Terminology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–18
iii
1.4.1 Program and Compilation Units . . . . . . . . . . . . . . . . . . . . . . 1–18
1.4.1.1 Compilation Unit Dependences . . . . . . . . . . . . . . . . . . . . 1–19
1.4.1.2 Current and Obsolete Units . . . . . . . . . . . . . . . . . . . . . . . 1–19
1.4.1.3 Unit and File-Name Conventions. . . . . . . . . . . . . . . . . . . 1–20
1.4.2 Order-of-Compilation Rules . . . . . . . . . . . . . . . . . . . . . . . . . . 1–22
1.4.3 Closure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–24
2 Working with DEC Ada Program Libraries and Sublibraries
2.1 Program Library and Sublibrary Operations . . . . . . . . . . . . . . . . 2–2
2.1.1 Creating a Program Library or Sublibrary. . . . . . . . . . . . . . . 2–3
2.1.2 Defining the Current Program Library . . . . . . . . . . . . . . . . . 2–5
2.1.3 Identifying the Current Program Library . . . . . . . . . . . . . . . 2–5
2.1.4 Obtaining Library Information . . . . . . . . . . . . . . . . . . . . . . . 2–5
2.1.5 Controlling Library Access. . . . . . . . . . . . . . . . . . . . . . . . . . . 2–6
2.1.5.1 Read-Only Access. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2–7
2.1.5.2 Exclusive Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2–8
2.1.6 Deleting a Program Library or Sublibrary . . . . . . . . . . . . . . . 2–9
2.2 Unit Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2–10
2.2.1 Specifying Units in ACS Commands . . . . . . . . . . . . . . . . . . . 2–10
2.2.2 Displaying General Unit Information. . . . . . . . . . . . . . . . . . . 2–11
2.2.3 Displaying Dependence and Portability Information . . . . . . . 2–12
2.2.4 Checking Unit Currency and Completeness. . . . . . . . . . . . . . 2–16
2.2.5 Using Units from Other Program Libraries . . . . . . . . . . . . . . 2–18
2.2.5.1 Copying Units into the Current Program Library . . . . . . 2–18
2.2.5.2 Entering Units into the Current Program Library. . . . . . 2–20
2.2.6 Introducing Foreign (Non-Ada) Code into a Library. . . . . . . . 2–24
2.2.7 Deleting Units from the Current Program Library . . . . . . . . 2–25
2.3 Using Program Sublibraries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2–26
2.3.1 Using ACS Commands with Program Sublibraries . . . . . . . . 2–27
2.3.2 Creating a Nested Sublibrary Structure . . . . . . . . . . . . . . . . 2–28
2.3.3 Changing the Parent of a Sublibrary . . . . . . . . . . . . . . . . . . . 2–29
2.3.4 Merging Modified Units into the Parent Library . . . . . . . . . . 2–30
2.3.5 Modifying and Testing Units in a Sublibrary
Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2–30
iv
3 Working with DEC Ada Library Search Paths
3.1 Understanding Current and Default Library Search Paths . . . . . 3–2
3.2 Defining the Current Path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3–3
3.3 Identifying the Current and Default Paths . . . . . . . . . . . . . . . . . 3–5
3.4 Modifying the Default Path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3–7
3.5 Configuring and Reconfiguring Program Libraries Using Library
Search Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3–8
3.6 Specifying Library Search Paths . . . . . . . . . . . . . . . . . . . . . . . . . 3–11
3.6.1 Understanding How Library Search Paths are Evaluated . . . 3–11
3.6.2 Specifying Library Search Paths in Commands . . . . . . . . . . . 3–12
3.6.3 Specifying Library Search Paths in Files . . . . . . . . . . . . . . . . 3–13
3.6.4 Specifying Library Search Paths in Default Paths. . . . . . . . . 3–13
4 Compiling and Recompiling DEC Ada Programs
4.1 Compiling Units into a Program Library . . . . . . . . . . . . . . . . . . . 4–4
4.2 Recompiling Obsolete Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4–6
4.3 Completing Incomplete Generic Instantiations . . . . . . . . . . . . . . 4–9
4.4 Compiling a Modified Program. . . . . . . . . . . . . . . . . . . . . . . . . . . 4–13
4.5 Forcing the Recompilation of a Set of Units. . . . . . . . . . . . . . . . . 4–14
4.6 Using Search Lists for External Source Files. . . . . . . . . . . . . . . . 4–15
4.7 Choosing Optimization Options . . . . . . . . . . . . . . . . . . . . . . . . . . 4–16
4.8 Processing and Output Options . . . . . . . . . . . . . . . . . . . . . . . . . . 4–17
4.8.1 Loading Units and Executing Compilations in a
Subprocess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4–18
4.8.2 Executing Compilations in Batch Mode . . . . . . . . . . . . . . . . . 4–18
4.8.3 Conventions for Defaults, Symbols, and Logical Names. . . . . 4–19
4.8.4 Directing Program Library Manager and Compiler
Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4–19
4.8.5 Setting Compiler Error Limits . . . . . . . . . . . . . . . . . . . . . . . . 4–20
5 Using the Professional Development Option
5.1 Overview of Smart Recompilation . . . . . . . . . . . . . . . . . . . . . . . . 5–2
5.1.1 Using Smart Recompilation to Recompile Obsolete Units . . . 5–3
5.1.2 Determining the Impact of a Change . . . . . . . . . . . . . . . . . . . 5–5
5.1.3 Forcing Recompilation when Smart Recompilation is in
Effect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5–6
5.1.4 Optimizing the Development Environment for Smart
Recompilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5–7
5.1.5 Understanding Inter-Unit Dependences. . . . . . . . . . . . . . . . . 5–8
v
5.1.6 Fragments, Inter-Dependence, and Independence . . . . . . . . . 5–8
5.1.6.1 Searching for Identifiers and Overloading Resolution . . . 5–9
5.1.6.2 Resolving Access Types . . . . . . . . . . . . . . . . . . . . . . . . . . 5–10
5.1.6.3 Inlining and Generic Expansion. . . . . . . . . . . . . . . . . . . . 5–10
5.1.6.4 With and Use Clauses. . . . . . . . . . . . . . . . . . . . . . . . . . . 5–10
5.1.6.5 Pragmas and Representation Clauses . . . . . . . . . . . . . . . 5–11
5.1.7 Coding Your Programs to Use Smart Recompilation
Efficiently. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5–11
5.2 Overview of Program Library File-Block Caching . . . . . . . . . . . . 5–13
5.3 Overview of the Directory Structure Feature. . . . . . . . . . . . . . . . 5–14
6 Linking Programs
6.1 Linking Programs Having Only DEC Ada Units . . . . . . . . . . . . . 6–2
6.2 Linking Mixed-Language Programs . . . . . . . . . . . . . . . . . . . . . . . 6–2
6.2.1 Using the ACS COPY FOREIGN and ENTER FOREIGN
Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6–3
6.2.2 Using the ACS LINK Command . . . . . . . . . . . . . . . . . . . . . . 6–6
6.2.3 Using the ACS EXPORT and DCL LINK Commands . . . . . . 6–7
6.3 Processing and Output Options . . . . . . . . . . . . . . . . . . . . . . . . . . 6–9
6.3.1 Conventions for Defaults, Symbols, and Logical Names. . . . . 6–10
6.3.2 Executing the Link Operation in a Subprocess or in Batch
Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6–10
6.3.3 Saving the Linker Command File and Package Elaboration
File. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6–11
7 Managing Program Development
7.1 Decomposing Your Program for Efficient Development . . . . . . . . 7–1
7.2 Setting up an Efficient Program Library Structure . . . . . . . . . . . 7–6
7.3 Integration with Other DEC Tools . . . . . . . . . . . . . . . . . . . . . . . . 7–10
7.3.1 Setting up Source Code Directories . . . . . . . . . . . . . . . . . . . . 7–10
7.3.2 Managing Source Code Modifications. . . . . . . . . . . . . . . . . . . 7–11
7.4 Efficient Use of DEC Ada on VMS Systems . . . . . . . . . . . . . . . . . 7–14
7.4.1 Reducing Disk Traffic Times . . . . . . . . . . . . . . . . . . . . . . . . . 7–14
7.4.2 Reorganizing Library Structures . . . . . . . . . . . . . . . . . . . . . . 7–16
7.5 Protecting Program Libraries. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–16
7.5.1 Program Library Access Requirements for ACS
Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–16
7.5.2 Standard User Identification Code (UIC) Based Program
Library Protection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–18
7.5.3 Program Library Protection Through Access Control
Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–20
vi
7.6 Accessing Program Libraries from Multiple Systems. . . . . . . . . . 7–22
7.7 General Guidelines for Network Access . . . . . . . . . . . . . . . . . . . . 7–23
7.7.1 Network Protection Mechanisms for Program Libraries . . . . 7–23
7.7.2 Achieving Efficient Network Access to Program Libraries . . . 7–23
7.7.3 Effect of Network Failures . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–23
7.8 Accessing Program Libraries Using DFS . . . . . . . . . . . . . . . . . . . 7–24
7.8.1 Configuring a Program Library using DFS . . . . . . . . . . . . . . 7–24
7.9 Accessing Progam Libraries with DECnet FAL . . . . . . . . . . . . . . 7–24
7.9.1 Configuring a Library Structure using DECnet FAL . . . . . . . 7–24
7.9.2 Restrictions on Using Program Libraries Accessed by
DECnet FAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–26
7.10 Maintaining Program Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . 7–27
7.10.1 Making References to Program Libraries Independent of
Specific Devices and Directories. . . . . . . . . . . . . . . . . . . . . . . 7–27
7.10.1.1 Using Concealed-Device Logical Names . . . . . . . . . . . . . . 7–28
7.10.1.2 Using Rooted Directory Syntax . . . . . . . . . . . . . . . . . . . . 7–29
7.10.2 Copying Program Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . 7–29
7.10.3 Backing Up and Restoring Program Libraries . . . . . . . . . . . . 7–30
7.10.4 Reorganizing Program Libraries . . . . . . . . . . . . . . . . . . . . . . 7–31
7.10.5 Verifying and Repairing Program Libraries . . . . . . . . . . . . . . 7–31
7.10.6 Recompiling Units After a New Release or Update of DEC
Ada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–35
7.11 Working with Multiple Targets . . . . . . . . . . . . . . . . . . . . . . . . . . 7–36
7.11.1 Determining DEC Ada Program Portability. . . . . . . . . . . . . . 7–36
7.11.1.1 Factors Affecting Portability . . . . . . . . . . . . . . . . . . . . . . 7–37
7.11.1.2 Features Listed in the Portability Summary . . . . . . . . . . 7–38
7.11.2 Setting the System Name . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–42
8 Debugging DEC Ada Tasks
8.1 A Sample Tasking Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–2
8.2 Referring to Tasks in Debugger Commands . . . . . . . . . . . . . . . . . 8–7
8.2.1 Ada Language Expressions for Tasks. . . . . . . . . . . . . . . . . . . 8–8
8.2.2 Task ID (%TASK). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–9
8.2.3 Pseudotask Names. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–11
8.2.3.1 Active Task (%ACTIVE_TASK) . . . . . . . . . . . . . . . . . . . . 8–11
8.2.3.2 Visible Task (%VISIBLE_TASK) . . . . . . . . . . . . . . . . . . . 8–11
8.2.3.3 Next Task (%NEXT_TASK) . . . . . . . . . . . . . . . . . . . . . . . 8–12
8.2.3.4 Caller Task (%CALLER_TASK) . . . . . . . . . . . . . . . . . . . . 8–12
8.2.4 Debugger Support of Ada Task Attributes . . . . . . . . . . . . . . . 8–13
8.3 Displaying Task Information (SHOW TASK) . . . . . . . . . . . . . . . . 8–13
8.3.1 Displaying Basic Information on All Tasks . . . . . . . . . . . . . . 8–14
vii
8.3.2 Selecting Tasks for Display . . . . . . . . . . . . . . . . . . . . . . . . . . 8–17
8.3.2.1 Task List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–17
8.3.2.2 Task-Selection Qualifiers . . . . . . . . . . . . . . . . . . . . . . . . . 8–17
8.3.2.3 Task List and Task Selection Qualifiers. . . . . . . . . . . . . . 8–18
8.3.3 Obtaining Additional Information . . . . . . . . . . . . . . . . . . . . . 8–19
8.4 Examining and Manipulating Tasks . . . . . . . . . . . . . . . . . . . . . . 8–22
8.5 Changing Task Characteristics (SET TASK) . . . . . . . . . . . . . . . . 8–23
8.6 Setting Breakpoints and Tracepoints . . . . . . . . . . . . . . . . . . . . . . 8–25
8.6.1 Task-Specific and Task-Independent Debugger
Eventpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–25
8.6.2 Task Bodies, Entry Calls, and Accept Statements . . . . . . . . . 8–27
8.6.3 Monitoring Ada Task Events . . . . . . . . . . . . . . . . . . . . . . . . . 8–29
8.7 Additional Task-Debugging Topics . . . . . . . . . . . . . . . . . . . . . . . . 8–34
8.7.1 Debugging Programs with Deadlock . . . . . . . . . . . . . . . . . . . 8–35
8.7.2 Debugging Programs that Use Time Slicing. . . . . . . . . . . . . . 8–36
8.7.3 Using Ctrl/Y when Debugging Tasks . . . . . . . . . . . . . . . . . . . 8–37
8.7.4 Automatic Stack Checking in the Debugger. . . . . . . . . . . . . . 8–37
A ACS Command Dictionary
($) ADA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–3
ATTACH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–18
CHECK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–20
COMPILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–25
COPY FOREIGN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–45
COPY UNIT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–47
CREATE LIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–51
CREATE SUBLIBRARY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–55
DELETE LIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–59
DELETE SUBLIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–62
DELETE UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–65
DIRECTORY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–69
ENTER FOREIGN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–74
ENTER UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–77
EXIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–81
EXPORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–82
EXTRACT SOURCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–85
HELP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–89
LINK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–90
LOAD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–102
viii
MERGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–114
MODIFY LIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–118
RECOMPILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–121
REENTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–140
REORGANIZE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–144
SET LIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–146
SET PRAGMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–151
SET SOURCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–153
SHOW LIBRARY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–155
SHOW PROGRAM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–159
SHOW SOURCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–165
SHOW VERSION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–166
SPAWN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–167
VERIFY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A–169
B Comparison of DEC Ada Commands for ULTRIX and VMS
Systems
C Supplemental Information for Debugging Ada Programs
C.1 Sample Debugging Session. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C–1
C.2 Using the Package GET_TASK_INFO . . . . . . . . . . . . . . . . . . . . . C–4
D Program Design Language Support
D.1 Program Design Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–1
D.2 Program Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–4
D.3 Restrictions on Placeholders . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–6
D.4 Name Resolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–8
D.5 Design Qualifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–10
D.6 Processing Level Qualifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D–11
E Diagnostic Messages
E.1 Diagnostic Message Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . E–1
E.2 Diagnostic Messages and Their Severity . . . . . . . . . . . . . . . . . . . E–2
E.3 Informational Messages and the /[NO]WARNINGS Qualifier . . . E–4
E.4 Run-Time Diagnostic Messages . . . . . . . . . . . . . . . . . . . . . . . . . . E–5
ix
F Reporting Problems
Index
Examples
3–1 Output from the ACS SHOW LIBRARY/FULL Command . . . 3–6
7–1 Decomposed Stack Application. . . . . . . . . . . . . . . . . . . . . . . . 7–3
7–2 Command Procedure for Doing LSE Ada Compilations in
Batch Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–12
8–1 Procedure TASK_EXAMPLE . . . . . . . . . . . . . . . . . . . . . . . . . 8–2
8–2 Sample Debugger Initialization File for DEC Ada Tasking
Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–33
Figures
1 Documentation Reading Path for Related Documents . . . . . . xiv
2 Documentation Reading Path for DEC Ada
Documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv
3 Figure Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
1–1 Dependences Among the Hotel Reservation Program
Compilation Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1–4
1–2 Source Files for the Hotel Reservation Program . . . . . . . . . . 1–5
1–3 Directory Structure for the Hotel Reservation Program. . . . . 1–7
1–4 Sample Compilation Units Used to Show Closure . . . . . . . . . 1–26
2–1 Simple Nested Sublibrary Structure . . . . . . . . . . . . . . . . . . . 2–28
2–2 Sublibrary Configuration for the HOTEL Program . . . . . . . . 2–31
3–1 Program Library Configuration for Smith . . . . . . . . . . . . . . . 3–10
3–2 Program Library Reconfiguration for Smith. . . . . . . . . . . . . . 3–11
7–1 Diagram of Decomposed Stack Application . . . . . . . . . . . . . . 7–6
7–2 Efficient Program Library and Sublibrary Structure . . . . . . . 7–8
7–3 Ada Program Library and Sublibrary Structure with CMS
Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7–11
7–4 DECnet Program Library Configuration . . . . . . . . . . . . . . . . 7–25
8–1 Task State Transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–15
8–2 Diagram of a Task Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8–22
x