Ada '83 Quality and Style:

Guidelines for Professional Programmers

Copyright 1989, 1991, 1992 Software Productivity Consortium, Inc., Herndon, Virginia.

Index (to Postscript version)

Symbols

A

abnormal termination, 106

abort
affects 'Count, 100
dynamic task, 94
portability, 118
statement, 106

abstract data, shared, 92

abstract data object, 139

abstract data type, 44, 139

abstract state machine, 139

abstraction, 47, 83
affect on naming, 128
complete functionality, 136
data modeling, 63
enhanced by subprogram, 42
includes exception, 51
name, 22
protect with exception handler, 82
supported, 41
using constrained subtype, 72
using nested record, 65
using private type, 63
using types, 61

accept
blocking, 96
causing deadlock, 105
closed, 97
end statement, 57
indentation, 8
minimize, 103
rendezvous, 96

access, 65
affects equality, 80
I/O portability, 123
portability, 121

access function, 45

accuracy
floating point, 114
fraction, 18
greater, 113
of constant, 115
of relational expression, 69
portability, 115

acronym, capitalization, 18

active iterator, 142

actual parameter, 58
anonymous, 62

adaptability, 136

address clause, 85

adjective, for boolean object, 21

aggregate, 77
function calls in, 43

algorithm
comment in header, 29
concurrent, 45
encapsulated in generic, 137
portability, 120

alias
of dynamic data, 65
of dynamic task, 94
using address clause, 85

alignment
and nesting, 70
declaration, 10
parameter modes, 11
vertical, 5, 9, 10, 11

allocate
dynamic data, 65
dynamic task, 93

ambiguous, use clause, 78

anonymous type, 62
task, 92

anticipated change
adaptability, 136
anonymous task, 93
comment in header, 29
encapsulate, 44
parameter mode, 60

apostrophe, spacing, 6

application domain
abbreviation, 19
abbreviation affects reusability, 129

application specific, literal, 24

application-independent, name, 128

array
anonymous type, 62
attribute, 67
function calls in initialization, 43
parallel, do not use, 64
parameter passing, 85, 131
performance, 154
range, 67
slice, 71
unconstrained, 131

assignment
for private type, 63
import for limited type, 145
reduced by aggregate, 77

assumption, 131
documented through generic parameter, 146

asynchronous
'Count, 99
entity, 91

attribute
'Base, 63
'Callable, 99
'Constrained, 63
'Count, 99
'First, 66, 67
'Image, 36
'Last, 66, 67
'Length, 67
'Pos, 36
'Pred, 36
'Range, 67
'Size, 63
'Storage_Size, 116
'Succ, 36
'Terminated, 99
'Val, 36
'Value, 36
implementation-defined, 121
in generic, 132

B

binding, 47

blank lines, 12
for goto statement, 75
for label, 75
return statement, 75

block
indentation, 7
localizing exception, 82
marker comment, 34, 35
name, 56
nesting, 56
performance, 154
statement, 76
to minimize suppress, 85
use clause, 78

blocking
not busy waiting, 96
with priority, 95

body
comment, 29
end statement, 57
header, as pagination, 13
hide interface to foreign code, 85
hide Unchecked_Conversion, 83
name repeated in begin, 34
task, 106

boolean
function, name, 22
object, name, 21

boundary value, 61

busy wait, 95
created with priorities, 103
portability, 117

C

capitalization, 18
in numeric literal, 17

case statement, 71
indentation, 7
marker comment, 34
nesting, 70
use constrained subtype, 72

clause
address, 85
context
minimize, 46
visibility, 47
length, for dynamic data, 65
renames, 79
representation, 116, 119, 120
instead of enumeration, 36
use, 78, 79

closing file, portability, 123

code, formatting, 5

cohesion, 44

colon
alignment, 10, 12
spacing, 6

comma, spacing, 6

comment, 17, 24
body header, 29
data, 30
distinct from code, 33
do not repeat, 30
exception, 30
exception handler for other, 82
header, 25
file, 26
for group of routines, 28
purpose, 28
when to omit, 30
label, 75
machine code insert, 120
marker, 34
minimize, 24
numerical analysis, 115
program specification, 26
reduced by naming, 20, 24, 56, 57, 58
reduced by static expression, 24
return statement, 75
statement, 32
tasking implementation, 49
to document portability, 111
trailing, alignment, 10
type, 30

