The tables below provide brief descriptions and page references for many terms, including all of Ada's reserved words (shown in bold face). They do not include attributes or predefined exceptions. (See List of Attributes in Appendix A and Exception Handling in Chapter 3.)
B C D E F G H I J K L M N O P Q R S T U V W X
|abort - a reserved word used in an abort statement to terminate execution of a task and other tasks dependent upon it.||6.3, A.1|
|abs - a reserved word, an operator used to produce the absolute value of a numerical quantity.||3.1, A.1|
|abstract - a reserved word used in the declaration of a type or subprogram that has no instances, but whose concrete descendants have instances.||5.1, 5.2, 5.3, A.1|
|Abstract Data Object (ADO) - an abstract object or "state machine" with an encapsulated data structure and a set of externally visible operations also defined abstractly.||2.7, 2.9, 3.13|
|Abstract Data Type (ADT) - a set of legal values and operations on those values, where the operations are defined abstractly (e.g., mathematically) without regard to an implementation on a computer.||2.7, 2.10, 2.11,
|Abstraction - reasoning in which lower-level details are ignored while one focuses on selected higher-level concerns.||2.7|
|ACTS - Ada Conformity Assessment Test Suite -- test suite used to validate Ada 95 systems. (See ACVC)||1.6|
|accept - a reserved word that starts
an accept statement.
Accept Statement - a compound statement in a task body, which corresponds to an entry in the task declaration.
|access - a reserved word used in
declaring an access type. (Access is also an attribute.)
Access Type - an Ada type whose values designate other objects or subprograms. There are two kinds: pool-specific access types and general access types.
Access Value - a value of an access type, designating another object or subprogram.
|1.6, 3.11, 4.10, 4.11,
5.6, A.1, A.3
|Actual Parameter - actual argument (value or expression) used in a call to a subprogram, entry or generic unit.||2.4, 2.5, 3.2, 6.1|
|ACVC - Ada Compiler Validation Capability -- test suite used to validate Ada 83 systems. (See ACTS)||1.6|
|Ada - a predefined package with many children (such as Ada.Text_IO and Ada.Calendar).||B.1, B.2|
|Ada, Countess of Lovelace - considered to be the first programmer.||1.5, 2.4|
|Ada Reference Manuals - documents defining the Ada language standards. [ARM83] and [ARM95]||1.5, C.0, R|
|Adjust - a procedure automatically called when assignment is done on a controlled type object.||5.7|
|ADO Package - a package that embodies an abstract data object (sometimes called an abstract state machine).||2.7, 2.9, 3.13|
|ADT Package - a package that exports one or more abstract data types, so that client units can declare objects of those types.||2.7, 2.10, 2.11,
|Aggregate - an array or record value written as a collection of component values (within parentheses).||3.6, 4.6|
|aliased - a reserved word, used in
declaring an object accessed by a general access variable.
all - a reserved word used in creating general access types, and in dereferencing.
|4.10, 4.11, A.1|
|Allocator - refers to the operation of dynamically creating a new object and returning an access value pointing to the object.||3.8, 4.10, 6.1|
|and - a reserved word, a binary Boolean operator.||3.1, 3.4, A.1|
|Anderson, Christine - led DoD Ada 9X upgrade effort, leading to Ada 95.||P|
|Anonymous Type - a one-of-a-kind array, task or protected object is said to be of "anonymous type." All other objects are instances of a type or subtype with a name.||4.1, 4.6, 6.1, 6.4|
|ANSI - American National Standards Institute||1.5, 1.6|
|ARA - Ada Resource Association, an industry group made up of Ada compiler vendors.||C.0|
|array - a reserved word, a
composite object whose components are all of the same type.
Array Type - an Ada composite type whose components are all of the same type. Components are selected by indexing.
|4.1, 4.6, A.1|
|ASCII Character Set - first 128 of the 256 in the Latin-1 set.||4.3|
|Assembly Code - code written in assembly (machine) language.||3.14|
|Assignment Statement - a simple statement that evaluates an expression and stores the value in one or more memory locations.||3.1|
|at - a reserved word used in representation clauses.||A.1|
|Attribute - a named property of a type, object, program unit, or other entity.||1.2, 2.12,
4.0 to 4.13,
5.2, 5.3, 6.1
|Barnes, John - author of Ada text books.||P, 2.7, 4.0,
|Barrier Condition - condition associated with a protected entry body that is similar to a guard associated with an accept statement. Every protected entry body must have a barrier condition.||6.4|
|Base Subtype - the subtype that contains all the values of a type. (Base is also an attribute).||4.4, A.3|
|begin - a reserved word used at the start of an executable part.||2.4, 2.5, 2.6,
6.1, 6.4, A.1
|Ben-Ari, Moti - author of an Ada text book.||P, 4.4, 4.9, 4.11,
6.4, C.0, R
|Block or Block Statement - a compound statement used to localize declarations or exception handlers.||3.7, 3.8|
|Booch, Grady - author of books on Ada and object technology.||P, 2.7, 5.1, R|
|body - a reserved word, the part of an Ada program unit that defines the execution or implementation details.||2.2, 2.3, 2.4 to 2.6,
6.1, 6.4, A.1
|Body Stub - a line of code indicating that a program unit body is compiled separately from the package in which it is declared.||2.13|
|Boolean Expression - an expression
that evaluates to True or False.
Boolean Type - a built-in enumeration type with two values: True and False.
|3.3, 3.4, 4.1|
|Botton, David - creator of the AdaPower web site.||C.0|
|Box Notation - refers to the "<>" symbol used in declaring an unconstrained array type, or certain generic formal parameters.||4.6|
|Brosgol, Ben - see Acknowledgements in Preface.||P|
|Calendar (package Ada.Calendar) - a predefined environment package that provides services related to dates and time.||1.2, 1.3, 1.4,
3.4, 3.11, 6.1, B.2
|Callback - refers to the act of calling an operation and passing it a pointer (access value) to another operation that is to be invoked when a particular event occurs.||4.11|
|case - a reserved word that starts a
Case Statement - a compound statement with a multi-way selection.
|Character Literal - a single character
enclosed within apostrophe marks.
Character Type - a built-in type consisting of the 256 elements of the Latin-1 Set. (See Wide_Character type)
|4.1, 4.2, 4.3, B.1|
|Child Unit - a library unit that extends the capabilities of a previously compiled "parent" library unit.||2.3, 2.13|
|Class (Ada) - a set of types that derive from a common root type, also called a derivation class. (Class is also an attribute.)||4.12, 5.1, 5.3, A.3|
|Class (OOD) - a set of objects that share a common structure and a common behavior. (Corresponds to an Ada type)||5.1|
|Class Diagram - a UML diagram that depicts relationships between classes.||5.1|
|Class versus Module - in Ada, these two concepts are kept separate. A module is a program unit -- not to be confused with a type or a set of types that derive from a common root type.||5.2|
|Classification - An approach to object oriented development in which objects are organized into hierarchies of classes (strongly related to inheritance). (See also, the composition approach.)||1.6, 2.1, 5.0 to 5.8|
|Classwide Operation - an operation
that works the same way for all members of a derivation class, involving implicit view
conversion "toward the root."
Classwide Type - a type, written as T'Class, that is implicitly created and comprises the union of all types in the derivation class rooted at T.
|Client - a software module that depends upon other modules for services.||2.3|
|Code Statement - a simple statement used for including machine or assembly code in an Ada program.||3.14|
|Cohen, Norman - author of Ada text books.||P, 3.14, 5.2,
6.5, C.0, R
|Comment - text following "--" for the benefit of human readers and ignored by compilers.||1.1|
|Compilation, Compilation Unit - The text of a program can be submitted to the compiler in one or more compilations. Each compilation is a succession of compilation units. A compilation unit contains either the declaration, the body, or a renaming of a program unit. Program units also can appear physically nested within other program units.||2.1, 2.8,|
|Component - one element of an array or record.||4.6, 4.8, 5.2|
|Composite Type - an Ada type that has components, such as a record or array.||4.1|
|Composition - An approach to object oriented development in which objects are designed as an assembly of component objects. (See also, the classification approach.)||1.6, 2.1,|
|Compound Statement - an executable statement with multiple lines of code, containing other statements.||3.0, A.2|
|Concurrency - the simultaneous execution (or apparently simultaneous execution) of multiple tasks.||6.0 to 6.7|
|Condic, Marin - see Acknowledgements in Preface.||P|
|Conditional Entry Call - a select statement with an entry call and an alternative sequence of statements (used by a client who withdraws the call if it is not accepted immediately).||6.2|
|Conn, Richard - creator of the Public Ada Library (PAL).||C.0|
|constant - a reserved word used in declaring an object whose value cannot be changed.||2.5, A.1|
|Constrained Array - an array whose
type or subtype declaration has a range specified for each index.
Constraint - the range specified for a dimension of a constrained array.
|Context Clause - a with clause, use clause or use type clause.||1.1, 1.3, 2.8,|
|Controlled Type - a special kind of tagged type that gives the programmer extra control over what happens during initialization, assignment and finalization. (See Initialize, Adjust and Finalize.)||5.7|
|Controlling Parameter - the parameter in a dispatching call (or function return type) that determines which version of the overloaded operation will be called.||5.3, 5.5, 5.6|
|Convention - a pragma used in interfacing to the conventions used by other languages (such as the data representation conventions of C or COBOL).||1.6, B.4|
|Decimal Type - a fixed-point type where the spacing between adjacent values is a power of ten.||4.1, 4.5|
|Declaration - code that creates an association between an identifier or operator symbol and some entity. Declarations exist for every program unit, object, and named data type in a program. (A program unit's declaration is its specification plus a final semi-colon.)||2.2, 2.3, 2.4,
2.6, 2.7, 4.0, 4.1
|Declarative Part - the section of a program unit or block that contains declarations.||1.2, 2.4, 2.5,
|declare -- a reserved word used at the start of a block statement.||3.8, 3.9, A.1|
|Default Value - the value applied to an in mode parameter whose declaration includes an assignment to a specific value or expression, unless a different actual value is used in a call.||2.4, 3.2|
|delay - a reserved word used in delay
statements, timed entry calls, and delay alternatives of selective accepts.
Delay Statement - a simple statement that causes suspension of execution. There are two kinds: relative delay and absolute delay.
|3.12, 6.2, A.1|
|delta - a reserved word, used in declaring a fixed-point type. It determines the precision or spacing between adjacent values. (Delta is also an attribute.)||4.5, A.1, A.3|
|Derivation Class - a hierarchy of types
derived from a common root. If the root is tagged, all of the descendant types are tagged.
If the root type is not tagged, none of the descendants are tagged.
Derived Type - an Ada type defined in terms of a parent type. The derived type is in the same classes as the parent, and inherits properties such as components and primitive operations from the parent. A type together with the types derived from it (directly or indirectly) form a derivation class.
|4.1, 4.12, 5.0 to 5.8|
|Dereferencing - finding an object to which an access value, P, refers, by using the "P.all" expression.||4.11|
|Dewar, Robert - see Acknowledgements in Preface.||P|
|digits - a reserved word used in declaring fixed-point and floating-point types. It determines the scale of the type. (Digits is also an attribute.)||4.5, A.1, A.3|
|Direct_IO (package Ada.Direct_IO) - a predefined generic package used to support the handling of files where individual data items in the file may be accessed at any time. (All items are of the same type.)||2.11, B.2|
|Discrete_Random - child of Ada.Numerics, used to generate discrete random numbers.||3.13, B.2|
|Discrete Type - an integer type or an enumeration type.||3.5, 4.1|
|Discriminant - a construct used in a type
declaration that allows for creation of different kinds of objects from the same type
Discriminated Record - a record type that is parameterized by use of a discriminant.
|Dispatching Operation - an operation or call, where a tag is used to control which operation is called -- related to dynamic polymorphism.||1.6, 4.0, 5.3, 5.5|
|do - a reserved word used in accept statements.||6.2, A.1|
|Dynamic Polymorphism - run-time dispatching to one of several possible operations having the same name.||5.2|
|Elaboration - the run-time processing of declarations, declarative parts, and program unit bodies -- used to allocate space and to provide initial values.||1.2, 2.6|
|Elementary_Functions - child of Ada.Numerics, which provides mathematical facilities.||4.12, B.2|
|Elementary Type - an Ada type that does not have components.||4.1|
|else - a reserved word used in if statements.
elsif - a reserved word used in if statements.
|Encapsulation - a technique that separates the external aspects of an object from its internal, implementation details.||2.7|
|end - a reserved word that completes various statements and units.||A.1|
|entry - a reserved word used in creating interfaces to task units and protected units.||6.1, 6.4, A.1|
|Entry Call Statement - a simple statement that issues a call to an entry of a task -- similar in form to a procedure call.||6.1|
|Entry Body - a program unit nested in the body of a protected unit, which implements the operation promised by the corresponding entry declaration.||6.4|
|Entry Family - a set of entries in a task, all having the same name.||6.1|
|Enumeration_IO - a predefined generic package exported by Ada.Text_IO, used to support input and output of text representing values of enumeration types.||2.11, B.2|
|Enumeration Type - an Ada composite type defined by an enumeration of its values, which may be identifiers or character literals.||4.1, 4.2, 4.3|
|exception - a reserved word used
in declaring and handling exceptional events.
Exception Handler - the section of code that executes after an exception occurs -- used to recover from exceptional conditions.
|2.4, 2.5, 3.1, 3.7,
3.8, 3.9, 4.9, A.1
|Executable Part - the section of a program unit or block that contains executable statements.||1.2, 2.4, 2.5, 2.6,
|Executable Statements - simple or compound statements that perform actions, such as assignments, calls, loop statements, etc.||3.0 to 3.15|
|exit - a reserved word used in exit statements, which transfer control out of loops.||3.6, A.1|
|Explicit Conversion - a type conversion that results from explicit coding by the programmer.||4.0, 4.4, 4.6|
|Export - 1) the act of providing resources from
one program unit to other, client units (e.g., a package exports types, objects,
subprograms, etc. and a task exports entries).
Export - 2) a pragma that supports the use of an Ada routine in a program written in another language.
|1.2, 1.6, 2.7,
|Expression - a formula for calculating a value.||3.1, 3.10|
|External File - a data file that is external to the program (such as disk file). Files can be created, opened, closed, written-to, and read-from using services provided by the predefined generic packages named Ada.Direct_IO, Ada.Sequential_IO, Ada.Streams, and Ada.Streams.Stream_IO.||2.11, B.1|
|Feldman, Michael - author of Ada text books and chair of SIGAda Education Working Group.||P, 2.7, 4.10,
|File Handling Services - services provided by predefined generic packages named Ada.Direct_IO, Ada.Sequential_IO, Ada.Streams, and Ada.Streams.Stream_IO.||2.11, B.1|
|Finalization (package Ada.Finalization) - a predefined environment package that provides services related to the creation and handling of controlled types.||5.7, B.2|
|Finalize - a procedure automatically called when a controlled type object is about to go out of existence.||5.7|
|Fixed (package Ada.Strings.Fixed) - a predefined package used to support manipulation of fixed-length strings.||4.7, B.2|
|Fixed_IO - a predefined generic package exported by Ada.Text_IO, used to support input and output of text representing values of user-defined fixed-point types.||2.11, 4.5, 4.6, B.2|
|Fixed-Point Type - a numeric type that has a constant spacing (delta) between adjacent values, specified by the programmer.||4.1, 4.5|
|Float - a built-in type consisting of real numbers.||4.1, 4.5, B.1|
|Float_IO - a predefined generic package exported by Ada.Text_IO, used to support input and output of text representing values of user-defined floating-point types.||2.11, 4.5, B.2|
|Float_Text_IO (package Ada.Float_Text_IO) - a predefined non-generic package that provides services related to the input and output of text representing values of the built-in type Float.||2.4, 2.5, 2.13, B.2|
|Floating-Point Type - a numeric type that uses a constant number (digits) of significant digits, specified by the programmer.||4.1, 4.5|
|for - a reserved word used in loop statements and representation clauses.||3.6, A.1|
|Formal Parameter - formal argument of a subprogram, entry or generic unit.||2.4, 2.5, 3.2, 6.1|
|Full Type Declaration - a type declaration that follows (and completes) a partial declaration of a type.||4.9|
|function - a reserved word, a subprogram that returns a value as a result; it is invoked by having its name appear in an expression.||1.2, 2.2, 2.5, 3.3|
|Function Call - an invocation of a function by having its name (and actual parameters) appear in an expression.||3.3|
|General Access Type - an access type that points to aliased objects (declared or dynamically allocated) or subprograms.||4.10, 4.11|
|generic - a reserved word used in
declaring a generic unit.
Generic Instance - In Ada, a program unit whose structure is based on a template defined by a generic unit.
Generic Instantiation - the creation of a
generic instance, based on a generic unit.
|Get - overloaded name of predefined procedures exported by Ada.Text_IO and others, used to retrieve data (character or string) from keyboard inputs.||2.6, 2.9, 2.14,
and many others
|Get-Line - predefined procedure exported by Ada.Text_IO, used to obtain a string and the number of characters in the string.||6.3|
|Gonzalez, Dean - author of Ada Handbook.||P, 6.3, C.0, R|
|goto - a reserved word used in a goto
Goto Statement - a simple statement that transfers control to a labeled location.
|Graphic Symbols (Ada) - symbols used to represent program units, relationships, types, objects, and exceptions.||2.2, 2.3, 2.6,
|Graphic Symbols (UML) - symbols used in UML class diagrams and state diagrams to represent classes, UML-style packages, inheritance, dependencies, states and transitions.||2.3, 2.5, 3.13,
|Guard - a conditional expression used to determine whether a selective alternative can be accepted.||6.2, 6.3, 6.4|
|Harbaugh, John - see Acknowledgements in Preface.||P|
|Heaney, Mathew - see Acknowledgements in Preface.||P|
|Heap (Storage Pool)- an area of memory used for dynamic allocation of entities.||4.10|
|Hierarchical Library - a hierarchy of child library units, children of children, etc. forming a subsystem descended from a single parent library unit -- a module hierarchy.||2.13|
|Hierarchy - a ranking or ordering of abstractions, such as a class hierarchy or a module hierarchy.||5.1|
|History of Ada - the language's creation was sponsored by the
US Department of Defense, and it was named after Ada, the Countess of Lovelace.
|Hoos, David - see Acknowledgements in Preface.||P|
|Ichbeah, Jean - leader of team that designed Ada 83.||P, 1.5|
|Identifier - the name of an entity.||1.1, 4.2|
|if - a reserved word, used in if
If Statement - a compound statement with conditional branching; it can have "elsif" tests and a final "else" part.
|Implicit Conversion - a type conversion that takes place automatically, without explicit coding by the programmer.||4.0, 4.5, 5.3|
|Import - a pragma used to help an Ada program call routines written in (or variables and constants declared in) other languages.||1.6, B.4|
|in - a reserved word, used in loop statements, in membership tests, and in specifying the mode of formal parameters.||2.4, 2.12,
3.3, 3.6, A.1
|Indefinite Subtype - an unconstrained array type, a record type with a discriminant and no default values, or a classwide type.||4.6, 5.3|
|Inheritance - a relationship between classes in which the inheriting class has all the properties of the inherited class and may have more. In Ada, a relationship between a parent type and another type derived from it, where the derived type has all the properties of the parent and may have more.||1.6, 2.1, 4.12,
5.0 to 5.8
|Initialization (of a package) - execution of the sequence of statements in the package's executable part (if any), which occurs during elaboration of the package.||2.6|
|Initialize - a procedure automatically called when a controlled type object is created.||5.7|
|Input/Output - a number of predefined packages Get input from the keyboard and Put output to the screen (see Text_IO, Integer_IO, Integer_Text_IO, Float_IO, Float_Text_IO, Fixed_IO and Enumeration_IO) and create and interact with external files (see Direct_IO, Sequential_IO and Stream_IO).||2.11, 4.5, B.2|
|Instance - (of a class) an object that is a member of the class.||5.1|
|Instantiation - the process of creating instances from classes. In Ada, the process of creating instances from generic units.||2.2, 2.11|
|Integer_IO - a predefined generic package exported by Ada.Text_IO, used to support input and output of text representing values of user-defined integer types.||B.2|
|Integer Type - a built-in numeric type including signed integers and modular types.||4.1, 4.5, B.1|
|Integer_Text_IO (Ada.Integer_Text_IO) - a predefined non-generic package that provides services related to the input and output of text representing values of the built-in type Integer.||2.13, 3.6, 3.8,
|Interfaces - a predefined package that (along with its children) provides facilities for interfacing with routines written in other languages.||B.1, B.4|
|Interrupt - an external event that suspends normal processing while some response action occurs. The predefined package Ada.Interrupts (see Annex C, Systems Programming) can be used to create an appropriate interrupt handler as a protected procedure.||6.4, A.4|
|is - a reserved word used in case statements, in generic instantiations, and in declaring program units, types and subtypes.||A.1|
|ISO - International Standards Organization||1.5, 1.6|
J, K and L
|Jacobson, Ivar - author of books on object technology.||5.1, R|
|Kester, Rush - see Acknowledgements in Preface.||P|
|Latin-1 Character Set - the 256 characters used to define Ada's Character type. (See also, Unicode Set.)||4.1, 4.3|
|Library or Program Library - a data base of information about compilation units that have been added to the environment. (Not a library of programs.)||2.8|
Library Unit - In Ada, a library unit is a "top-level" separately compiled program unit. In Ada 95 library units may have other library units as children. Tasks and protected objects cannot be library units. A root library unit, together with its children and grandchildren and so on, form a subsystem.
|Lifetime Rule (for Access Types) - given an
access type T, X'Access yielding a result of type T is allowed only if X can live at least
as long as T.
Lifetime Rule (for Tagged Types) - a parent tagged type may not outlive any type derived from it.
|limited - a reserved word, used in declaring a type to have limited operations, in that it cannot be used in assignments or checks for equality or inequality.||4.9, 5.2, A.1|
|Linked List - a data structure in which each element contains an access value pointing to another element.||4.10, 5.6|
|loop - a reserved word, used in the
first and last parts of a loop statement.
Loop Statement - a compound statement providing repetitious execution of a sequence of statements.
|Machine Code - code written in assembly (machine) language.||3.14|
|Main Procedure - a library procedure called from outside the language -- by a "hypothetical main task." (It does not have to be called "Main" and usually isn't.)||1.1, 2.4|
|Master - a library package, program unit, or block upon which a task depends -- often the unit in which the task is nested.||6.3|
|Membership Test - a Boolean expression using in (or not in) to determine if a value is within (or not within) a certain subtype or range.||2.12, 2.13|
|mod - a reserved word used as a unary operator and in declaring a modular type.||3.1, 4.5, A.1|
|Mode - an indication of data flow direction of parameters. The three possibilities are: in, in out, and out.||2.4, 3.2, 3.3|
|Modular Type - an unsigned integer type whose values range from 0 to n and exhibit "modulo n" arithmetic.||4.1, 4.5|
|Module versus Class - in Ada, these two concepts are kept separate. A module is a program unit -- not to be confused with a type or a set of types that derive from a common root type.||5.2|
|Move - a predefined procedure exported by Ada.Strings.Fixed, used to copy and truncate or pad strings.||4.7|
|Multi-tasking (Multi-thread Programs) - refers to programs with more than one thread of control (in Ada, more than one task).||6.0|
|Named Association (Named Notation) - use of the "formal => actual" syntax in the parameter list of a call.||3.2, 3.3|
|Nested Unit - an Ada program unit that is declared inside another program unit, and is therefore not a library unit.||1.4, 2.3, 2.6, 2.12,
|new - a reserved word used in allocating dynamic objects, and declaring derived types or generic instances.||2.11, 4.10, 4.12, A.1|
|New_Line - predefined procedure exported by Ada.Text_IO, used to skip to a new line on the screen or other output device.||2.5, 2.11, 2.12,
and many others
|not - a reserved word used as a unary Boolean operator and in membership tests. (Also used in the "null record" phrase.)||3.1, A.1|
|null - a reserved word, used in null
statements and as an access value that points to nothing.
Null Statement - a simple statement that does nothing.
|3.4, 3.11, A.1|
|Numeric Type - an integer type, fixed-point type, or floating-point type.||4.1, 4.5|
|Numerics (package Ada.Numerics) - a predefined environment package that (together with its children) provides a variety of numerical and mathematical services.||3.13, 4.12, B.2|
|Object - an instance of a class; an object has state, behavior and identity. In Ada, something that holds a value, such as a variable, constant, or instance of a user-defined type.||2.1, 2.6,
4.0, 4.1, 5.1
|Object Oriented Design (OOD)- a method of design in which the world is viewed as a collection of objects that cooperate with one another to achieve some desired functionality, and a notation for depicting both logical and physical as well as static and dynamic models of the system.||1.6, 2.1, 5.0 to 5.8|
|Object Oriented Programming (OOP)- a method of implementation in which programs are organized as collections of objects, each representing an instance of a class, and whose classes may be members of a hierarchy of classes related via inheritance.||1.6, 2.1, 5.0 to 5.8|
|of - a reserved word used in array type or one-of-a-kind array declarations.||4.6, A.1|
|One-of-a-kind Array - an array that is declared without having its type declared previously -- said to be of an anonymous type.||4.1, 4.6|
|One-of-a-kind Protected Object - a protected object that is declared without having its type declared previously -- said to be of an anonymous type.||4.1, 6.4|
|One-of-a-kind Task - a task that is declared without having its type declared previously -- said to be of an anonymous task type.||4.1, 6.1|
|Operation - a function or transformation that may be applied to objects in a class.||5.1, 5.2|
|or - a reserved word used as a binary Boolean operator and in select statements.||3.1, 3.4, A.1|
|others - a reserved word used in case statements, exception handlers, and aggregates.||3.5. A.1|
|out - a reserved word, used in specifying the mode of formal parameters.||2.4, A.1|
|Overloading - having more than one meaning for the same symbol or identifier (such as the multiple Get and Put routines in Ada.Text_IO).||2.6|
|package (Ada) - a reserved word, a program unit that specifies a group of logically related entities such as objects, types, subprograms, and other program units.||1.1, 1.2, 2.2,
2.6 to 2.13, A.1
|Package (UML) - a graphic symbol that represents a collection of classes or other model elements.||2.5|
|Parameter - formal or actual argument of a
subprogram, entry or generic unit.
Parameter Profile - the number of parameters, the base type of each parameter at each position, and the base type of the result (in the case of a function). The compiler uses this information to resolve references to overloaded names of subprograms or entries.
|2.4, 2.5, 2.8, 3.2|
|Parent Type - the type from which a new type is derived.||4.12|
|Parent Unit - the library unit whose capabilities are extended when a public or private child unit is declared.||2.3|
|Partial (Incomplete) Type Declaration - a type declaration that is incomplete, either because it is private (to be completed in the private part of a package) or it is a dynamic data structure (such as a linked list) that requires multiple steps for its declaration.||4.9|
|Partition - a program or part of a program that can be invoked from outside the Ada implementation. Partitions can run on separate processors and contain their own runtime systems.||1.6, 6.0, 6.6 , B.3|
|Polymorphism - having many forms (see static polymorphism and dynamic polymorphism).||2.11, 5.2|
|Pool-Specific Access Type - an access type that points to dynamically declared objects.||4.10|
|Positional Association (Positional Notation) - Placing the actual parameters of a call in the same order as the formal parameters.||3.2|
|pragma - a reserved word, a compiler directive. There are language-defined pragmas that give instructions for optimization, listing control, etc. An implementation may support additional (implementation defined) pragmas.||1.6, 6.1, A.1|
|Precedence - refers to the rules determining the order in which operators are considered in evaluating an expression.||3.1|
|Precision - the spacing (delta) between adjacent values of a fixed point type.||4.5|
|Predefined Environment - built-in declarations, attributes, pragmas, and a large collection of packages that provide many useful services.||1.1, 4.7, B.0|
|Predefined Exceptions - the four built-in categories (Constraint_Error, Program_Error, Storage_Error and Tasking_Error) and many others declared in packages of the predefined environment.||3.8, B.0|
|Primitive Operation - an operation of a type that is declared together with the type declaration, and is inherited by other types in the same class of types.||4.12|
|Priority - an indication of the urgency of a task (a larger number corresponds to a higher priority).||6.1|
|private - a reserved word used in declaring a private type or private child unit, or at the start of the private part of a package, task or protected unit declaration.||2.13, 4.9, 5.2, A.1|
|Private Child Unit - a library unit that extends the capabilities of its parent library unit and is accessible only to other family members.||2.3, 2.13|
|Private Part - the part of a package declaration that contains full declarations of partially declared entities, previously declared as private.||2.8, 4.9|
|Private Type - a type that has a partial view (perhaps just its name) visible to clients and whose full view is hidden from its clients.||2.10, 4.9|
|procedure - a reserved word, an Ada subprogram that is invoked by a procedure call statement.||1.1, 1.2, 2.2
|Procedure Call - a simple statement invoking a procedure.||1.1, 3.2|
|Program Unit - a program unit is either a package, a task unit, a protected unit, a protected entry, a generic unit, or a subprogram unit.||2.1, 2.2,
2.7, 2.8, 6.1, 6.4
|Propagation - the process of passing a raised exception to higher levels, seeking to find an exception handler.||3.8|
|protected - a reserved word, used
in declaring a protected unit.
Protected Object - an instance of a protected type.
Protected Operation - a legal operation on a protected type or object -- a protected procedure, protected function, or protected entry.
Protected Type - a composite type whose components are protected from concurrent access by multiple tasks.
Protected Unit - a program unit that creates either a protected type or a single protected object of anonymous type.
6.4, 6.5, A.1
|Public Child Unit - a library unit that extends the capabilities of its parent library unit and is accessible to all other units.||2.3, 2.13|
|Put - overloaded name of predefined procedures exported by Ada.Text_IO and others, used to display data (character or string) on the screen.||2.5, 2.6, 2.10,
and many others
|Put_Line - overloaded name of predefined procedures exported by Ada.Text_IO and others, used to display text strings on the screen and to skip to the next line.||1.1, 1.2, 1.3,
and many others
Q and R
|Qualified Expression - an expression preceded by a subtype name, as in Color'Silver or Metal'Silver, used to eliminate ambiguity or aid readability.||4.1|
|Queue - an ordered "line up" of tasks waiting to have entry calls accepted.||6.4, 6.5|
|raise - a reserved word used in a
raise statement to raise a user-defined exception.
Raise Statement - a simple statement that raises an exception.
|3.8, 3.9, 4.9, A.1|
|Random Number Generation - a capability provided by predefined packages, Ada.Numerics.Discrete_Random and Ada.Numerics.Float_Random.||3.13, B.2|
|range - a reserved word used in specifying the first and last values (range constraint) of a type, subtype or object. (Range is also an attribute.)||4.4, A.1, A.3|
|record - a reserved word used in
specifying a record type.
Record Type - a composite type consisting of zero or more named components, possibly of different types.
|4.8, 5.2, A.1|
|Recursion - the use of a subprogram or type to define itself.||2.4, 4.10|
|rem - a reserved word, an operator that performs remainder arithmetic on integer quantities.||3.1, A.1|
|Remote_Call _Interface (RCI) - a pragma and a library unit defined in Annex E, used in distributed systems.||6.6|
|renames - a reserved word, used in
a renaming declaration.
Renaming Declaration - a declaration that creates a new name (usually shorter) to represent an entity previously declared with another name.
|1.3, 2.8, A.1|
|Rendezvous - the Ada mechanism used to synchronize the interaction between two tasks.||6.1|
|Representation Clause - a clause that directs the compiler in the selection of the mapping of a type, object or task onto features of the underlying machine.||1.6, 6.1|
|requeue - a reserved word, used in a requeue statement, which places a calling task on a different entry queue.||6.5, A.1|
|Reserved Word - words that can be used only for particular effects. (They cannot be used as identifiers.)||1.1, A.1|
|return - a reserved word used in a
Return Statement - a simple statement that returns control to the calling unit.
|2.5, 3.10, A.1|
|reverse - a reserved word, used in a for loop to reverse the order of indexing.||3.7, A.1|
|Riehle, Richard - author of Ada articles in JOOP (Journal of Object Oriented Programming).||P, C.0|
|Rosen, Jean Pierre - author of article on composition.||1.6, 2.1, R|
|Rumbaugh, James - author of books on object technology.||5.1, R|
|Scalar Type - a discrete type or a real type.||4.1|
|Scale - the range of values (set by the number of digits) of a floating-point or fixed-point type.||4.5|
|Scope - the region of a program unit over which a declared entity has effect.||1.2, 2.6|
|select - a reserved word that starts
a select statement.
Select Statement - a compound statement that allows for two-way selection of alternatives for entry calls, or multi-way selection for accept statements.
Selective Accept Statement (Selective Wait) - the form of select statements that accepts entry calls (found in a task body).
|separate - a reserved word, used in the creation of body stubs and subunits.||2.14, A.1|
|Sequential_IO (package Ada.Sequential_IO) - a predefined generic package used to support the handling of files where data items are always accessed sequentially. (All items are of the same type.)||2.11, B.2|
|Server - a program unit that provides services to another (client) unit.||2.3|
|Shumate, Ken - author of Ada text books.||P, 2.7, R|
|SIGAda - Special Interest Group: Ada, a part of the professional society, Association for Computing Machinery (ACM).||C.0|
|Signed Type - integer type including both positive and negative numbers.||4.1, 4.5|
|Simple Statement - an executable statement with a single line of code.||3.0, A.2|
|Single-thread Program - a program with no tasks, other than the task containing the main procedure.||3.12, 6.0|
|Slice - a contiguous portion of a one-dimensional array, denoted using an index range.||4.6|
|Specification - the part of an Ada program unit that specifies its interface to other (client) units -- the unit's declaration without the final semi-colon.||2.6|
|Stack (push-down) - a last-in/first-out data structure.||2.9, 2.10, 2.11, 3.9|
|Standard - the predefined package in which the automatically-available built-in types are declared.||4.1, 4.3, 4.7, B.1|
|State Diagram - a UML diagram showing states and state transitions.||3.13, 6.3|
|Static Polymorphism - refers to compile-time decisions as to which one of several possible entities having the same name will be called or referenced.||2.11|
|Storage Pool (Heap)- an area of memory used for dynamic allocation of entities.||4.10|
|Stream_IO (package Ada.Streams.Stream_IO) - a predefined generic package used to support the handling of files where the data items are not all of the same type.||2.11, B.2|
|String Type - a built-in type -- an unconstrained array of characters.||4.1, 4.7, B.1|
|Strings (package Ada.Strings) - a predefined environment package that (together with its children) provides a variety of string-handling services.||4.7, B.2|
|Strong Typing - a characteristic of Ada making it able to catch many potential errors during compilation.||1.6, 4.0|
|Subprogram - an Ada program unit that specifies a sequence of actions. There are two kinds: procedure and function. A procedure is invoked by a procedure call statement. A function returns a value as a result; it is invoked by having its name appear in an expression.||2.2|
|Subsystem - In general, a collection of modules that have a joint purpose or role in the overall system. In Ada 95, a subsystem can be formed by a family of hierarchical library units having parent/child relationships.||2.13, 5.3|
|subtype - a reserved word, an Ada
type together with a constraint, which constrains the values of the subtype.
Subtype Name (Subtype Mark) - an identifier naming a type or subtype in its declaration.
|3.1, 4.1, 4.4, A.1|
|Subunit - a separately compiled program unit body, declared in a package declaration and having a body stub in that package's body.||2.3, 2.14, 3.7|
|Synchronization - refers to the interaction between two tasks during a rendezvous.||6.0, 6.1|
|System - the predefined package that (along with its children) defines various machine-dependent or configuration-dependent characteristics.||B.1, B.3|
|Taft, Tucker - leader of team that updated Ada to Ada 95.||P, 1.5|
|tagged - a reserved word used in
declaring a tagged type.
Tagged Type - a type whose values have a run-time type tag, which indicates the specific type from which the value originated. An operand of a class-wide tagged type can be used in a dispatching call; the tag indicates which subprogram body to invoke. Tagged types may be extended with additional components.
|5.0 to 5.8, A.1|
|task - a reserved word, an Ada program unit that operates concurrently with other units.||1.6, 2.2, 6.1, A.1|
|Task States - the five possible states: activation, executable, abnormal, completed, and terminated.||6.3|
|Task Type - a composite type whose values are tasks.||2.2, 1.6|
|terminate - a reserved word used in a select statement to create a terminate alternative.||6.3, A.1|
|Text_IO (package Ada.Text_IO) - a predefined environment package that provides a variety of services related to the input and output of text.||1.1, 1.2, 4.7, B.2 ...
and many others
|then - a reserved word used in if statements.||3.4, A.1|
|Timed Entry Call - a select statement with an entry call, a delay, and an alternative sequence of statements (used by a client who is willing to wait only so long for the call to be accepted).||6.2|
|type - a reserved word, each Ada object has a type. A type has an associated set of values, and a set of primitive operations. In Ada, types can be grouped into classes called derivation classes.||2.5, 2.6, 3.1,
4.0 to 4.13, A.1
|Type Conversion - changing a value, variable or parameter from one type to another type (such as from a real number to an integer).||4.0, 4.1|
|Type Extension - the ability to derive new tagged record types that have added components.||5.2|
|Unchecked_Deallocation (Ada.Unchecked_Deallocation) - a predefined environment package that provides deallocation services, used to prevent memory leaks.||4.10, 5.7, B.2|
|Unconstrained Array - an array whose type declaration does not have a specified range for each index, and uses the "box" notation.||4.6, 4.7|
|UML - Unified Modeling Language.||2.3, 3.13, 5.1, 6.3|
|Unicode Set - a set of 65,536 characters that are the basis for Ada's Wide_Character type.||4.1, 4.3|
|Universal Integer - an anonymous type used
in evaluating universal integer expressions. (All integer literals are considered to
belong to this type.)
Universal Real - an anonymous type used in evaluating universal real expressions. (All real literals are considered to belong to this type.)
|until - a reserved word, used in an absolute delay statement.||3.12, A.1|
|use - a reserved word used in use clauses and
Use Clause - a context clause providing direct visibility to declarations in the visible part of a named package.
|1.3, 3.14, A.1|
|Use Type Clause - a context clause that makes the primitive operations of a type (and nothing else) visible to clients.||4.8|
|Validation - the process of testing an Ada compiler with the ACVC or ACTS suite of tests, designed to check conformance to the language standard.||1.6|
|Variable - an object whose value may be modified.||2.6|
|Variant Record - a record type or object that contains different component fields, depending on its discriminant.||4.8|
|View - refers to different ways of viewing an object, such as the classwide view or an extended view of a tagged object.||4.9, 5.3|
|View Conversion - the process of converting from one view of an object to another view -- a kind of type conversion.||5.3|
|Visibility - refers to the ability to reference an entity at a location in a program.||2.7|
|Visible Part - the part of a package's declaration preceding the word private. (Entities declared in the visible part are visible to clients.)||2.6, 4.9|
W and X
|when - a reserved word, used in case statements, exception handlers, exit statements, select statements, and protected entry bodies.||3.5, 3.6,
6.3, 6.5, A.1
|while - a reserved word, used in while loop statements.||3.6, A.1|
|Wide_Character Type - a built-in type corresponding to the 65,536 characters of the Unicode Set. (See Character type)||4.1, 4.3, B.1|
|Wide_String Type - a built-in type that is an unconstrained array of Wide_Character elements.||4.1, 4.7, B.1|
|with - a reserved word used in with clauses, specification of generic formal parameters, and record type extensions.||1.1, 1.4, 2.3, 2.8,
5.2, 5.3, A.1
|With Clause - a context clause providing access to a library unit from within another program unit.||1.1, 1.4, 2.3, 2.8|
|xor - a reserved word, a binary Boolean operator.||3.1, A.1|
[ Back to top of page ]