Coding Standards

Number of 'andthen' operators

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'case' blocks in 'switch' in the function

Number of 'case' labels in the function

Number of 'catch' statements in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of 'continue' statements in the function

Number of Commented Statements.

Number of 'default' blocks in 'switch' in the function

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'else' statements

Number of calls to the exit function

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of lines containing both code and comment in the source files.

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of 'throw' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of 'try' statements in the function

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

Avoid using COMMIT WORK statements in loops.

Avoid using APPEND in SQL SELECT statements.

Avoid using COMMIT WORK statements in loops.

Avoid using INSERT statements in loops. Querying in a loop can lead to performance issues.

Avoid using SQL INTO statements in loops.

SELECT * should be avoided as it does not enable to keep control on the flow return and could therefore be error prone and potentially lead to performance issues.

The BYPASSING BUFFER clause causes the SELECT statement to avoid the SAP buffering and to read directly from the database and not from the buffer on the application server.

The SQL DISTINCT clause causes the SELECT statement to avoid the SAP buffering and to read directly from the database and not from the buffer on the application server.

Avoid SELECT SQL statement with a WHERE clause containing the NOT EQUAL operator.

SQL COUNT(..) , MIN(..), MAX(..), SUM(..), AVG(..) functions cause the SAP table buffer to be bypassed and so usage of such functions can lead to some performance issues.

Avoid using SUBMIT statements in loops.

Avoid using UPDATE, MODIFY, DELETE statements in loops. Querying in a loop can lead to performance issues.

Using GROUP BY in SQL queries can lead to performance issues.

Using the SQL JOIN clause leads to bypass the SAP table buffer.

Using LIKE in SQL queries can lead to performance issues.

Avoid using the WAIT statement.

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

Call of a System Function: CALL 'cfunc' is only intended for internal usage. Incompatible changes and further development is possible at any time and without warning or notice.

Forbid calls to dialog transactions.

This statement is exclusively for internal use within SAP Technology Development. Incompatible changes or developments are possible at any time without prior warning or notes.

This statement is exclusively for internal use within SAP Technology Development. Incompatible changes or developments are possible at any time without prior warning or notice.

Forbid uses of OFFSET in ASSIGN.

This statement is only for !Internal use in SAP Basis development!. Its use is subject to various restrictions, not all of which may be listed in the documentation. Changes and further development, which may be incompatible, may occur at any time, without warning or notice!

Handling the exceptions when calling a function module is optional but should be mandatory to correctly handle errors in production.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

Native SQL should not be used.

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

This statement bypasses the authority checks that are performed when calling the ABAP editor via transaction code.

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

Number of 'andthen' operators

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'case' blocks in 'switch' in the function

Number of 'case' labels in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of Commented Statements.

Number of Declare operators

Number of 'default' blocks in 'switch' in the function

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'else' statements

Number of Entry statements

Number of 'when' blocks in 'exception handler'.

Number of Exception handlers

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of 'goto' statements

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

The object is declared generic

Number of Label statements

Number of lines.

Number of loop statements in the function

Number of lines containing both code and comment in the source files.

Number of AND operators

Number of Constants

Number of Private constants

Number of Public constants

Number of Declared functions/procedures

Number of Private function/Procedure

Number of Public functions/procedures

Number of Declared Exceptions

Number of Private exceptions

Number of Public exceptions

Number of Separate functions/procedures

Number of OR operators

Number of package declared Separate

Number of Declred Protected objects

Number of Renamed object

Number of Subtypes

Number of task declared Separate

Number of Types

Number of Derived types

Number of Private types

Number of Public types

Number of Variables

Number of Private variables

Number of Public variables

Number of With statements

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of Raise statementts

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

Backward gotos shall not be used.

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

Each exit label shall be named.

Use 'exit when' instead of if…​ exit syntax.

Each loop shall be named.

Use of 'abort'

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

Use of 'delay'

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

The 'goto' statement shall not be used (see [MISRA-C:2004]: RULE 14.4).

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

There shall be no 'when others' in exception handler.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

There shall be a single exit by loop.

Number of 'andthen' operators

Number of assignment operators used in the source file

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'break' statements in loop in the function