communication, 96
complexity, 103
using shared variable, 101

compilation
affected by Inline, 153
conditional, 149
separate, 41

complex communication, 103

complex data, comment, 30

concurrency, 91
See also task
affects exception behavior, 81

concurrent algorithm, 45, 91

conditional compilation, 149

conditional entry
call, 50, 102
indentation, 8

conditional expression, in while loop, 72

configuration control, 44

constant, 23
declaration, alignment, 10
in static expression, 131
to avoid use clause, 79
to reduce nesting, 70
type of, 24

constraint, 36, 60

constraint check
for generic formal, 133
performance, 155

Constraint_Error, portability, 119

context
dependency, 46
of exceptions, 50
to shorten names, 20

context clause
generic needs elaboration, 148
indentation, 8
minimize, 46
per line, 14
reduced using generic parameter, 147
visibility, 47

continuation condition, for while loop, 72

continuation line, indentation, 6, 7, 9

conversion
loss of precision, 115
of a private type, 63
rational fraction, 18
type, 61
unchecked, 83, 122

copyright notice, 26

coupling
data, 45
due to pragma, 148
reduced using generic parameter, 147

cyclic activity, 45

cyclic executive, termination, 106

D

data
abstract type, 139
comment, 30
coupling, 45
dynamic, 65
grouped in package, 44
in algorithm, 137
iterator for complex, 142
protected, 101
representation, 120
shared, 45, 100
structure, 63
Unchecked_Conversion, 83

data-driven program, 150

dead code, 149

deadlock, 49
eliminate, 95

deallocation, 65

declaration
alignment, 10
anonymous task, 93
array size, 131
blank lines, 12
constant, 23
constrained subtype, 72
digits, 113
exception, 50
floating point, 114
function call in, 85
grouping, 44
hiding, 79
minimize, 46
named number, 23
per line, 14
range, 113
record, for heterogeneous data, 63
renames, 20, 78, 79
type, 20, 35
variable, 45
within block, 76

default mode, 60

default parameter, 59

delay
drift, 96
in selective wait, 102
inaccurate, 95
portability, 117
statement, 95
to avoid deadlock, 105

delimiter, spacing, 5

dependency
affects reusability, 147
comment about, 27
context, 46
reduced using generic parameter, 148

derived type, 35, 60

design
for reusability, 127
impact of concurrency, 91
impact of typing, 36
impact on nesting, 70
uses data representation, 120

digits declaration, 113

Direct_IO, 86
import private type, 147

discrete, affects equality, 80

discriminant, of a private type, 63

documentation
exception in abstraction, 50
generic formal parameter, 130
hidden task, 134
infinite loop, 75
invalid state, 135
object value, 21
of assumption, 131
of implementation dependency, 112
of iterator behavior, 142
of machine code, 120
of numerical analysis, 115
of system call, 122
portability, 111
table-driven code, 151
using named number, 131

drift, delay, 96

Duration, 110
portability, 117

dynamic data, 65
adaptability, 136
deallocation, 84

dynamic storage, 116

dynamic task, 93

E

elaboration, 85
of value, 23

else clause
comment, 34
nesting, 70

else part
in selective wait, 102
open alternative, 98
to avoid deadlock, 105

elsif clause, nesting, 70

encapsulation, 44
implementation dependency, 112, 119
of algorithm in generic, 137
of synchronization code, 101
supported, 41

end statement
name, 57
pagination, 13

entry
address clause, 85
attribute, 99
call, 49
avoiding Tasking_Error, 99
named association, 58
conditional, 50, 102
default parameter, 59
exceptions raised in, 50
hiding, 49
indentation, 8
interrupt, 85
minimize, 104
minimize accepts, 103
name, 22
parameter list, 58
parameter mode, 60
queue
'Count, 99
not prioritized, 94
timed, 50, 102
affects 'Count, 100

enumeration
alignment, 10, 11
in case statement, 71
literal, 78
type, 36

equality
for private type, 63
import for limited type, 145
overload operator, 80

erroneous execution, 83
not portable, 109

