PowerAda APPENDIX A. Glossary

From OC Systems Wiki!
Jump to: navigation, search

American National Standards Institute (ANSI)

An organization sponsored by the Computer and Business Equipment Manufacturers Association through which accredited organizations create and maintain voluntary industry standards.


See American National Standards Institute (ANSI).

baseline project

A project which has been "frozen" so it may be used as the parent baseline for other projects intended to contain incremental changes to the baseline. A project is marked as a baseline using the Make Baseline operation in the Project menu, or with the aprojbaseline command-line tool.

baselines file

A text file identified by the environment variable POWERADA_BASELINES, which associates aliases (simple names), with baseline projects. This allows aliases to remain constant while the actual projects they reference may be moved or replaced. If the current project or its ancestors were created using an alias for a baseline, POWERADA_BASELINES must identify an existing baselines file associating that alias with an existing project root directory.

base name

In PowerAda, a compilation unit name specified without its type qualifier of lib/ or sec/, such as text_io; or a file name without the path to its enclosing directory, e.g., textiob.ada.


In PowerAda, the operation of producing a complete Ada executable program given the name of a main unit and a program library. This processing includes confirming all units are present, generating an elaboration order, generating code to elaborate library units in the program, generating a script to link the object code using the ld command, running this script, and cleaning up afterward.


A place in a program, specified by a command or condition, where the system stops execution and gives control to the user or to a specified program, such as the PowerAda debugger.

changed file

In PowerAda, an Ada source file which a different time stamp and a different source checksum than the file by the same name that is currently loaded or compiled.


See configuration management.


  1. Configuration management (CM) information associated with a text file and the compilation unit(s) it contains, and shown by the PowerAda navigator and other tools.
  2. The name of a pragma recognized by the PowerAda compiler which specifies a text string to be recorded as the CM information for the source file containing it. The pragma SCCS_ID is an equivalent pragma. A common argument to pragma CM_INFO is an sccs_id string.


  1. Instructions to the computer.
  2. To write instructions for the computer.
  3. A representation of a condition, such as an error code.
  4. To represent data or a computer program in a symbolic form that can be accepted by a data processor.


In PowerAda, a compilation is generally the translation of an Ada source program into an executable object module. When you use the PowerAda debugger, a compilation consists of one or more compilation units in a single file. If you include three package specifications and two package bodies in one file, that file represents one compilation consisting of five compilation units: three library units and two secondary units. There is usually only one compilation unit in a compilation.

compilation unit

The smallest element of an Ada program that may be independently compiled. Formally, a compilation unit may be one of seven syntactic entities: a package specification, a package body, a subprogram specification, a subprogram body, a generic specificationspeciosities and body together, a library unit that is a generic instantiation, or a subunit. Names of compilation units are either the Ada subprogram name of the unit or (for Ada subunits) the name of the unit's ultimate ancestor followed by a period, (.), followed by the Ada subprogram name of the subunit.


  1. To translate a program written in a high-level programming language into an intermediate language, assembly language, or a matching language. See also, load.
  2. The computer actions required to transform a source file into an executable object file. A program that does this is called a compiler.

compiled unit

A unit for which semantic information and machine code has been generated, as distinguished from a pending unit for which only syntactic and dependency information has been recorded.

configuration management

The tracking and controlling of how and why source files are created, organized, accessed, and changed, and from which versions of source a program is built. This is commonly referred to as CM.


For a PowerAda compilation unit, the state where none of that unit's supporters has been recompiled since the unit itself was compiled. This state implies that all of the supporters exist, since the Ada language requires this in order for the program to be compiled. Currency implies that all supporters of a unit were compiled in the correct order, as defined by Ada language rules.

dead variable

In PowerAda, a variable that is initialized, but is not used within the context of the program. Like unreachable code, dead variables are detected and removed by the optimizer.


A program used to detect, trace, and eliminate errors in computer programs or software.


PowerAda compilation units that would have to be recompiled if another unit were to be recompiled because of the compilation order imposed by the Ada language.

delta project

A project that has a parent baseline project, and whose contents reflect "deltas" or changes to the contents of that parent.

delta sublibrary

A hidden sublibrary created within a user-visible sublibrary (e.g., adalib) to allow changes to the sublibrary while other tools such as the debugger or PowerAda Source Browser have a read-lock on it.


The Executable and Linking Format (ELF) was originally developed by Unix System Laboratories and is rapidly becoming the standard for file formats. This is the standard object file format on the Linux operating system.

executable file

