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