error
as an exception, 50
unrecoverable, use exception, 51

evaluation order
parenthesis, 67
select statement, 117

exception, 50, 80
avoiding, 81
cause, 82
comment, 27, 30
Constraint_Error, portability, 119
declaration, 50
do not propagate, 50
do not raise, 50
handler, 50, 81, 82
for Storage_Error, 65
in block, 76
in task body, 97, 106
reusability, 134
to avoid termination, 104
implementation-defined, 82, 119
in initialization, 86
keep error separate, 51
name, 50
Numeric_Error, portability, 119
part of abstraction, 51
portability, 118
predefined, 82, 118
Program_Error, 97
erroneous execution, 83
propagation, 82, 83, 134
reusability, 134
Storage_Error, 65
suppress, 85
Tasking_Error, 97, 99
user-defined, 82

execution pattern, 96
portable, 117

execution speed, 153

exit statement, 57, 72, 73
conditional, 69
in loop, 72

export, overloading in generic, 134

expression, 66
aggregate, 77
alignment, 9, 11
evaluation, portability, 115
function calls in, 43
logical, 68
nesting, 69
numeric, 113
order dependency, 87
parenthesis, 67
relational, 68, 69
slice, 71
spacing, 6
static, 23, 130
universal_real, 115
use named association, 58

F

file
closing, 123
header, 26
naming conventions, 41
organization, 41

finalization, complete functionality, 136

fixed point
in relational expression, 69
precision, 110

flag
in complex loop, 73
in while loop, 73
naming, 68

floating point
accuracy, 114, 115
affects equality, 80
arithmetic, 114
in relational expression, 69
model, 114, 115
precision, 110, 114
relational expression, 115

flow of control, 81

for loop, 72
indentation, 7
is bounded, 75

foreign code, 85

Form, parameter in predefined I/O, 123

formal parameter, 58
anonymous, 62
generic, 130
name, 58

formatter, 6, 9, 10, 11, 12, 13, 14, 15, 17, 19

FORTRAN, 64
equivalence, 85

fraction, 18

free list, 66

function
access, 45
body, indentation, 8
call

in dclaration, 85
named association, 58
recursive, 74
spacing, 6
default parameter, 59
end statement, 57
generic, 137, 147
Inline, 153
interrogative, to avoid exception, 50
name, 22
overload, 79
parameter list, 58
procedure versus, 43
return, 75
side effect, 43
specification, indentation, 8
to reduce nesting, 70

functionality, complete, 136

G

generic, 137
abstract data object, 139
abstract data type, 139
instance, indentation, 8
name, 22, 128
named association, 58
package, 47, 134
parameter, 130
accessed within task, 134
indentation, 8
to reduce coupling, 147
robustness, 132
subtype in formal, 132
to encapsulate algorithm, 137
when formal raise exception, 134

global data, access, 46

global effect, comment, 27

goto, 75
simulated by exception, 81

guard
causing Program_Error, 97
evaluation order, 117
nonlocal variable, 100
referencing 'Count, 100

guideline, violation, 24

H

heterogeneous data, 63

hidden task, 48, 134
avoid Priority, 148

hiding, declarations, 79

horizontal spacing, 5

I

if statement
avoid exit, 73
indentation, 7
marker comment, 34
nesting, 70
positive name, 68

immediately, undefined, 103

implementation
added feature, 113
comment in header, 29
encapsulate decisions, 44
hide detail, 46

implementation dependent, 119
actual limit, 111
at run time, 122
encapsulation, 112
global assumptions, 110
storage specification, 116
tentative rendezvous, 103

implementation-defined
attribute, 121
exception, 82, 119
pragma, 121
System constant, 120
Unchecked_Conversion, 84

in, 60
alignment, 12

in out, 60
for limited type, 145
used in generic formal, 132

incremental scheme, to improve performance, 155, 156

indentation, 6
affects abbreviation, 20
of declarations, 10

inequality, for private type, 63

infinite loop, 74

infix operator, 78, 79

information hiding, 41, 44
aids adaptability, 136
effects exception handling, 51
enforced through visibility, 46
using iterator, 144
using private type, 63

initialization, 85
in declaration, alignment, 10
performance, 154
procedure, 136