A compiled and linked program which is usually generated by a compiler. Often, an executable file is named "a.out".


An error situation that may arise during program execution. Ada programs can respond to exceptions if they declare exception handlers.


For a PowerAda compilation unit U, all the direct dependents of U. That is, the set of all units whose imports (withs) include U.

extended family

The set of all of a PowerAda compilation unit's supporters and all of their families, including the associated bodies and subunits. (The supporters of a unit include only the library units required for its compilation, not the associated bodies or subunits.) The extended family of a main subprogram includes exactly those units needed to bind a program from that subprogram.

extended line number

For aprojbaseline or the PowerAda debugger (adbg),a line number relative to the Ada compilation that contains the specified compilation unit. Extended line numbers are used for debugging generic instantiations and subprograms included due to inlining.


In PowerAda, an entity--file, directory, unit or sublibrary--is referred to as external when that entity exists outside the current full project, That is, it is neither local to the working project nor shadowed in a baseline project.


A PowerAda library unit together with its body and subunits (if any). Not all potential family members need be present: a library unit may have only an implicit specification. The family of a secondary unit is that unit together with any subunits.

full imports

The transitive closure of sublibrary imports for a given sublibrary, identifying the project-relative name of all sublibraries that must be present in order for units in a given sublibrary to compile.

fully qualified name

A qualified name that includes all names in the hierarchical sequence above the structure member to which the name refers, as well as the name of the member itself.

full project

All files, directories, and sublibraries in the working project and all its imported baseline projects.


A list of PowerAda debugger commands entered recently. The history command has a default list of the 20 most recently entered commands. You can use history to re-enter a previous command, or to form a new command by editing the history reference text.


v.t. references or withs, as in "unit A imports unit B" or "sublibrary S imports sublibrary T";

n. all units named in the context specification of a library unit (stated in its with clauses) and any supporting unit specifications introduced by the compiler, for example, the standard package SYSTEM. The imports of a secondary unit are all the units named in its context specification, any supporting unit requirements introduced by the compiler, its associated parent unit (if any), and the bodies of any generic specifications included among its other imports.

The imports of a sublibrary are the all the sublibraries containing the imports of the units compiled in to that sublibrary. See sublibrary imports.

inline expansion

Replacing a call to a subprogram with the actual code of the subprogram as part of the compilation process. This results in a speed increase at run time, but may require more run-time storage. In PowerAda, this is done only when optimization is specified, and only if the subprogram and call are within the same compilation unit, or if a pragma inline is applied to the subprogram's specification.


See inline expansion.

language reference manual (LRM83)

The document Reference Manual for the Ada Programming Language (ANSI/MIL-STD-1815A-1983). This document is the official, authoritative source on the syntax and semantics of the original Ada language. The Ada95 Reference Manual (SO/IEC 8652:1995), Version 6.0 defines the Ada95 language. The Ada95 Rationale, January 1995, from Intermetrics, Inc. is a very readable description of the rationale and functionality of the new features in Ada95, and is available on-line as part of PowerAda.


In PowerAda library management, a database that stores the various intermediate code files produced by the complier and records the dependency and order of compilation information as required by the Ada language specification. When compiling a unit that depends on other (previously compiled) units, the compiler gets the required dependency information (such as the package specification of a unit that is included with a with clause) from the library. Similarly, when an Ada program unit is to be linked, the library specifies the set of units that must be included to create an executable image.

A library is implemented by a sublibrary imports file or library list file, together with the one or more sublibrary directories named by that file.

library component

In PowerAda, a package body, package specification, subprogram body, subprogram specification, or object module that resides in a library.

library list file

In PowerAda version 2, a text file containing the name of one or more sublibraries comprising an Ada program library. The default name for the library list file is alib.list. While still supported for compatibility, the library list file is superseded by the sublibrary imports file file (adalib.imports) in PowerAda 3.

library unit

In PowerAda, one of five syntactic entities: a subprogram declaration, a package declaration, a generic declaration, a generic instantiation, or a subprogram body in the case where there is no corresponding subprogram declaration. As the name implies, a library unit resides in the Ada program library. The significance of library units is that they may be referenced by other independently compiled units. This reference may either be explicit (referenced via a with clause) or implicit (such as the reference of a package body to its specification).


To interconnect items of data or portions of one or more computer programs, such as linking object programs by a linkage editor. See bind, and statically linked.


The state of an Ada program when all its compilation-unit dependencies have been resolved. To produce an executable file, the compiler does not need to do any translation of Ada source: it only needs to call the linkage-editor.

