[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this chapter may be used to enforce various feature usages consistent with good software engineering, for example as described in Ada 95 Quality and Style.
1.1 Tasking | ||
1.2 Object Orientation | ||
1.3 Portability | ||
1.4 Program Structure | ||
1.5 Programming Practice | ||
1.6 Readability | ||
1.7 Source Code Presentation |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this section may be used to enforce various feature usages related to concurrency.
1.1.1 Multiple_Entries_In_Protected_Definitions | ||
1.1.2 Volatile_Objects_Without_Address_Clauses |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Multiple_Entries_In_Protected_Definitions
Flag each protected definition (i.e., each protected object/type declaration) that defines more than one entry. Diagnostic messages are generated for all the entry declarations except the first one. An entry family is counted as one entry. Entries from the private part of the protected definition are also checked.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Volatile_Objects_Without_Address_Clauses
Flag each volatile object that does not have an address clause.
The following check is made: if the pragma Volatile
is applied to a
data object or to its type, then an address clause must
be supplied for this object.
This rule does not check the components of data objects,
array components that are volatile as a result of the pragma
Volatile_Components
, or objects that are volatile because
they are atomic as a result of pragmas Atomic
or
Atomic_Components
.
Only variable declarations, and not constant declarations, are checked.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this section may be used to enforce various feature usages related to Object-Oriented Programming.
1.2.1 Deep_Inheritance_Hierarchies | ||
1.2.2 Direct_Calls_To_Primitives | ||
1.2.3 Too_Many_Parents | ||
1.2.4 Visible_Components |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Deep_Inheritance_Hierarchies
Flags a tagged derived type declaration or an interface type declaration if its depth (in its inheritance hierarchy) exceeds the value specified by the ‘N’ rule parameter.
The inheritance depth of a tagged type or interface type is defined as 0 for a type with no parent and no progenitor, and otherwise as 1 + max of the depths of the immediate parent and immediate progenitors.
This rule does not flag private extension declarations. In the case of a private extension, the corresponding full declaration is checked.
This rule has the following (mandatory) parameter for the ‘+R’ option:
Integer not less than -1 specifying the maximal allowed depth of any inheritance hierarchy. If the rule parameter is set to -1, the rule flags all the declarations of tagged and interface types.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Direct_Calls_To_Primitives
Flags any non-dispatching call to a dispatching primitive operation, except for two cases:
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Too_Many_Parents
Flags any type declaration, single task declaration or single protected declaration that has more then ‘N’ parents, ‘N’ is a parameter of the rule. A parent here is either a (sub)type denoted by the subtype mark from the parent_subtype_indication (in case of a derived type declaration), or any of the progenitors from the interface list, if any.
This rule has the following (mandatory) parameters for the ‘+R’ option:
Positive integer specifying the maximal allowed number of parents.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Visible_Components
Flags all the type declarations located in the visible part of a library package or a library generic package that can declare a visible component. A type is considered as declaring a visible component if it contains a record definition by its own or as a part of a record extension. Type declaration is flagged even if it contains a record definition that defines no components.
Declarations located in private parts of local (generic) packages are not flagged. Declarations in private packages are not flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this section may be used to enforce various feature usages that support program portability.
1.3.1 Forbidden_Attributes | ||
1.3.2 Forbidden_Pragmas | ||
1.3.3 Implicit_SMALL_For_Fixed_Point_Types | ||
1.3.4 Predefined_Numeric_Types | ||
1.3.5 Separate_Numeric_Error_Handlers |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Forbidden_Attributes
Flag each use of the specified attributes. The attributes to be detected are named in the rule’s parameters.
This rule has the following parameters:
Adds the specified attribute to the set of attributes to be detected and sets the detection checks for all the specified attributes ON. If Attribute_Designator does not denote any attribute defined in the Ada standard or in (gnat_rm)Implementation Defined Attributes section ‘Implementation Defined Attributes’ in GNAT Reference Manual, it is treated as the name of unknown attribute.
GNAT
All the GNAT-specific attributes are detected; this sets the detection checks for all the specified attributes ON.
ALL
All attributes are detected; this sets the rule ON.
Removes the specified attribute from the set of attributes to be detected without affecting detection checks for other attributes. If Attribute_Designator does not correspond to any attribute defined in the Ada standard or in (gnat_rm)Implementation Defined Attributes section ‘Implementation Defined Attributes’ in GNAT Reference Manual, this option is treated as turning OFF detection of all unknown attributes.
Turn OFF detection of all GNAT-specific attributes
Clear the list of the attributes to be detected and turn the rule OFF.
Parameters are not case sensitive. If Attribute_Designator does not have the syntax of an Ada identifier and therefore can not be considered as a (part of an) attribute designator, a diagnostic message is generated and the corresponding parameter is ignored. (If an attribute allows a static expression to be a part of the attribute designator, this expression is ignored by this rule.)
When more then one parameter is given in the same rule option, the parameters must be separated by commas.
If more then one option for this rule is specified for the gnatcheck call, a new option overrides the previous one(s).
The ‘+R’ option with no parameters turns the rule ON, with the set of attributes to be detected defined by the previous rule options. (By default this set is empty, so if the only option specified for the rule is ‘+RForbidden_Attributes’ (with no parameter), then the rule is enabled, but it does not detect anything). The ‘-R’ option with no parameter turns the rule OFF, but it does not affect the set of attributes to be detected.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Forbidden_Pragmas
Flag each use of the specified pragmas. The pragmas to be detected are named in the rule’s parameters.
This rule has the following parameters:
Adds the specified pragma to the set of pragmas to be checked and sets the checks for all the specified pragmas ON. Pragma_Name is treated as a name of a pragma. If it does not correspond to any pragma name defined in the Ada standard or to the name of a GNAT-specific pragma defined in (gnat_rm)Implementation Defined Pragmas section ‘Implementation Defined Pragmas’ in GNAT Reference Manual, it is treated as the name of unknown pragma.
GNAT
All the GNAT-specific pragmas are detected; this sets the checks for all the specified pragmas ON.
ALL
All pragmas are detected; this sets the rule ON.
Removes the specified pragma from the set of pragmas to be checked without affecting checks for other pragmas. Pragma_Name is treated as a name of a pragma. If it does not correspond to any pragma defined in the Ada standard or to any name defined in (gnat_rm)Implementation Defined Pragmas section ‘Implementation Defined Pragmas’ in GNAT Reference Manual, this option is treated as turning OFF detection of all unknown pragmas.
Turn OFF detection of all GNAT-specific pragmas
Clear the list of the pragmas to be detected and turn the rule OFF.
Parameters are not case sensitive. If Pragma_Name does not have the syntax of an Ada identifier and therefore can not be considered as a pragma name, a diagnostic message is generated and the corresponding parameter is ignored.
When more then one parameter is given in the same rule option, the parameters must be separated by a comma.
If more then one option for this rule is specified for the gnatcheck
call, a new option overrides the previous one(s).
The ‘+R’ option with no parameters turns the rule ON with the set of pragmas to be detected defined by the previous rule options. (By default this set is empty, so if the only option specified for the rule is ‘+RForbidden_Pragmas’ (with no parameter), then the rule is enabled, but it does not detect anything). The ‘-R’ option with no parameter turns the rule OFF, but it does not affect the set of pragmas to be detected.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Implicit_SMALL_For_Fixed_Point_Types
Flag each fixed point type declaration that lacks an explicit
representation clause to define its 'Small
value.
Since 'Small
can be defined only for ordinary fixed point types,
decimal fixed point type declarations are not checked.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Predefined_Numeric_Types
Flag each explicit use of the name of any numeric type or subtype defined
in package Standard
.
The rationale for this rule is to detect when the
program may depend on platform-specific characteristics of the implementation
of the predefined numeric types. Note that this rule is over-pessimistic;
for example, a program that uses String
indexing
likely needs a variable of type Integer
.
Another example is the flagging of predefined numeric types with explicit
constraints:
subtype My_Integer is Integer range Left .. Right; Vy_Var : My_Integer; |
This rule detects only numeric types and subtypes defined in
Standard
. The use of numeric types and subtypes defined in other
predefined packages (such as System.Any_Priority
or
Ada.Text_IO.Count
) is not flagged
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Separate_Numeric_Error_Handlers
Flags each exception handler that contains a choice for
the predefined Constraint_Error
exception, but does not contain
the choice for the predefined Numeric_Error
exception, or
that contains the choice for Numeric_Error
, but does not contain the
choice for Constraint_Error
.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this section may be used to enforce feature usages related to program structure.
1.4.1 Deeply_Nested_Generics | ||
1.4.2 Local_Packages | ||
1.4.3 Non_Visible_Exceptions | ||
1.4.4 Raising_External_Exceptions |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Deeply_Nested_Generics
Flags a generic declaration nested in another generic declaration if the nesting level of the inner generic exceeds a value specified by the ‘N’ rule parameter. The nesting level is the number of generic declarations that enclose the given (generic) declaration. Formal packages are not flagged by this rule.
This rule has the following (mandatory) parameters for the ‘+R’ option:
Positive integer specifying the maximal allowed nesting level for a generic declaration.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Local_Packages
Flag all local packages declared in package and generic package specs. Local packages in bodies are not flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Non_Visible_Exceptions
Flag constructs leading to the possibility of propagating an exception out of the scope in which the exception is declared. Two cases are detected:
others
choice.
raise
statement in an exception handler of a subprogram body,
task body or block statement is flagged if it (re)raises a locally
declared exception. This may occur under the following circumstances:
raise;
)
and the enclosing handler contains a locally declared exception in its
exception choices.
Renamings of local exceptions are not flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Raising_External_Exceptions
Flag any raise
statement, in a program unit declared in a library
package or in a generic library package, for an exception that is
neither a predefined exception nor an exception that is also declared (or
renamed) in the visible part of the package.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules in this section may be used to enforce feature usages that relate to program maintainability.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Anonymous_Arrays
Flag all anonymous array type definitions (by Ada semantics these can only occur in object declarations).
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Enumeration_Ranges_In_CASE_Statements
Flag each use of a range of enumeration literals as a choice in a
case
statement.
All forms for specifying a range (explicit ranges
such as A .. B
, subtype marks and 'Range
attributes) are flagged.
An enumeration range is
flagged even if contains exactly one enumeration value or no values at all. A
type derived from an enumeration type is considered as an enumeration type.
This rule helps prevent maintenance problems arising from adding an
enumeration value to a type and having it implicitly handled by an existing
case
statement with an enumeration range that includes the new literal.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Exceptions_As_Control_Flow
Flag each place where an exception is explicitly raised and handled in the
same subprogram body. A raise
statement in an exception handler,
package body, task body or entry body is not flagged.
The rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Exits_From_Conditional_Loops
Flag any exit statement if it transfers the control out of a for
loop
or a while
loop. This includes cases when the exit
statement
applies to a FOR
or while
loop, and cases when it is enclosed
in some for
or while
loop, but transfers the control from some
outer (unconditional) loop
statement.
The rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
EXIT_Statements_With_No_Loop_Name
Flag each exit
statement that does not specify the name of the loop
being exited.
The rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GOTO_Statements
Flag each occurrence of a goto
statement.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Improper_Returns
Flag each explicit return
statement in procedures, and
multiple return
statements in functions.
Diagnostic messages are generated for all return
statements
in a procedure (thus each procedure must be written so that it
returns implicitly at the end of its statement part),
and for all return
statements in a function after the first one.
This rule supports the stylistic convention that each subprogram
should have no more than one point of normal return.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Non_Short_Circuit_Operators
Flag all calls to predefined and
and or
operators for
any boolean type. Calls to
user-defined and
and or
and to operators defined by renaming
declarations are not flagged. Calls to predefined and
and or
operators for modular types or boolean array types are not flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
OTHERS_In_Aggregates
Flag each use of an others
choice in extension aggregates.
In record and array aggregates, an others
choice is flagged unless
it is used to refer to all components, or to all but one component.
If, in case of a named array aggregate, there are two associations, one
with an others
choice and another with a discrete range, the
others
choice is flagged even if the discrete range specifies
exactly one component; for example, (1..1 => 0, others => 1)
.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
OTHERS_In_CASE_Statements
Flag any use of an others
choice in a case
statement.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
OTHERS_In_Exception_Handlers
Flag any use of an others
choice in an exception handler.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Overly_Nested_Control_Structures
Flag each control structure whose nesting level exceeds the value provided in the rule parameter.
The control structures checked are the following:
if
statement
case
statement
loop
statement
The rule has the following parameter for the ‘+R’ option:
Positive integer specifying the maximal control structure nesting level that is not flagged
If the parameter for the ‘+R’ option is not specified or if it is not a positive integer, ‘+R’ option is ignored.
If more then one option is specified for the gnatcheck call, the later option and new parameter override the previous one(s).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Positional_Actuals_For_Defaulted_Generic_Parameters
Flag each generic actual parameter corresponding to a generic formal parameter with a default initialization, if positional notation is used.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Positional_Actuals_For_Defaulted_Parameters
Flag each actual parameter to a subprogram or entry call where the corresponding formal parameter has a default expression, if positional notation is used.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Positional_Components
Flag each array, record and extension aggregate that includes positional notation.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Positional_Generic_Parameters
Flag each positional actual generic parameter except for the case when the generic unit being instantiated has exactly one generic formal parameter.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Positional_Parameters
Flag each positional parameter notation in a subprogram or entry call, except for the following:
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Recursive_Subprograms
Flags specs (and bodies that act as specs) of recursive subprograms. A subprogram is considered as recursive in a given context if there exists a chain of direct calls starting from the body of, and ending at this subprogram within this context. A context is provided by the set of Ada sources specified as arguments of a given gnatcheck call. Neither dispatching calls nor calls through access-to-subprograms are considered as direct calls by this rule.
Generic subprograms and subprograms detected in generic units are not flagged. Recursive subprograms in expanded generic instantiations are flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Unconditional_Exits
Flag unconditional exit
statements.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Unnamed_Blocks_And_Loops
Flag each unnamed block statement and loop statement.
The rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
USE_PACKAGE_Clauses
Flag all use
clauses for packages; use type
clauses are
not flagged.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The rules described in this section may be used to enforce feature usages that contribute towards readability.
1.6.1 Misnamed_Controlling_Parameters | ||
1.6.2 Misnamed_Identifiers | ||
1.6.3 Name_Clashes | ||
1.6.4 Uncommented_BEGIN_In_Package_Bodies |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Misnamed_Controlling_Parameters
Flags a declaration of a dispatching operation, if the first parameter is
not a controlling one and its name is not This
(the check for
parameter name is not case-sensitive). Declarations of dispatching functions
with controlling result and no controlling parameter are never flagged.
A subprogram body declaration, subprogram renaming declaration or subprogram body stub is flagged only if it is not a completion of a prior subprogram declaration.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Misnamed_Identifiers
Flag the declaration of each identifier that does not have a suffix corresponding to the kind of entity being declared. The following declarations are checked:
This rule may have parameters. When used without parameters, the rule enforces the following checks:
_T
, unless the type is an access type,
in which case the suffix must be _A
_C
_R
Defining identifiers from incomplete type declarations are never flagged.
For a private type declaration (including private extensions), the defining identifier from the private type declaration is checked against the type suffix (even if the corresponding full declaration is an access type declaration), and the defining identifier from the corresponding full type declaration is not checked.
For a deferred constant, the defining name in the corresponding full constant declaration is not checked.
Defining names of formal types are not checked.
The rule may have the following parameters:
Default
Sets the default listed above for all the names to be checked.
Type_Suffix=string
Specifies the suffix for a type name.
Access_Suffix=string
Specifies the suffix for an access type name. If
this parameter is set, it overrides for access
types the suffix set by the Type_Suffix
parameter.
For access types, string may have the following format:
suffix1(suffix2). That means that an access type name
should have the suffix1 suffix except for the case when
the designated type is also an access type, in this case the
type name should have the suffix1 & suffix2 suffix.
Class_Access_Suffix=string
Specifies the suffix for the name of an access type that points to some
class-wide type.
If this parameter is set, it overrides for such access
types the suffix set by the Type_Suffix
or Access_Suffix
parameter.
Class_Subtype_Suffix=string
Specifies the suffix for the name of a subtype that denotes a class-wide type.
Constant_Suffix=string
Specifies the suffix for a constant name.
Renaming_Suffix=string
Specifies the suffix for a package renaming name.
All_Suffixes
Remove all the suffixes specified for the identifier suffix checks, whether by default or as specified by other rule parameters. All the checks for this rule are disabled as a result.
Type_Suffix
Removes the suffix specified for types. This
disables checks for types but does not disable
any other checks for this rule (including the
check for access type names if Access_Suffix
is
set).
Access_Suffix
Removes the suffix specified for access types.
This disables checks for access type names but
does not disable any other checks for this rule.
If Type_Suffix
is set, access type names are
checked as ordinary type names.
Class_Access_Suffix
Removes the suffix specified for access types pointing to class-wide
type. This disables specific checks for names of access types pointing to
class-wide types but does not disable any other checks for this rule.
If Type_Suffix
is set, access type names are
checked as ordinary type names. If Access_Suffix
is set, these
access types are checked as any other access type name.
Class_Subtype_Suffix=string
Removes the suffix specified for subtype names. This disables checks for subtype names but does not disable any other checks for this rule.
Constant_Suffix
Removes the suffix specified for constants. This disables checks for constant names but does not disable any other checks for this rule.
Renaming_Suffix
Removes the suffix specified for package renamings. This disables checks for package renamings but does not disable any other checks for this rule.
If more than one parameter is used, parameters must be separated by commas.
If more than one option is specified for the gnatcheck
invocation,
a new option overrides the previous one(s).
The ‘+RMisnamed_Identifiers’ option (with no parameter) enables checks for all the name suffixes specified by previous options used for this rule.
The ‘-RMisnamed_Identifiers’ option (with no parameter) disables all the checks but keeps all the suffixes specified by previous options used for this rule.
The string value must be a valid suffix for an Ada identifier (after trimming all the leading and trailing space characters, if any). Parameters are not case sensitive, except the string part.
If any error is detected in a rule parameter, the parameter is ignored. In such a case the options that are set for the rule are not specified.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Name_Clashes
Check that certain names are not used as defining identifiers. To activate this rule, you need to supply a reference to the dictionary file(s) as a rule parameter(s) (more then one dictionary file can be specified). If no dictionary file is set, this rule will not cause anything to be flagged. Only defining occurrences, not references, are checked. The check is not case-sensitive.
This rule is enabled by default, but without setting any corresponding dictionary file(s); thus the default effect is to do no checks.
A dictionary file is a plain text file. The maximum line length for this file is 1024 characters. If the line is longer then this limit, extra characters are ignored.
Each line can be either an empty line, a comment line, or a line containing
a list of identifiers separated by space or HT characters.
A comment is an Ada-style comment (from --
to end-of-line).
Identifiers must follow the Ada syntax for identifiers.
A line containing one or more identifiers may end with a comment.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Uncommented_BEGIN_In_Package_Bodies
Flags each package body with declarations and a statement part that does not
include a trailing comment on the line containing the begin
keyword;
this trailing comment needs to specify the package name and nothing else.
The begin
is not flagged if the package body does not
contain any declarations.
If the begin
keyword is placed on the
same line as the last declaration or the first statement, it is flagged
independently of whether the line contains a trailing comment. The
diagnostic message is attached to the line containing the first statement.
This rule has no parameters.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section is a placeholder; there are currently no rules in this category.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by root on March 13, 2014 using texi2html 1.82.