Inline, improves speed, 153

input/output
Low_Level_IO, 123
on access type, 123
portability, 122

instantiation
name, 22, 128
named association, 58
reusability, 137

Integer, portability, 110

Interface
portability, 120
to foreign language, 121

interface
access to device, 91
comment, 27
implementation-defined exception, 119
minimize, 46
parameter list, 58
to a device, 44, 63, 85, 123
to device data, 120
to foreign code, 85, 120, 121
undocumented, 47

interrupt
entry, 85
implementation dependent, 112
scheduling portability, 118

interval, delay, 96

iteration
bound, 74
using loop statement, 72

iterator, 142

L

late initialization, 154

length, line, 15

length clause, for dynamic data, 65

library
binding, 47
reuse, 79
separate compilation, 41

limited private type, 62
equality, 80
I/O difficult, 147
versus private, 145

line
continuation, indentation, 6
length, 15
multiple, 14
statements per, 14

linear independence, 24

literal
avoid in generic, 132
enumeration, 78
linear independence of, 23
numeric, 17, 66, 67
self-documenting, 24
string, 5
use named association, 58

localize
declaration, 76
implementation dependency, 112
scope, 78

logical operator, 68

loop, 72
array slices, 71
bound, 74
busy wait, 95, 103
conditional exit, 69
exit, 73
using relational expression, 69
indentation, 7
infinite, 74
marker comment, 35
name, 55, 57
nesting, 55, 57

Low_Level_IO, portability, 123

lower case, 18

M

machine dependency, encapsulated, 44

main program, 112

marker comment, 34

membership test, of a private type, 63

memory management
of dynamic data, 65
of task, 94
Unchecked_Deallocation, 84

mod, performance, 155

mode
alignment, 11
explicit, 60

model
floating point, 115
task, 91

model interval
affects equality, 80
affects relational expression, 69, 116

modularity, 44

multiple return statement, 76

multiprocessor, 45, 92

mutual exclusion, and priority, 95

N

name, 20
abbreviation, 19, 129
block, 56
boolean, 68
capitalization, 18
convention, 20
end statement, 57
flag, 68
formal parameter, 58
fully qualified, 20, 79
loop, 55, 57
nested record, 64
number, 23
object, 21
overloading, in generic, 134
predefined, 35
program, 22
qualified, 47
repeated in begin, 34
repeated in header, 26, 29
reusability, 128
simple, 17
state, 68
subtype, 35
type, 20, 35
use positive form, 68

named association, 58, 59
in aggregate, 77

named number, 23, 115, 130
to specify priority, 149

negative logic, in name, 68

nesting, 69
affects abbreviation, 20
block, 56
control structure, 70
expression, 69
indentation, 6
initialization exception, 86
loop, 55, 57
package, 47
record, 64

new, as an allocator, 65

non-terminating, tasks, 105

normal termination, 105

noun
as function name, 22
as identifier, 21
for record component, 21
to describe abstraction, 22

numeric
conversion, 18
encoding, 36
expression, 113
in relational expression, 69
literal, 17, 66, 67
named, 23
type, 113

Numeric_Error, portability, 119

O

operating system, dependence, 122

operator
alignment, 9, 10
equality, 80
infix, 78
logical, 68
mod, 155
overload, 80
precedence, 6, 67, 70
rem, 155
renamed, 79
short circuit, 68
spacing, 5

optimizing compiler, values not checked, 86

optional parameter, 58

order
of arguments in aggregate, 77
of elaboration, 149
of evaluation, 43, 68, 87
in expression, 67

others clause
in case statement, 71
in exception, 50, 81
in task body, 106

out, 60
alignment, 12
not for limited type, 145

overload
equality, 80
in generic, 134
operator, 80
subprogram, 79
type name, 35
use clause, 78

P

pagination, 13, 34

paragraphing, 7

parameter
adding to list, 59
aggregate, 77
alignment, 11
anonymous, 62
array, 131
declaration, per line, 14
default value, 59
for main program, 112
formal name, 58
generic formal, 130
generic reduces coupling, 147
in predefined I/O, 123
list, 58
mode, 60
alignment, 11
name in header, 27
named association, 58
number, 46
optional, 58
passing mechanism, 84
with exception, 135
profile, 79
size, 131
unmodified with exception, 134

