PowerAda APPENDIX A. Glossary
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.
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.
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.
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.,
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.
- 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.
- 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.
- Instructions to the computer.
- To write instructions for the computer.
- A representation of a condition, such as an error code.
- 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.
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.
- To translate a program written in a high-level programming language into an intermediate language, assembly language, or a matching language. See also, load.
- The computer actions required to transform a source file into an executable object file. A program that does this is called a compiler.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
A program that resolves cross-references between separately-assembled object modules and then assigns final addresses to create a single relocatable load module.
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, 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.
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.
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.
A PowerAda library unit that is not current.
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.
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.
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.
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.
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.
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.
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.
- A name made unique by the addition of one or more qualifiers.
- 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.
- A unique name used to identify another name.
- A modifier that makes a name unique.
- 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.
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%".
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.
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.
Synonym for base name.
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.
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
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.
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.
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.
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.
Code that cannot be reached during program execution. Unreachable code is detected and removed as part of optimization.
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.
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;
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.