linkage editor

A program that resolves cross-references between separately-assembled object modules and then assigns final addresses to create a single relocatable load module.

link name

The symbol representing the entry point of some generated code. The terms linkname and symbol are generally used interchangeably.


To syntax-check and record the dependencies and command-line options of an Ada source file in order to enable subsequent compilation operations. Source files can be loaded in any order, creating pending units in the sublibrary. A subsequent update operation on the sublibrary then compiles the units in the correct order.


In PowerAda, an entity--file, directory, unit or sublibrary--is referred to as local when that entity exists in the working project. See shadowed and external.

lock file

In PowerAda, a file used to implement an advisory read-lock or write-lock on a sublibrary. This file is in the sublibrary directory and is called adalockfile. Deleting this file defeats locking on that sublibrary.

log file

A file that contains a record of your commands and comments and the debugger's responses. This log can be used for later analysis, for documenting program behavior, or for making comparisons after program modification.


See language reference manual (LRM83).


A series of PowerAda debugger commands that execute in sequence when you call the macro. With the macro option, you can define and manipulate new debugger commands.


In powerada, moving between views of information within a project in a manner similar to moving between "web pages" with a World Wide Web browser.,


A PowerAda library unit that is not current.

optimized unit

A PowerAda compilation unit that has been processed by one or more of the compiler's optimizing phases. Some source-level information is unavailable to the debugger when it examines the unit. You can use an optimized unit in the same contexts as the corresponding unoptimized unit. Optimized and unoptimized units can be mixed within an Ada program.


In PowerAda, the associated specification of a package body or subprogram body. The parent of a subunit or task is the body in which it was declared.

parent baseline

The baselined project relative to which changes are made in the working project. The PowerAda project mechanism supports a hierarchy, such that the contents of a project may stand alone, or represent incremental changes to a parent baseline. The parent of a project P is specified when P is created, and may later be changed. A parent baseline project is designated by its project root or by an alias defined in a baselines file.

pending unit

A unit which has been loaded (by aprojbuild or a powerada Build operation) but not yet compiled. When the pending unit is successfully compiled it becomes a compiled unit which replaces any previously compiled unit of that name in the same sublibrary.

PowerAda executable

An executable file created by the PowerAda compiler, which has stored in it additional information about the Ada compilation units and sublibraries from which it was built, allowing consistency checking, debugging, and automatic rebuilding with PowerAda tools.

program unit

One of four kinds of Ada program structures: a package, a subprogram (procedure or function), a generic, or a task.


In PowerAda, a specially marked directory and its subdirectories which define the environment in which Ada programs are built, examined, and debugged. A project is created from with powerada or with the aprojinit command line tool.

project library

An ordered set of sublibraries, defined by a single root sublibrary and the closure of all its sublibrary imports file.

project-relative name

The portion of a file's pathname with the path of the project root removed from the front. The project root may be indicated by "=/" in such pathnames. Source file names are stored in the library with "//" indicating the start of the project-relative portion of the name.

project root

The top-level directory of a project. The path of this directory is the one specified when referencing the project as a baseline project and it is relative to this directory that all paths within the project are interpreted.

qualified name

  1. A name made unique by the addition of one or more qualifiers.
  2. A data name explicitly accompanied by a specification of the class to which it belongs in a specified classification system, for example the PowerAda classification system for Ada compilation units.


  1. A unique name used to identify another name.
  2. A modifier that makes a name unique.
  3. All names in a qualified name other than the rightmost, which is called the base name or simple name.


The Ada95 Reference Manual (SO/IEC 8652:1995), Version 6.0 defines the Ada95 language. The Ada95 Rationale, January 1995, from Intermetrics, Inc. is a very readable description of the rationale and functionality of the new features in Ada95, and is available on-line as part of PowerAda.


In PowerAda, an advisory lock held on a special file in a sublibrary indicating that the sublibrary is being read, and preventing other PowerAda operations from writing in the same sublibrary. A read-lock on a sublibrary will cause the creation of a delta sublibrary by actions which create new units, such as compiling, copying, or moving.

root sublibrary

The sublibrary whose corresponding sublibrary imports file define a given project library.

run-time checks

Error checking that occurs while a PowerAda program runs. If an error is detected, the program raises an exception.


A string of special character sequences which are replaced with actual values when placing or returning a file to configuration management. If a string containing such a sequence is the argument to the PowerAda pragma CM_INFO (or its equivalent pragma, SCCS_ID), it is recorded in the library and executable file and may be viewed with a number of tools. A useful sccs_id for the CMVC configuration management system is "%E% %U%, %I%, %W%".