parameter type, alignment, 12

parenthesis, 67
alignment, 11
spacing, 6
superfluous, 6

parser, use table-driven program, 150

part family, 149

passive iterator, 142

performance, 153
access to data, 45
comment in header, 27
named number, 24

period, spacing, 6

periodic activity, 96

persistent object, 47

plain loop, 72

pointer
See also access
to task, 94

polling, 95
portability, 117

portability, 15, 44, 109
comment in header, 29
execution pattern, 96
of relational expression, 69
order dependency, 87
principles, 109

positional association, 59, 77

positive logic, naming, 68

pragma
Elaborate, 86, 148
implementation-defined, 121
Inline, 153
Interface
portability, 120
to foreign code, 121
introduce coupling, 148
Priority, 94, 148
portability, 118
Shared, 101
portability, 118
Suppress, 85

precedence of operator, 67, 70

precision
fixed point, 110
floating point, 110, 114

predefined
exception
do not raise, 50
handle, 82
portability, 118
I/O parameter, 123

predefined type, 35
as a name, 20
numeric, 113

String index, 114

predicate
as function name, 22
for boolean object, 21

preemptive scheduling, 118

prioritized activity, 45

Priority, 94
can create busy wait, 103
not for hidden task, 148
portability, 118

priority inversion, 95

private type, 62
equality, 80
for numeric type, 113
versus limited, 145

problem domain, model with task, 91

procedure
as main program, 112
call
named association, 58
recursive, 74
default parameter, 59
end statement, 57
generic, 137, 147
Inline, 153
name, 22
overload, 79
parameter list, 58
parameter mode, 60
return, 75
to reduce nesting, 70
versus function, 43

processor
multiple, 92
virtual, 92

program
body, indentation, 8
grouping, 44
name, 22
pagination, 13
termination, 82, 106
visibility, 47

Program_Error, 97
erroneous execution, 83

project
abbreviation, 20
entry name, 23

prologues, as pagination, 13

propagation, 82
exception, 83, 134

Q

queue, entry not prioritized, 95

R

radix, 17
precision, 115

raise statement, in abstraction, 50

range
constraint, 60
declaration, 113
Duration, 110
in case statement, 71
scalar types, 35
values, 66

real operand, in relational expression, 69

recompilation, reduced by separate file, 42

record
assignment, 77
component, name, 21
heterogeneous data, 63
indentation, 8
map to device data, 63
nesting, 64
parameter passing, 85
with access type component, 65

recursion, bound, 74

relational expression, 68, 69
portability, 115

rem, performance, 155

renames clause, 20, 78, 79
declare in block, 76
for a type, 36

rendezvous
efficient, 96
exception during, 97
instead of shared variable, 100
tentative, 102
versus shared variable, 118
with exception handler, 104

repeat until, how to simulate, 73

representation clause
evaluate during porting, 120
for device data, 64
indentation, 9
instead of enumeration, 36
portability, 116, 119, 120

reserved word, capitalization, 18

return statement, 75

reusability, 127
library, 79
of non-terminating program, 106
renames clause, 79

robust software, 130

run time system, dependence, 122

runaway task, 106

S

safe programming, 75

scheduling
algorithm
affected by hidden task, 134
portability, 118
delay, 96
task, 106
using priority, 95

scientific notation, 17

scope
access type, portability, 121
exception, 50
minimize, 47
use clause, 78

select statement
blocking, 96
minimize, 103
portability, 117
to provide normal termination, 105

selected component, of a private type, 63

selective wait
closed alternatives, 97
efficient, 96
indentation, 8
with else, 102

semicolon, spacing, 6

sentinel value, 61

separate
compilation, 41
indentation, 8
to reduce visibility, 48

separation of concerns, 46

Sequential_IO, 86
import private type, 147

Shared, 101
portability, 118

shared data, 45
hidden task in generic, 134

shared variable, 100
portability, 118

short circuit operator, 68

side effect, 43, 69

simplification heuristics, 70

slice, 71

source text, 5, 110

spacing, 5
for goto statement, 75
for label, 75
horizontal, 5

