Ada 95 Quality and Style Guide Index
INDEX
SYMBOL enhanced by subprogram, 50,
'Base, 73 62
'Callable, 126 includes exception, 61
'Constrained, 73 name, 28, 45
'Count, 126 protect with exception
protected objects, 126, 138 handler, 101, 112
tasks, 126, 138 supported, 47
'First, 83, 110 using abstract types, 207,
'Image, 44 222
'Last, 83, 110 using constrained subtype,
'Length, 83, 110 89
'Pos, 44 using nested record, 77
'Pred, 44 using private type, 73
'Range, 83, 110 using types, 71
'Size, 73 accept, 129, 138
'Storage_Size, 154 blocking, 123
'Succ, 44 causing deadlock, 133, 138
'Terminated, 126, 133 closed, 125, 138
'Val, 44 end statement, 67, 108
'Value, 44 indentation, 11
minimize, 124, 131, 138
A rendezvous, 124, 138
abbreviation, 23, 24, 44 selective, 124, 125, 138
capitalization, 22 access, 78, 109
renames clause, 97, 111 affects equality, 98
reusability, 171 I/O portability, 163
abnormal termination, 136 portability, 160
abort to subprogram, 154
affects 'Count, 127 access function, 55
completion point, 135 access value, 52, 63
portability, 156 accuracy
statement, 134, 156 analysis, 151
task, 156 constraints, 151
abstract data object, 183 floating point, 142, 151,
abstract data type, 51, 62, 165
183 fraction, 22
abstract data types, 183, 199, greater, 150, 165
209 model, 150
abstract state machine, 183 of relational expression, 85
abstract subprograms, 209 portability, 151
abstract types, 207, 209, 211, acronym
222 capitalization, 22
abstraction, 102 active iterator, 186, 199
affect on naming, 170, 198 actual parameter, 68, 108
complete functionality, 178 anonymous, 72
data modeling, 74 Ada.Command_Line
and portability, 145
versus POSIX, 146
Ada.Strings_Bounded, 57
adaptability, 177, 198 anonymous type, 72, 108
address clause, 104 attribute, 83
adjective constrained, 75, 227, 238
for boolean object, 25, 45 function calls in
aggregate, 94 initialization, 51
function calls in, 51 indexing, 227, 238
performance, 232, 238 parallel
algorithm do not use, 76
comment in header, 36 parameter passing, 173, 198
concurrent, 55, 63 performance, 227, 228, 230,
encapsulated in generic, 181 238
portability, 158, 166 range, 83
alias slice, 87, 110
of dynamic data, 79 unconstrained, 173, 198
using address clause, 104, assignment
112 conditional, 230, 238
alignment for private type, 73
and nesting, 87 reduced by aggregate, 94,
declaration, 14 111
parameter modes, 15, 19 assumption
vertical, 9, 13, 14, 15, 19 document, 173, 198
allocate documented through generic
dynamic data, 78, 109 parameter, 181
dynamic task, 119, 138 minimizing, 173, 198
ambiguous asynchronous
use clause, 95, 111 'Count, 127
anonymous type, 72 entity, 115, 137
protected objects, 119, 137 attribute
task, 119 'Base, 73
anticipated change 'Callable, 126
adaptability, 178 'Constrained, 73
anonymous task, 119 'Count, 126
comment in header, 36 'First, 83, 110
encapsulate, 51, 63 'Image, 44
parameter mode, 70 'Last, 83, 110
apostrophe 'Length, 83, 110
spacing, 10 'Pos, 44
application domain 'Pred, 44
abbreviation, 23, 44 'Range, 83, 110
abbreviation affects 'Size, 73
reusability, 171 'Storage_Size, 154
application specific 'Succ, 44
literal, 31 'Terminated, 126
application-independent 'Val, 44
name, 170 'Value, 44
array implementation-specific, 160
in generic, 174, 198
B
binary operator
spacing, 9 case statement, 77, 88
blank lines, 16 indentation, 11
for goto statement, 92 marker comment, 41, 46
for label, 92 nesting, 87
return statement, 92, 110 performance, 229, 238
block use constrained subtype, 89
indentation, 11 child package. See package,
localizing exception, 101, child
112 class-wide operation, 212, 222
marker comment, 41, 42, 46 class-wide type, 203, 205,
name, 66 211, 216, 222
nesting, 66, 108 clause
performance, 226 address, 104
statement, 93 context
to minimize suppress, 105, minimize, 55, 63
112 visibility, 57, 64
use clause, 95, 111 length
blocking for dynamic data, 78, 109
not busy waiting, 123 renames, 96
with priority, 122 representation, 154, 158,
within protected object, 107 166
body instead of enumeration, 43,
comment, 36 46
end statement, 67, 108 use, 95, 96, 111
header closing file
as pagination, 17 portability, 162
hide interface to foreign code
code, 148 formatting, 9
hide Unchecked_Conversion, cohesion, 54
102, 112 colon
name repeated in begin, 41, alignment, 14, 15
46 spacing, 10
task, 136, 139 comma
boolean spacing, 10
function comment, 21, 31
name, 28, 45 body header, 36
object data, 38
name, 25, 45 distinct from code, 40, 46
boundary value, 70, 108 do not repeat, 38, 46
bounded error, 102 exception, 38, 46
busy wait, 122, 138 header, 32, 45
created with priorities, 131 file, 33
for group of routines, 36
C purpose, 35
Calendar when to omit, 37
portability, 156 label, 92
capitalization, 22 machine code insert, 159
in numeric literal, 21, 44 marker, 41
minimize, 32 type of, 30
numerical analysis, 151 constrained, 142
program specification, 34, constraint, 43, 70, 108
45 constraint check
reduced by naming, 24, 30, for generic formal, 175
44, 66, 68, 108 constraint checking, 175
reduced by static constructor, 52, 63, 212
expression, 30 context
return statement, 92, 110 dependency, 55, 63
statement, 40 of exceptions, 60, 64
tasking implementation, 60 to shorten names, 24
to document portability, 144 context clause
trailing generic needs elaboration,
alignment, 14 193, 199
type, 38, 46 indentation, 12
comments minimize, 55, 63
to document portability, 151 per line, 18
communication reduced using generic
complexity, 131 parameter, 192, 199
protected objects, 124 use type, 95, 111
tasks, 124 visibility, 57, 64
compilation continuation condition
affected by Inline, 236 for while loop, 89, 110
conditional, 195 continuation line
separate, 47 indentation, 10, 13, 19
complex communication, 131 controlled types, 206, 222
complex data conversion
comment, 38, 46 of a private type, 73
concurrency, 113, 225. See rational fraction, 22
task. See task type, 71
affects exception behavior, unchecked, 102, 161
99 copyright notice, 33
concurrent algorithm, 55, 63, coupling
115, 137 data, 54
conditional compilation, 195 due to pragma, 193
conditional entry reduced using generic
call, 60, 129, 138 parameter, 192
indentation, 11 cyclic activity, 55, 63
conditional expression cyclic executive
in while loop, 89, 110 termination, 134
configuration pragmas, 49
constant, 30 D
declaration dangling reference, 78, 109
alignment, 14 data
in static expression, 173
to avoid use clause, 96
to reduce nesting, 87
abstract type, 183, 199 in selective accepts, 129,
comment, 38 138
coupling, 54 inaccurate, 122, 138
dynamic, 78 portability, 155
grouped in package, 54, 63 statement, 122, 138
in algorithm, 181, 199 statements, 155
iterator for complex, 186, to avoid deadlock, 133, 139
199 delimiter
protected, 129 spacing, 9, 19
representation, 158, 166 dependency
shared, 55, 127, 138 affects reusability, 191,
structure, 74, 109 199
structures, 227 comment about, 34
Unchecked_Conversion, 102 context, 55, 63
data-driven program, 195 reduced using generic
dead code, 195, 199 parameter, 193
deadlock, 60 derived type, 42, 46, 70
eliminate, 122 design
deallocation, 78, 109 for reusability, 169
decimal types impact of typing, 43
and the Information Systems impact on nesting, 87
annex, 153 tradeoffs, 4
declaration uses data representation,
alignment, 14 158, 166
anonymous task, 119 digits declaration, 149, 165
array size, 173, 198 Direct_IO, 73, 106, 163
blank lines, 16 import private type, 181
constant, 30, 45 discrete
constrained subtype, 89 affects equality, 98
digits, 149, 165 discriminant
floating point, 151 access, 213, 222
function call in, 105, 112 of a private type, 73
grouping, 51, 63 protected objects, 117, 118,
hiding, 97 137
minimize, 55, 63 tasks, 117, 137
named number, 30, 45 discriminants
per line, 18 tasks, 118
range, 149, 165 dispatching, 188, 203, 205,
record 206, 210, 212, 222, 231,
for heterogeneous data, 75, 238
109 documentation
renames, 23, 96, 111 exception in abstraction,
type, 24, 42 60, 64
variable, 54, 63 generic formal parameter,
within block, 93, 110 171, 198
default mode, 70 hidden task, 176, 198
default parameter, 69 infinite loop, 92
delay
drift, 122, 123
invalid state, 177 entry
object value, 25, 45 address clause, 104, 112
of assumption, 173, 198 attribute, 126, 138
of implementation call, 59, 129, 137, 138, 139
dependency, 146, 164 avoiding Tasking_Error,
of iterator behavior, 186, 126, 138
199 circular, 137, 139
of machine code, 159 conditional, 129, 138
of numerical analysis, 151, named association, 68, 108
165 conditional, 60, 129, 138
of system call, 162 default parameter, 69, 108
portability, 144, 164 exceptions raised in, 60, 64
table-driven code, 196 hiding, 59
using named number, 173 indentation, 11
drift interrupt, 104
delay, 122 minimize, 132
Duration, 143, 164 minimize accepts, 131, 138
portability, 156 name, 28, 45
dynamic data, 78 parameter list, 68, 108
adaptability, 178, 198 parameter mode, 69, 108
deallocation, 103 queue
dynamic storage, 154, 166 'Count, 127
dynamic task, 119 not prioritized, 120, 138
timed, 60, 129, 138
E affects 'Count, 127
Elaborate, 106 enumeration
elaboration, 105, 112, 194 alignment, 14
of value, 30, 45 in case statement, 88, 110
else clause literal, 95, 111
comment, 41, 46 representation clause, 161
nesting, 87 type, 43, 77
else part enumeration types
in selective accept, 129, representation clauses, 44
138 equality, 98, 111, 181, 214,
open alternative, 126 223
to avoid deadlock, 133, 139 for private type, 73
elsif clause overload operator, 98
nesting, 87 erroneous execution, 102, 112
encapsulation, 51, 63 not portable, 141
implementation dependency, error
146, 158 files, 163
of algorithm in generic, 181 unrecoverable
supported, 47 use exception, 61
end statement evaluation order
name, 67 parenthesis, 84, 110
pagination, 17, 19 select statement, 156
exception, 60, 64, 99, 111,
210, 211, 222
avoiding, 99, 111
cause, 101 nesting, 86, 110
comment, 34, 38, 46 numeric, 149, 165
do not propagate, 60, 64 order dependency, 149, 165
do not raise, 60, 64 parenthesis, 84
handler, 60, 64, 99, 100, relational, 84, 85, 110
101, 111, 112, 125, 138 slice, 87
during rendezvous, 125, 138 spacing, 10
for Storage_Error, 78, 109 static, 30, 45, 172, 198
in block, 93, 110 use named association, 68,
in task body, 125, 136, 108
138, 139
reusability, 176, 198 F
to avoid termination, 132, family of parts, 194
138 file
implementation-defined, 101, closing, 162
112, 157 header, 33
in initialization, 106 naming convention, 48
keep error separate, 61 naming conventions, 47, 62
numeric error, 142 organization, 47, 62
part of abstraction, 61 finalization, 178, 206, 207,
portability, 157, 166 222
predefined, 101, 111, 112, complete functionality, 178,
157 198
Program_Error, 125, 126, 138 fixed point
erroneous execution, 102 in relational expression, 86
propagation, 101, 112, 176, precision, 143, 164
198 flag
rendezvous, 126 in complex loop, 90
reusability, 176 in while loop, 90
Storage_Error, 78, 109 naming, 84, 110
suppress, 105 floating point
Tasking_Error, 125, 126, 138 accuracy, 151
user-defined, 101, 111 affects equality, 98
execution pattern arithmetic, 150, 165
portable, 155, 166 in relational expression, 86
exit statement, 67, 89, 90, precision, 143, 151, 164
110 relational expression, 152,
conditional, 86 165
in loop, 65, 89, 110 flow of control, 99
exit status for loop, 89, 110
setting, 137, 139 indentation, 11
export is bounded, 92
overloading in generic, 175, foreign code, 148
198 Form
expression, 83, 110 parameter in predefined I/O,
aggregate, 94 162
alignment, 13, 15 formal parameter, 68, 108
evaluation
portability, 151
function calls in, 51
logical, 85
anonymous, 72 formal package, 192, 199
generic, 171 formal packages, 193
name, 68, 108 formal parameters, 176, 198
formatter, 10, 13, 14, 15, 16, formal subprograms, 216
17, 18, 19, 21, 23 formal type, 179, 199
FORTRAN, 76 instance
equivalence, 104, 112 indentation, 12
fraction, 22 name, 28, 45, 170, 198
free list, 79 named association, 68, 108
function package, 57, 175, 198
access, 55 parameter, 171, 198
body accessed within task, 176,
indentation, 12 198
call indentation, 12
in declaration, 105, 112 to reduce coupling, 192
named association, 68, 108 parameters, 192, 199
recursive, 91, 110 reusability, 169
spacing, 9 robustness, 174
default parameter, 69, 108 subtype in formal, 174, 198
end statement, 67, 108 to encapsulate algorithm,
generic, 179, 192, 199 181
Inline, 236, 238 when formal raise exception,
interrogative 176, 198
to avoid exception, 60, 64 generics, 191, 199, 216
name, 28, 45 global data
overload, 97, 111 access, 56, 63
parameter list, 68, 108 global effect
return, 92 comment, 34, 46
side effect, 50, 62 goto, 92
specification simulated by exception, 100
indentation, 12 guard
to reduce nesting, 87 causing Program_Error, 125,
use of, 50 138
functionality evaluation order, 156, 166
complete, 178 nonlocal variable, 127, 138
referencing 'Count, 127
G guideline
garbage collection violation, 32
of dynamic data, 79
Unchecked_Deallocation, 103 H
generic, 179, 192, 199, 218, header
223 file, 33
abstract data object, 183 heterogeneous data, 75, 203
abstract data type, 183 hidden task, 59, 176
abstract data types, 183, hiding
199 declarations, 97
families, 194, 199 horizontal spacing, 9
formal derived types, 207,
222
affects abbreviation, 23
I of declarations, 14, 19
identifier independence, 31, 191
abbreviation, 23, 44, 171, inequality
198 for private type, 73
capitalization, 22 infinite loop, 91, 110
constant, 30, 45 information hiding, 47, 51, 62
naming convention, 23 aids adaptability, 178
numeric, 30 effects exception handling,
object, 25, 45 62
reusability, 170, 198 enforced through visibility,
type, 24 55
use of underscore, 21 using iterator, 189
visibility, 55, 63 using private type, 73
if statement inheritance, 201
avoid exit, 90, 110 mixin, 181, 191, 199, 201,
indentation, 11 218
marker comment, 41, 46 multiple, 201, 209, 220
nesting, 87 example, 220
positive name, 84 reusability, 169
immediately initialization, 105, 178, 206,
undefined, 131 207, 213, 222
implementation in declaration
added feature, 146 alignment, 14
comment in header, 36 performance, 226, 238
encapsulate decisions, 51, procedure, 178, 198
63 input/output
hide detail, 56, 63 on access type, 163
implementation dependent, 158, portability, 162, 167
166 stream_IO, 162
at run time, 161, 167 instantiation
encapsulation, 146 name, 28, 45, 170, 198
global assumptions, 143 named association, 68, 108
storage specification, 154 reusability, 179, 199
tentative rendezvous, 131 Integer
implementation-defined portability, 143, 164
exception, 101, 112, 157 interface
System constant, 159 access to device, 55, 63,
Unchecked_Conversion, 103 114, 137
implementation-specific comment, 34, 46
attribute, 160 implementation-defined
pragma, 160 exception, 157, 166
in minimize, 55
alignment, 15 parameter list, 68, 108
in out portability, 158
used in generic formal, 174, to a device, 51, 63, 75,
198 104, 109, 112
indentation, 10 to device data, 158
to foreign code, 148, 159 enumeration, 95, 111
to foreign language, 159, linear independence of, 30,
166 45
undocumented, 56 numeric, 21, 44, 83, 110
interrupt self-documenting, 31
entry, 104 string, 9
handler, 233, 238 use named association, 68,
implementation dependent, 108
146, 165 localize
scheduling portability, 156, declaration, 93, 110
166 implementation dependency,
interval 146
delay, 123 scope, 95, 111
iteration logical operator, 85
bound, 91 loop, 89
using loop statement, 89, array slices, 87, 110
110 bound, 91, 110
iterator, 186, 189 busy wait, 122, 131, 138
conditional exit, 86
L exit, 90, 110
label, 92 using relational
delimiter, 10 expression, 86
indentation, 11 indentation, 11
late initialization, 226, 238 infinite, 91, 110
length marker comment, 42
line, 19 name, 65, 67, 108
length clause nesting, 65, 67, 108
for dynamic data, 78, 109 lower case, 22
library
reuse, 97 M
separate compilation, 47, machine code
57, 62 not portable, 159
library unit machine dependency
child, 63. See also package, encapsulated, 51, 63
child. Seealsopackage,child main program, 144
limited private type marker comment, 41
I/O difficult, 181 membership test
versus private, 72, 179 of a private type, 73
line memory management
continuation of dynamic data, 79
indentation, 10, 19 Unchecked_Deallocation, 103
length, 19 mode
multiple, 18, 19 alignment, 15, 19
statements per, 18, 19 explicit, 69, 108
literal model
avoid in generic, 174, 198 task, 115, 137
model interval
affects equality, 98 control structure, 86, 110
affects relational expression, 86, 110
expression, 86, 152 indentation, 10, 19
modular types, 82, 231, 234 initialization exception,
modularity, 52 106
multiple inheritance, 218 loop, 65, 67, 108
multiple return statement, 93 package, 57
multiprocessor, 55, 63, 117 record, 77
new
N as an allocator, 79
name, 24 nonterminating
abbreviation, 23, 44, 171, tasks, 133, 138
198 normal termination, 133
block, 66 noun
Boolean, 84, 110 as function name, 28, 45
capitalization, 22 as identifier, 25, 45
convention, 23, 28 for record component, 25, 45
end statement, 67 to describe abstraction, 28,
flag, 84, 110 45
formal parameter, 68, 108 numeric
fully qualified, 23, 96, 111 conversion, 22
loop, 65, 67, 108 encoding, 43, 46
nested record, 77, 109 expression, 149, 165
number, 30, 45 in relational expression,
object, 25 85, 110
overloading literal, 21, 44, 83, 110
in generic, 175, 198 named, 30
parameter in predefined I/O, type, 149, 165
162
predefined, 42, 46 O
program, 28 object
qualified, 57 identifier, 25, 45
repeated in begin, 41, 46 initialization, 105, 112
repeated in header, 34, 36, name, 25
45, 46 operating system
reusability, 170 dependence, 161, 167
simple, 21, 44 operator
state, 84, 110 alignment, 13, 14, 19
subtype, 42, 46 bit-wise, 82
type, 24, 42, 46 equality, 98
use positive form, 84, 110 logical, 85
named association, 68, 69 overload, 98
in aggregate, 94 performance, 228, 238
named number, 30, 172 precedence, 10, 84, 87
negative logic renamed, 96, 111
in name, 84, 110 short circuit, 85
nesting, 86 spacing, 9
affects abbreviation, 23 optimizing compiler
block, 66, 108
values not checked, 106 child, 52, 53, 63, 192, 199,
optional parameter, 68, 108 213, 217, 223
order cohesion, 54, 63
of arguments in aggregate, comment, 34
94, 111 coupling, 54
of elaboration, 194 dependency, 56
of evaluation, 51, 85, 149 Direct_IO, 106
in expression, 84, 110 document nonportable, 144,
others clause 164
in case statement, 88, 110 end statement, 67, 108
in exception, 60, 64, 100 generic, 57, 179, 192, 199
in task body, 136, 139 implementation-defined
out exception, 157, 166
alignment, 15 interface, 146, 164
overload minimize interface, 55
equality, 98 name, 28, 45
in generic, 175 named in use clause, 95, 111
operator, 98 nested, 57, 214
subprogram, 97 predefined
type name, 42, 46 type name, 24, 44
use clause, 95, 111 vendor supplied feature,
146, 165
P private, 72, 114, 137
package, 51 private child, 52, 53, 56,
abstract data type, 183 57, 63
Ada.Asynchronous_Task_Contro public child, 52, 63
l, 236 Sequential_IO, 106
Ada.Streams.Stream_IO, 163 specification, 55, 57, 63
Ada.Strings_Bounded, 57 exception declaration, 60,
Ada.Synchronous_Task_Control 64
, 236 file name, 47
Ada.Unchecked Deallocation, indentation, 12
161 pagination, 17, 19
portability, 161 portability, 146, 164
body, 114, 137 Standard, 42, 46
comment, 36 predefined numeric type,
file name, 47 149, 165
for different environment, System
146, 165 portability, 158
hide Unchecked_Conversion, portability of Tick, 156
102, 112 vendor supplied, 146, 165
hide pagination, 17, 41, 46
Unchecked_Deallocation, paragraphing, 10
103, 104, 112 parameter
indentation, 12 adding to list, 69, 108
multiple implementation, 48 aggregate, 94, 111
using pragma Interface, alignment, 15
159, 166 anonymous, 72
Calendar array, 173, 198
portability, 156 declaration
per line, 18
default value, 69
for main program, 144, 164 assumptions, 143
formal name, 68, 108 target platforms, 143
generic formal, 171 comment in header, 36
generic reduces coupling, execution pattern, 155
192 of relational expression, 86
in predefined I/O, 162 order dependency, 149
list, 68, 108 principles, 141
mode, 69, 108 positional association, 69,
alignment, 15, 19 94, 111
name in header, 34 positive logic
named association, 68, 108 naming, 84
number, 55, 63 pragma
optional, 68, 108 Atomic, 127, 138
passing mechanism, 147, 177 configuration, 49, 62
with exception, 177 Discard_Names, 237, 238
profile, 97, 111 Elaborate, 106
size, 173, 198 Elaborate_All, 194
unmodified with exception, Elaborate_Body, 193, 199
176, 198 implementation-specific, 160
parameter type Inline, 236, 238
alignment, 15 Interface
parenthesis, 84 portability, 158
alignment, 15, 19 to foreign code, 159, 166
spacing, 10 introduce coupling, 193
superfluous, 10 Preelaborate, 194, 237, 238
parser Priority, 120
use table-driven program, portability, 156, 166
195 Pure, 194, 237, 238
part family, 194 Restrictions, 237, 238
passive iterator, 186, 199 Reviewable, 237, 239
performance Shared
access to data, 55 portability, 157
aspects, 225 Suppress, 49, 105, 237, 239
comment in header, 34, 46 Volatile, 127, 128, 138
measuring, 225 precedence of operator, 84, 87
named number, 30 precision
period fixed point, 143, 164
spacing, 10 floating point, 143, 151,
persistent object, 56 164, 165
plain loop, 89, 110 predefined
pointer. See access. See exception
access do not raise, 60, 64
to task, 120 handle, 101, 111
polymorphism, 77, 197, 201, portability, 157
206, 216, 223 I/O parameter, 162, 167
portability, 19, 52, 141 predefined type, 42, 46
and obsolescent features, as a name, 24, 44
142 numeric, 149
predicate
as function name, 28, 45 structure, 226
for boolean object, 25, 45 termination, 101, 134
preemptive scheduling, 156 unit, 192
prioritized activity, 55, 63 visibility, 57, 64
priority, 120 Program_Error, 125, 138
can create busy wait, 131 erroneous execution, 102
ceiling priority, 115, 120, project
122, 138 abbreviation, 23
mutual exclusion, 122 entry name, 29
portability, 156, 166 prologues
priority ceiling blocking, as pagination, 17
122 propagation, 101
priority ceiling emulation, exception, 101, 176, 198
122 protected objects, 107
priority inversion, 122 and interrupt handlers, 114,
protected objects, 120, 138 115, 137
sequence of execution, 122 and tagged types, 123, 138
tasks, 120, 122, 138 communication, 124, 125, 138
priority inversion, 122 entries, 126, 138
private type, 72, 179, 199 'Count, 126, 138
equality, 98, 111 execution overhead, 131
for numeric type, 150, 165 mutual exclusion, 114, 137
versus limited, 179 performance, 233, 238
problem domain reusability, 123
model with task, 115, 137 synchronization, 114, 125,
procedure 129, 131, 137
as main program, 144, 164 versus rendezvous, 129, 131,
call 138
named association, 68, 108
recursive, 91, 110 Q
default parameter, 69, 108 qualified name, 57, 96, 111
end statement, 67, 108 queue
generic, 179, 192, 199 entry not prioritized, 122
Inline, 236, 238
name, 28, 45 R
overload, 97, 111 race condition, 60, 133
parameter list, 68, 108 attribute, 127
parameter mode, 69, 108 in tentative rendezvous, 131
return, 92 priority, 122
to reduce nesting, 87 with shared variable, 129
processor race conditons
multiple, 117 avoiding, 137, 139
virtual, 117 radix, 21, 44
program raise statement
body in abstraction, 60
indentation, 12 range
grouping, 51, 63
name, 28
pagination, 17, 19
constraint, 70, 108 instead of enumeration, 43,
declaration, 149, 165 46
Duration, 143, 164 portability, 154, 158, 166
in case statement, 88, 110 reserved word
scalar types, 42, 46 capitalization, 22, 44
subexpression, 151 return statement, 92
values, 83 reusability
real operand library, 97
in relational expression, of nonterminating program,
85, 110 134
recompilation renames clause, 96, 111
reduced by separate file, 48 robust software, 172, 198
record Root_Integer
assignment, 94, 111 portability, 143
component run time system
name, 25, 45 dependence, 161, 167
heterogeneous data, 75 runaway task, 135
indentation, 12
map to device data, 75, 109 S
nesting, 77 safe programming, 92
performance, 227, 228, 238 scheduling
variant, 76, 77 algorithm
with access type component, affected by hidden task,
78, 109 176
recursion portability, 156
bound, 91 delay, 123
relational expression, 84, 85, task, 134
110 using priority, 121
portability, 152 scientific notation, 21, 44
relational expressions scope
portability, 152 access type
renames clause, 23, 96 portability, 160
declare in block, 93, 110 exception, 60, 64
for a type, 43 minimize, 57, 64
rendezvous use clause, 96
efficient, 124, 138 select
exception during, 125, 138 minimize, 131, 138
tentative, 129 select statement
versus shared variable, 157, asynchronous, 134, 139
166 blocking, 123
with exception handler, 132, portability, 156
138 terminate alternative, 133,
repeat until 138
how to simulate, 90 to provide normal
representation clause termination, 133, 138
evaluate during porting, 158 selected component
for device data, 76
indentation, 12
of a private type, 73 reusable part family, 194,
selective accept 199
closed alternatives, 125, task hiding, 59, 176, 198
138 spelling, 21
efficient, 124, 138 abbreviation, 23
with else, 129, 138 in comments, 32, 45
selectiveaccept Standard, 42, 46
indentation, 11 predefined numeric type,
semicolon 149, 165
spacing, 10 starvation, 60
sentinel value, 71 state
separate and exception, 60, 64
compilation, 47 naming, 84, 110
indentation, 12 statement, 86, 110
to reduce visibility, 59 abort, 134, 156
separation of concerns, 55 accept, 125, 131, 138
Sequential_IO, 106, 163 block, 93
import private type, 181 case, 88
Shared comment, 40
portability, 157 delay, 122, 138, 155
shared data, 55, 129 end, 67
hidden task in generic, 176 exit, 67, 89, 90, 110
shared variable, 127 goto, 92
portability, 157 indentation, 10
unprotected, 127, 138 loop, 87, 110
short circuit operator, 85 conditional exit, 86
side effect, 50, 62, 85 marker comment, 41
simplification heuristics, 86, per line, 18, 19
110 return, 92
slice, 87 select, 125, 131, 138
source text, 9, 143, 164 portability, 156
spacing, 9, 19 tentative rendezvous, 129
for goto statement, 92 static
for label, 92 data, 78, 109
horizontal, 9 expression, 30, 45, 172, 198
Specialized Needs annexes storage control
implementation, 147 and portability, 154
specification storage pool mechanisms, 154
comment, 34, 45 Storage_Error, 78, 109
end statement, 67, 108 Stream_IO, 163
generic, 174, 198 string
header handling, 196, 199
as pagination, 17 strings
indentation, 12 performance, 235, 238
package, 55, 57, 63 strong typing, 42, 47, 70, 108
to enforce assumption, 173,
198
to reduce constraint check, portability of Tick, 156
235, 238
subprogram, 50 T
call tab character, 10, 19
named association, 68, 108 table-driven programming, 195
overhead, 50 tagged type, 216
recursive, 91, 110 derived, 218
default parameter, 69, 108 hierarchies, 197, 199, 202
document nonportable, 144, operations, 209
164 visibility, 218
end statement, 67, 108 tagged typed, 214
exceptions raised in, 60, 64 tagged types, 191, 199, 206
generic, 179, 192, 199 and dispatching, 203, 222
grouped in package, 54, 63 and maintainability, 203
grouping, 47 and protected objects, 123,
hiding task entries, 59 138
Inline, 236, 238 derived, 217, 223
main, 144 naming, 26
name, 28 redispatching, 38, 40, 46
overload, 97 task, 55, 117, 137
overloading in generic, 175, activation order, 155
198 allocate, 119, 138
parameter list, 55, 63, 68, anonymous type, 119
108 asynchronous control, 115,
procedure versus function, 137
50, 62 attribute, 126, 138
return, 92 avoid termination, 132
to reduce nesting, 87 body
subrecord, 77, 109 exception handler, 136, 139
subtype, 42, 46, 70 indentation, 12
in case statement, 89 communication, 59, 124, 125
in generic, 174, 198 complexity, 131, 138
used as range, 83, 110 portability, 157, 166
using suffixes, 24, 44 deadlock, 137
subunit declaration, 119
embedded document nonportable, 144,
pagination, 17 164
file name, 47 dynamic, 119, 120
indentation, 12 end statement, 67, 108
Suppress, 105 entries, 126, 138
symbolic 'Count, 126, 138
value, 30, 45 hidden, 59, 176
synchronization, 55, 63, 114, comment in header, 34
137 model, 115, 137
portability, 156, 166 name, 28, 45
using shared variable, 127, nonterminating, 133, 138
138 portability, 155, 156, 166
System receiving interrupt, 146,
portability, 158 165
rendezvous, 115, 118, 124,
12 comment, 38, 46
reusability, 176 conversion, 71
runaway, 135 declaration, 42
scheduling, 122, 123, 134 derived, 42, 46, 70
portability, 156 Duration, 143, 164
specification portability, 156
indentation, 12 enumeration, 43
pagination, 17, 19 grouped in package, 54, 63
synchronization, 117, 127, identifier, 24
129, 138 Integer, 143, 164
point, 156, 166 limited private, 72, 179
portability, 157, 166 modular, 82, 110, 234, 238
termination, 132, 133, 134, name, 24, 42, 46
136, 139 numeric, 149, 165
type, 119 of constant, 30
Tasking_Error, 125, 126, 138 predefined, 42, 46, 149
temporary file private, 72, 179
portability, 163 renaming, 43
tentative rendezvous, 129 strong, 42, 47, 70, 108,
terminate alternative 235, 238
to avoid deadlock, 133, 139 subtype, 70
termination suffix, 24, 44
abnormal, 136 tagged, 202
controlled, 101 unconstrained array, 173,
file status, 163 198
normal, 133 universal, 30
of loop, 90, 110 used as range, 83, 110
of task, 132
undesired, 132, 138 U
thread of control, 117 Unchecked_Conversion, 102
Tick portability, 161
portability, 156 Unchecked_Deallocation, 103
time sliced portability, 160
scheduling, 156 underscore, 21, 44
timed entry, 129, 138 in file name, 47
affects 'Count, 127 in numbers, 21, 44
call, 60 significant in name, 23
indentation, 11 universal_integer, 30
tool, 9, 33, 96 universal_real, 30
type, 70, 108 until loop
access, 78, 109 how to simulate, 90
portability, 160 upper case, 22
anonymous, 72 use clause, 95, 96, 111. See
anonymous task, 119 context clause
attribute use type clause, 97, 111
for real value, 152, 165 user-defined exception, 101,
boundary value, 70, 108 111
choice affects equality, 98 replaces implementation-
defined, 166
V
variable
declaration
alignment, 14
localize declaration, 94
of access type, 78, 109
referenced in guard, 127,
138
replaced with aggregate, 94,
111
to reduce nesting, 87
valid state, 176, 198
verb
as entry name, 28, 45
as procedure name, 28, 45
vertical alignment, 13, 14,
15, 19. See alignment
virtual processor, 117
visibility, 53, 55, 56, 57,
63, 95, 111, 217, 223
use type clause, 97, 111
using renames clause, 96,
111
W
while loop. See loop
indentation, 11
with clause. See context
clause