script file

In the PowerAda debugger, a script file is a file that contains a series of commands that can be used to drive the debugger. Script files are useful for debugging large, complex programs when you may not be able to complete a debugging session in one sitting.

secondary unit

In PowerAda, the body of a library unit (such as a subprogram body, package body, generic body, or subprogram body) or a subunit. All compilation units that are not library units are secondary units. Secondary units are not subject to reference by other independently compiled units and can be thought of as the hidden implementation of a library unit or separate declaration.


In PowerAda, an entity--file, directory, unit or sublibrary--is referred to as shadowed when that entity exists in a read-only baseline that is a parent (or ancestor) of the current project but which is not in the working project. See local.

simple name

Synonym for base name.

stab strings

Information in an XCOFF module's string table which support debugging of programs compiled with AIX compilers for C, FORTRAN and other languages. See XCOFF.

statically linked

This means that all shared libraries (e.g., libc.a) are linked into the executable. This is specified by the option -bnso on the ld command for AIX, and the -Bstatic option for Linux.


The basic component of a PowerAda library. It contains information about a set of units that have been loaded and compiled. A sublibrary is implemented as a directory, usually (though not required to be) named adalib.

sublibrary files

The Ada source files compiled into a given sublibrary. The project-relative names of the files for a sublibrary are listed in a sublibrary files file

sublibrary files file

A text file, usually called adalib.files, which names the sublibrary files associated with a given root sublibrary, usually named adalib. The sublibrary imports file associated with a sublibrary named S is named S.files in the same directory.

sublibrary imports

Other sublibraries upon which a given sublibrary directly depends. Specifically, the sublibrary imports for sublibrary S are those sublibraries other than S which contain the imports of compilation units in S. The project-relative names of the imports for a sublibrary are listed in a sublibrary imports file

sublibrary imports file

A text file, usually called adalib.imports, which names the sublibrary imports associated with a given root sublibrary, usually named adalib. The sublibrary imports file associated with a sublibrary named S is named S.imports in the same directory.


In Ada, procedure or function. Overloading makes it possible for a subprogram to be both a procedure and a function depending on how it is called.


A subunit is the implementation of a body stub, referenced by a separate clause, that corresponds to the body of a package, subprogram or generic unit.


In PowerAda, all the compilation units required by the language to allow a unit to be compiled. This consists of the unit's imports, their imports, and so on.

task identifier

In PowerAda, an alphabetic label or identification for a task. This label is determined by the debugger TASKS option. A task id is assigned to each task that has not terminated.

time stamp

Records the date and time when a PowerAda compilation unit was last modified.


For the PowerAda debugger, a listing of the routines that are in the call chain above the code you are debugging. For example, if you set a breakpoint within an Ada procedure and request a call traceback, you see a list of all the procedures that called your Ada procedure, in the order in which they called it. All the calling procedures in the call chain are listed up to, but not including, the operating system calling the original highest level routine.


Synonym for compilation unit.

unreachable code

Code that cannot be reached during program execution. Unreachable code is detected and removed as part of optimization.

unused subprograms

In PowerAda, subprograms unused only within the context of a specific program or set of units. For example, a program might call only a small subset of subprograms in a utility package. The remaining uncalled (unreachable) subprograms constitute unreachable code in the context of that program.


To make current all source files and pending units associated with a specified unit, sublibrary, library, or PowerAda executable.


In powerada, the process of creating and presenting a view of information related to the current view, or to a specific element of the current view. See navigate,


The noun "with" is used to refer to a unit named in an Ada context (with) clause, as in, "B is a with of A."

The verb "to with" is commonly used to mean "to name in an Ada with clause". Hence when we say A withs B, or B is withed by A, we mean:

with B;
package A is ... end A;

working project

The project in which all work is done, as distinguished from a baseline project which is read-only. See also, local.


In PowerAda, an advisory lock held on a lock file in a sublibrary (a per-sublibrary lock) or in the project root (a project-wide lock) indicating that the sublibrary or project is being written to, and preventing other PowerAda operations from reading or writing in the same sublibrary or project. For most tools, the default action is to wait for the lock to be released before continuing.


EXtended Common Object File Format. This is the format of object files generated by AIX compilers and assemblers and linked by the AIX ld command. This is a superset of the standard COFF format defined for many UNIX platforms. XCOFF is not well-documented in the standard AIX documentation.