specification
comment, 26
end statement, 57
generic, 132
header, as pagination, 13
indentation, 8
package, 46, 47
reusable part family, 149
task hiding, 49, 134

spelling, 17
abbreviation, 19
in comments, 25

Standard, 35
predefined numeric type, 113

starvation, 49

state
and exception, 50
naming, 68

statement, 69
abort, 106, 118
accept, 97, 103
block, 76
case, 71
comment, 32
delay, 95, 117
end, 57
exit, 57, 72, 73
goto, 75
indentation, 6
loop, 71
conditional exit, 69
marker comment, 34
per line, 14
return, 75
select, 97, 103
portability, 117
tentative rendezvous, 102

static
data, 65
expression, 23, 130

Storage_Error, 65

String, indexed with subtype, 114

strong typing, 35, 41, 60
to enforce assumption, 131
to reduce constraint check, 155

subprogram, 42
call
named association, 58
overhead, 43
recursive, 74
default parameter, 59
document non-portable, 111
end statement, 57
exceptions raised in, 50
generic, 137, 147
grouped in package, 44
grouping, 41
hiding task entries, 49
Inline, 153
main, 112
name, 22
overload, 79
overloading in generic, 134
parameter list, 46, 58
procedure versus function, 43
return, 75
to reduce nesting, 70

subrecord, 64

subtype, 35, 60
in case statement, 72
in generic, 132
used as range, 66

subunit
embedded, pagination, 13
file name, 41
indentation, 8
minimize context, 47
visibility, 47

Suppress, 85

symbolic, value, 23

synchronization, 91
and abort statement, 106
portability, 118
using shared variable, 100

System
portability, 120
portability of Tick, 117

system, do not comment, 27

T

table-driven program, 150

task, 45, 91
abort dynamic, 94
activation order, 117
allocate, 93
anonymous type, 92
attribute, 99
avoid termination, 104
body
exception handler, 106
indentation, 8
order, 94
communication, 49, 96, 97
complexity, 103
portability, 118
declaration, 92
document non-portable, 111
dynamic, 93
end statement, 57
hidden, 48, 134, 148
comment in header, 27
model, 91
name, 22
non-terminating, 105
parameter passing, 85
portability, 117
receiving interrupt, 112
rendezvous, 96
runaway, 106
scheduling, 106
portability, 118
specification
indentation, 8
pagination, 13
synchronization, 100
point, 118
portability, 118
termination, 104, 105
type, 92

Tasking_Error, 97, 99

temporary file, portability, 123

tentative rendezvous, 102

terminate alternative, to avoid deadlock, 105

termination, 104
abnormal, 106
controlled, 82
dynamic task, 94
file status, 123
normal, 105
of loop, 73

Text_IO, 47

thread of control, 92

Tick, portability, 117

time sliced, scheduling, 118

timed entry, 102
affects 'Count, 100
call, 50
indentation, 8

timing
affected by task, 94
execution pattern, 96

tool, 5, 25, 79

type, 60
access, 65
portability, 121
anonymous, 62
anonymous task, 92
attribute, for real value, 115
boundary value, 61
choice affects equality, 80
comment, 30
conversion, 61
precision, 115
declaration, 35
derived, 35, 60
Duration, 110
portability, 117
enumeration, 36
floating point, model, 114
grouped in package, 44
identifier, 20
Integer, 110
limited private, 62, 145
name, 20, 35
numeric, 113
of constant, 24
parameter passing, 85
predefined, 35, 113
private, 62, 145
renaming, 36
strong, 35, 41, 60
subtype, 60
suffix, 20
unconstrained array, 131
universal, 24
used as range, 66

U

Unchecked_Deallocation, 84
portability, 121

underscore, 17
in file name, 41
in numbers, 17
significant in name, 20

universal_integer, 24
portability, 110

universal_real, 24
for greater precision, 115

until loop, how to simulate, 73

upper case, 18

use clause, 78, 79
See also context clause

user-defined exception, 82
replaces implementation-defined, 119

V

verb
as entry name, 22
as procedure name, 22

vertical alignment, 9, 10, 11
See also alignment

virtual processor, 92

visibility, 46, 47, 77
using renames clause, 79

W

with clause. See context clause

Z