Number of 'break' statements in 'switch' in the function

Number of 'case' blocks in 'switch' in the function

Number of calls to the function (including direct recursive calls).

Number of calls to distinct functions defined in the project source files (including recursive call).

Number of call statements in the function.

Number of distinct functions calling the function (including recursice call).

Number of distinct call to external functions (not present in project’s source files).

Number of 'case' labels in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of direct recursive call in the function.

Number of calls to external functions (not present in project’s source files).

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of call graph cycles in which the function is involved (excluding direct recursive calls).

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of 'continue' statements in the function

Number of comparison operators used in the source file

Number of Commented Statements.

Number of call graph cycles in which the function is involved (including recursivity).

Number of 'default' blocks in 'switch' in the function

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'do…​while' statements in the function

Number of 'else' statements

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of 'goto' statements

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of lines containing both code and comment in the source files.

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of 'return' statements in the function

Duplicated blocks in the function

Use of signal Functions

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

Number of special operators used in the source file

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Use IO Functions

Use of String Conversions

Number of 'switch' statements in the function

Use of system Functions

Number of ternary operators i.e. ?:

Use of Time Handling

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

An unconditional break statement shall terminate every non-empty switch clause (see [MISRA-C:2004]: RULE 15.2).

Backward gotos shall not be used.

The statement forming the body of a switch, while, do …​ while or for statement shall be a compound statement (see [MISRA-C:2004]: RULE 14.8).

An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement (see [MISRA-C:2004]: RULE 14.9).

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

Dynamic heap memory allocation shall not used. This precludes the use of the functions calloc, malloc, realloc and free (see [MISRA-C:2004]: RULE 20.4)

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

(The setjmp macro and the longjmp function shall not be used (see [MISRA-C:2004]: RULE 20.7).

Assignment operators should not be used in condition expressions (if, for, while, do, switch).

Assignment operators shall not be used in condition expressions (if, for, while, do, switch) that does not contain comparison operators.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

There shall be a no code before the first case of a switch statement.

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

There shall be no fallthrough the next case in a switch statement.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

The 'goto' statement shall not be used (see [MISRA-C:2004]: RULE 14.4).

A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement (see [MISRA-C:2004]: RULE 15.1).

Functions shall not called themselves either directly or indirectly (see [MISRA-C:2004]: RULE 16.2).

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

The macro offsetof, in library <stddef.h>, shall not be used (see [MISRA-C:2004]: RULE 20.6).

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

For any iteration statement there shall be at most one 'break' statement used for loop termination (see [MISRA-C:2004]: RULE 14.6).

The signal handling facilities of <signal.h> shall not be used (see [MISRA-C:2004]: RULE 20.8).

The input/output library <stdio.h> shall not be used in production code (see [MISRA-C:2004]: RULE 20.9).

The library functions atof, atoi and atol from library <stdlib.h> shall not be used (see [MISRA-C:2004]: RULE 20.10).

The library functions abort, exit, getenv and system from library <stdlib.h> shall not be used (see [MISRA-C:2004]: RULE 20.11).

The time handling functions of library <time.h> shall not be used: time, strftime, clock, difftime, mktime (see [MISRA-C:2004]: RULE 20.12).

Number of arithmetic operators

Number of blank lines of code in the source file(s).

Number of CALL statements

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of lines of comments in the source file(s).

Number of lines of comments in the source file(s) whose first word is a keyword.

Number of lines of comments in the source file(s) without alphabetic character.

Number of real lines of comments in the source file(s) with alphabetic characters.

Number of cloned artefacts

Number of conditions

Number of Commented Statements.

Number of lines of debug in the source file(s).

Number of DISPLAY statements

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operands in Data Division: variables and constants ([Halstead,76]: n2)

Number of distinct operands in Procedure Division: variables and constants ([Halstead,76]: n2)

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of distinct operators in Data Division: language keywords ([Halstead,76]: n1)

Number of distinct operators in Procedure Division: language keywords ([Halstead,76]: n1)

Number of 'else' statements

Number of EVALUATE statements

Number of calls to the exit function

Number of file declarations

Number of references to files

Number of Comments containing FIXME string.

Number of 'goto' statements

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Is IDMS active in program

Number of IDMS instructions called

Number of IDMS records called

Number of calls for modification

Number of calls for reading/searching

Number of IDMS subschema definition

Number of 'if' statements

Number of lines.

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

Number of paragraphs.

Number of files where a parsing error occured, resulting in a partial interpretation

Number of PERFORM statements

Duplicated blocks in the function

Number of data declarations

Number of used data

Number of sections.

Number of lines of source code in the source file(s).

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of STOP statements

Number of TIMES clauses in PERFORM statements

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operands in Data Division: variables and constants ([Halstead,76]: N2)

Number of occurrences of operands in Procedure Division: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of occurrences of operators in Data Division: language keywords ([Halstead,76]: N1)

Number of occurrences of operators in Procedure Division: language keywords ([Halstead,76]: N1)

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of UNTIL clauses in PERFORM statements

Number of VARYING clauses in PERFORM statements

Number of WHEN and WHENOTHER clauses in EVALUATE Statements

In the FILE-DESCRIPTION section, each file description shall always use the BLOCK CONTAINS 0 RECORDS clause. The system will assign the BLOCK-SIZE automatically when allocating the file.

Only * and D shall be used in column 7.

A comment is recommended before each division.

A comment is recommended before each file description.

A comment is recommended before each first level of IF or PERFORM.

A comment is recommended before each variable 01 and 77.

An empty line shall precede and follow a DIVISION.

An empty line shall follow an EXIT statement.

The nested statements shall be indented.

Scope terminators must be on the same column as the beginning of the block to facilitate program readability.

An empty line shall follow a SECTION.

A variable shall be declared in the WORKING STORAGE using the format ^W

Paragraphs having exact same name in the same PROGRAM-ID is forbidden.

An EVALUATE statement shall be closed by END-EVALUATE

A file shall be closed only once

A file shall be opened and closed in the same program

A file shall be opened only once

FILE STATUS shall be used to manage I/O errors.

Only a single GOBACK shall be used in a subprgram.

IDMS FIND CURRENT is forbidden

Each IDMS modify statement (MODIFY/ERASE/STORE) should be in a specific perform

Avoid duplicated IDMS call.

Each IDMS Ready Update statement should be defined in PROTECTED mode.

After each IDMS statement, return code should be checked.

An IF statement shall be closed by an END-IF

Avoid Cobol programs containing PERFORM - END-PERFORM loops with more than 80 lines.

In the FILE-DESCRIPTION section, each file description shall always use the LABEL RECORD STANDARD clause. Only the standard labels are checked by the system.

An ADD statement shall be closed by an END-ADD.

An CALL statement shall be closed by an END-CALL.

An COMPUTE statement shall be closed by an END-COMPUTE.

An DELETE statement shall be closed by an END-DELETE.

An DIVIDE statement shall be closed by an END-DIVIDE.

An MULTIPLY statement shall be closed by an END-MULTIPLY.

An READ statement shall be closed by an END-READ.

An RETURN statement shall be closed by an END-RETURN.

An REWRITE statement shall be closed by an END-REWRITE.

An SEARCH statement shall be closed by an END-SEARCH.

An START statement shall be closed by an END-START.

An STRING statement shall be closed by an END-STRING.

An SUBTRACT statement shall be closed by an END-SUBTRACT.

An UNSTRING statement shall be closed by an END-UNSTRING.

An WRITE statement shall be closed by an END-WRITE.

Even the 'FILLER' word is optional since Cobol85, it is recommanded to write it.

There shall be no more than 3 nexted IF statements

Nested program is not recommanded

The ALTER statement shall not be used. Labels are decided only at execution time.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

Conditional GO TO shall not be used. Use EVALUATE instead.

MOVE CORRESPONDING shall not be used.

COMPUTE shall be used to add more than 2 data instead of ADD.

COMPUTE shall be used to add more than 2 data instead of SUBTRACT.

DEBUGGING-MODE shall not be used

COMPUTE shall be used instead of DIVIDE.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

INITIALIZE shall not be used. Use MOVE to initialize variable.

COMPUTE shall be used instead of MULTIPLY.

Procedural COPY clauses shall not be used. Use subprograms instead.

The RENAMES clause shall not be used.

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

The variables shall not be declared in S9(9) COMP. It implies a conversion

Avoid Cobol Programs containing sections or paragraphs that are called by PERFORM statements and that contain a GO TO statement to another section or paragraph that is not in the scope of the initial PERFORM.

Avoid Cobol programs using OPEN or CLOSE in loops. Following loops are taken into account: - PERFORM TIMES / UNTIL / VARYING

Avoid Cobol programs accessing part of data by using a position and a length.

For the OCCURS DEPENDING ON clause, the corresponding item shall be declared using COMP or BINARY.

A program should not mix paragraphs and sections.

The call of a paragraph shall be made in the use of PERFORM paragraphName THRU paragraphNameExit.

On a PERFORM range: P1 THRU P2, P1 must be declared before P2.

READ A INTO B or WRITE A FROM B forms shall be used for reading/writing a file.

Avoid Cobol programs using READ statements without the AT END clause.

A rule violation is relaxed and justified.

A COBOL statement shall be written in uppercase to keep the program readable.

SYNCHRONIZED shall be used for COMP, COMP-1, COMP-2, POINTER and INDEX variables.

There shall be no homonymous variables.

EVALUATE shall end by a WHEN OTHER clause.

Number of constant data

Number of attributes

Number of 'andthen' operators

Number of public data

Number of protected data

Number of private data

Number of assignment operators used in the source file

Number of static data

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'break' statements in loop in the function

Number of 'break' statements in 'switch' in the function

Number of 'case' blocks in 'switch' in the function

Number of calls to the function (including direct recursive calls).

Number of calls to distinct functions defined in the project source files (including recursive call).

Number of call statements in the function.

Number of distinct functions calling the function (including recursice call).

Number of distinct call to external functions (not present in project’s source files).

Number of 'case' labels in the function

Number of 'catch' statements in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of direct recursive call in the function.

Number of calls to external functions (not present in project’s source files).

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of call graph cycles in which the function is involved (excluding direct recursive calls).

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of 'continue' statements in the function

Number of comparison operators used in the source file

Number of Commented Statements.

Maximun depth of the inheritance tree from the class

Number of 'default' blocks in 'switch' in the function

DIT is the maximum depth of the class inheritance tree

Measurement method: The depth of inheritance tree counts the maximum length of inheritance from the class to the ultimate base class

Meaning: A large DIT reveals a long inheritance chain below the class and maybe a complex hierarchy, adding methods to that class may impact many inherited subclasses with inappropriate behaviours.

Improving: Carefully test the newly implemented methods in that class, verify if the abstraction tree could not be redesigned.

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'do…​while' statements in the function

Number of 'else' statements

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of 'goto' statements

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of 'constant' methods i.e. which do not modify the object

Number of classes from which the class inherits directly.

Note: For Java Classes and Interfaces, the MII is computed by ignoring the number of implemented classes/interfaces (which is counted by the 'IIMPL' measure).

Number of lines containing both code and comment in the source files.

Number of methods without any accessibility specifier

Number of public methods

Number of protected methods

Number of private methods

Number of static methods

Number of classes from which the class inherits directly or indirectly

Number of classes which inherit from the class directly or indirectly

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOC is the number of classes that inherit directly from the class.

Measurement method: NOC counts the number of classes inheriting from the class we are in.

Meaning: The higher the number of children the higher the possible impact of the class. A modification in the class may impact many sub-classes and thus should be done carefully. A large NOC may reveal misuse of subclassing. However, the greater the NOC the better because it uses the power of reuse introduced by OO languages.

Improving: A high number of NOC should lead to more testing and if the class is already complex (suggested by other metrics) then it may need to be redesigned, intensively tested or carefully reviewed.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

Number of special operators used in the source file

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of ternary operators i.e. ?:

Number of 'throw' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of 'try' statements in the function

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

An unconditional break statement shall terminate every non-empty switch clause (see [MISRA-C:2004]: RULE 15.2).

Backward gotos shall not be used.

The statement forming the body of a switch, while, do …​ while or for statement shall be a compound statement (see [MISRA-C:2004]: RULE 14.8).

An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement (see [MISRA-C:2004]: RULE 14.9).

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

Assignment operators should not be used in condition expressions (if, for, while, do, switch).

Assignment operators shall not be used in condition expressions (if, for, while, do, switch) that does not contain comparison operators.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

There shall be a no code before the first case of a switch statement.

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

There shall be no fallthrough the next case in a switch statement.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

The 'goto' statement shall not be used (see [MISRA-C:2004]: RULE 14.4).

A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement (see [MISRA-C:2004]: RULE 15.1).

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

For any iteration statement there shall be at most one 'break' statement used for loop termination (see [MISRA-C:2004]: RULE 14.6).

Number of constant data

Number of internal data (only applicable to C#)

Number of attributes

Number of 'andthen' operators

Number of public data

Number of protected internal data (only applicable to C#)

Number of protected data

Number of private data

Number of assignment operators used in the source file

Number of static data

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'break' statements in loop in the function

Number of 'break' statements in 'switch' in the function

Number of 'case' blocks in 'switch' in the function

Number of 'case' labels in the function

Number of 'catch' statements in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of 'continue' statements in the function

Number of comparison operators used in the source file

Number of Commented Statements.

Maximun depth of the inheritance tree from the class

Number of 'default' blocks in 'switch' in the function

DIT is the maximum depth of the class inheritance tree

Measurement method: The depth of inheritance tree counts the maximum length of inheritance from the class to the ultimate base class

Meaning: A large DIT reveals a long inheritance chain below the class and maybe a complex hierarchy, adding methods to that class may impact many inherited subclasses with inappropriate behaviours.

Improving: Carefully test the newly implemented methods in that class, verify if the abstraction tree could not be redesigned.

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'do…​while' statements in the function

Number of 'else' statements

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of 'foreach' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of 'goto' statements

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of 'constant' methods i.e. which do not modify the object

Number of classes from which the class inherits directly.

Note: For Java Classes and Interfaces, the MII is computed by ignoring the number of implemented classes/interfaces (which is counted by the 'IIMPL' measure).

Number of internal methods (only applicable to C#)

Number of lines containing both code and comment in the source files.

Number of methods without any accessibility specifier

Number of public methods

Number of protected internal methods(only applicable to C#)

Number of protected methods

Number of private methods

Number of static methods

Number of classes from which the class inherits directly or indirectly

Number of classes which inherit from the class directly or indirectly

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOC is the number of classes that inherit directly from the class.

Measurement method: NOC counts the number of classes inheriting from the class we are in.

Meaning: The higher the number of children the higher the possible impact of the class. A modification in the class may impact many sub-classes and thus should be done carefully. A large NOC may reveal misuse of subclassing. However, the greater the NOC the better because it uses the power of reuse introduced by OO languages.

Improving: A high number of NOC should lead to more testing and if the class is already complex (suggested by other metrics) then it may need to be redesigned, intensively tested or carefully reviewed.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of constant properties

Number of properties with a setter (only applicable to C#)

Number of internal properties (only applicable to C#)

Total number of properties

Number of properties without accessibility specifier

Number of public properties

Number of protected internal properties (only applicable to C#)

Number of protected properties

Number of private properties

Number of properties with a getter (only applicable to C#)

Number of static properties in the class

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

Number of special operators used in the source file

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of ternary operators i.e. ?:

Number of 'throw' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of 'try' statements in the function

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

Backward gotos shall not be used.

The statement forming the body of a switch, while, do …​ while or for statement shall be a compound statement (see [MISRA-C:2004]: RULE 14.8).

An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement (see [MISRA-C:2004]: RULE 14.9).

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

Assignment operators should not be used in condition expressions (if, for, while, do, switch).

Assignment operators shall not be used in condition expressions (if, for, while, do, switch) that does not contain comparison operators.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

There shall be a no code before the first case of a switch statement.

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

There shall be no fallthrough the next case in a switch statement.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

The 'goto' statement shall not be used (see [MISRA-C:2004]: RULE 14.4).

A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement (see [MISRA-C:2004]: RULE 15.1).

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

For any iteration statement there shall be at most one 'break' statement used for loop termination (see [MISRA-C:2004]: RULE 14.6).

Number of 'andthen' operators

Count number of arithmetic if

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'break' statements in loop in the function

Number of 'case' blocks in 'switch' in the function

Number of 'case' labels in the function

Duplicated code of this artefact

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of duplicated tokens in control flow of functions

Number of lines of comments in the source file(s).

Number of cloned artefacts

Number of 'continue' statements in the function

Number of Commented Statements.

Count number of declarative statements

Number of 'default' blocks in 'switch' in the function

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'do…​while' statements in the function

Number of 'else' statements

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of 'goto' statements

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Duplicated code in this artefact

Number of duplicated tokens in control flow of functions

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of lines containing both code and comment in the source files.

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Percent of parsed tokens

Number of files where a parsing error occured, resulting in a partial interpretation

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

A function must have the same number of allocate and deallocate.

Backward gotos shall not be used.

Use of contains is forbidden to declare functions inside another function.

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

The 'continue' statement is deprecated.

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

A project should not contain any Fortran 77 file.

The number of lines of code of a function must not exceed the limit.

A function must be declared inside a Fortran module

Function name does not fit the convention.

Module name does not fit the convention.

A parameter name must comply with the minimum length.

Program name does not fit the convention.

Subroutine name does not fit the convention.

The number of parameters received by a function should not exceed the limit.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

The 'cycle' statement shall not be used.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

The 'goto' statement shall not be used (see [MISRA-C:2004]: RULE 14.4).

A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement (see [MISRA-C:2004]: RULE 15.1).

There shall be no duplicated parts in functions

The 'stop' statement shall not be used.

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A rule violation is relaxed and justified.

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

A function must not use the SAVE and DATA keywords.

For any iteration statement there shall be at most one 'exit' statement used for loop termination.

Number of 'andthen' operators

Number of public data

Number of assignment operators used in the source file

Number of comment blocks.

Number block of comment placed before the beginning of the artefact.

Number of blank lines of code in the source file(s).

Number of lines of code containing only a brace in the source file(s).

Number of 'break' statements in loop in the function

Number of 'break' statements in 'switch' in the function

Number of 'case' blocks in 'switch' in the function

Number of 'case' labels in the function

Number of 'catch' statements in the function

Number of lines in source code used when searching for code duplication

Number of linearly independent paths in the function control graph.

Number of tokens in the control flow of functions

Number of lines of comments in the source file(s).

Number of 'continue' statements in the function

Number of Commented Statements.

Number of 'default' blocks in 'switch' in the function

DOPD counts the number of distinct operands: variables, constants, identifiers, constants and function names when used during calls. ([Halstead,76]: n2)

Example: In the expression A = B + 3; A, B and 3 are the operands.

Number of distinct operators: language keywords ([Halstead,76]: n1)

Number of 'do…​while' statements in the function

Number of 'else' statements

Number of Comments containing FIXME string.

Number of 'for' statements in the function

Number of control structures added since the previous version.

Number of control structures modified since the previous version.

Number of control structures removed since the previous version.

Number of comment lines placed before the beginning of the artefact.

Number of lines between the function or class definition and the first opening brace.

Number of 'if' statements

Number of lines.

Number of loop statements in the function

Number of lines containing both code and comment in the source files.

Number of methods without any accessibility specifier

Number of public methods

NEST is the maximum nesting level found in the function.

Measurement method: Nesting is computed by counting the number of imbrication level. For loop, while loop, if conditional statement is all considered as a layer, thus an if statement inside a for loop will be measured as a nesting level of 2. In a consistently indented code, the nesting number can be visualized as the right most-indented line of the function’s body. The maximum of all blocks of code containing imbrication is kept. Notes, else if structures are considered as imbrication level.

Meaning: High nesting levels make the code difficult to understand and can lead to errors in program logic, it shows a complicated design with either to much control flow ( if/else statements) or computational complexity (for loops) or both of them. Above 5 of nesting, the function should be perceived as critical.

Improving: Consider splitting the procedure, inspect the code and/or add unit testing.

NOP counts the number of formal parameters of the method.

Meaning: A high number of parameters suggests a strong coupling between modules in comparison with low numbers. A module with many parameters may require more time and effort to understand, and when modified it is more likely that it will have side effects on other modules.

Improving: If coding with object-oriented programming language you may consider if some parameters could be grouped inside an object. Consider refactoring in successive smaller modules if possible.

PATH is the number of non-cyclic paths in the function.

Measurement method: PATH is calculated according to the transfers of control induced by the various types of statements. The PATH for a sequence of statements with the same nesting level is the product of each statement’s PATH. For nested structures, the sum of the PATH is calculated.

Meaning: PATH is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Improving: To reduce PATH for a function, try to divide the function into blocks of code that logically belong together. Create a new function for each block of code. Then replace each block of code with the newly created function. The original functionality is thus distributed, reducing the PATH value for the original function.

Example:

PATH(if then else endif) = PATH(body of then) + PATH(body of else)

PATH(while do-endwhile for) = PATH(body of while) + 1

PATH(switch) = SUM (i=1,n) PATH(body of case(i)), where n is the number of cases.

PATH(sequence) = 1

Number of 'orelse' operators

Number of files where a parsing error occured, resulting in a partial interpretation

Number of 'return' statements in the function

Duplicated blocks in the function

Skipped Lines of Comment code i.e. lines that match a user defined regular expression to skip lines of comments.

Number of lines of source code in the source file(s).

STAT counts the number of executable statements in the artifact.

Measurement method: A statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. To be counted in STAT, the statement has to contain executable code. Declarations are not counted as executable statements.

Meaning: STAT is a measure of the size of the module, it highlights a complexity by counting the number of executable statements. A high number of statements may suggest a high algorithmic complexity. Many statements also suggest more time to fully read and thus to fully understand the module.

Improving: A module with more than 50 statements should be inspected, the analysis of the module can be completed with the help of others metrics such as VG, NEST…​

Number of 'switch' statements in the function

Number of ternary operators i.e. ?:

Number of 'throw' statements in the function

Number of Comments containing TODO string.

Number of occurrences of operands: variables and constants ([Halstead,76]: N2)

Number of occurrences of operators: language keywords ([Halstead,76]: N1)

Number of 'try' statements in the function

Number of lines added since the previous version.

Number of lines modified since the previous version.

Number of lines removed since the previous version.

Number of 'while' statements in the function

An unconditional break statement shall terminate every non-empty switch clause (see [MISRA-C:2004]: RULE 15.2).

The statement forming the body of a switch, while, do …​ while or for statement shall be a compound statement (see [MISRA-C:2004]: RULE 14.8).

An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement (see [MISRA-C:2004]: RULE 14.9).

The final clause of a switch statement shall be the default clause (see [MISRA-C:2004]: RULE 15.3).

All if …​ else if constructs shall be terminated with an else clause (see [MISRA-C:2004]: RULE 14.10).

Assignment operators should not be used in condition expressions (if, for, while, do, switch).

Assignment operators shall not be used in condition expressions (if, for, while, do, switch) that does not contain comparison operators.

Consider classes refactorization

Consider files refactorization

Consider functions refactorization

Consider packages refactorization

There shall be no duplicated classes

There shall be no duplicated files

There shall be no duplicated functions

There shall be no algorithmic cloning

There shall be a no code before the first case of a switch statement.

The 'continue' statement shall not be used (see [MISRA-C:2004]: RULE 14.5).

There shall be no fallthrough the next case in a switch statement.

FIXME shall not be commited in sources code as it brings confusion regarding code reliability.

There shall be no duplicated parts in functions

TODO shall not be commited in sources code as it brings confusion regarding code reliability.

Every switch statement shall have at least one case clause (see [MISRA-C:2004]: RULE 15.5).

A function shall have a single point of exit at the end (see [MISRA-C:2004]: RULE 14.7).

For any iteration statement there shall be at most one 'break' statement used for loop termination (see [MISRA-C:2004]: RULE 14.6).

Number of constant data

Number of attributes

Number of 'andthen' operators

Number of public data