Matrix Req To Tests

Code Metric
NumFiles (Number of files)

NumIncludFiles (Number of included header files)
AP_CG_CYCLE (Number of Recursions)
AP_CG_DIRECT_CYCLE (Number of Direct Recursions)
NumLines (Number of lines)
NumLineNoCom (Number of lines without comment)
COMF (Comment Density)
FCO (Estimated Function Coupling)
FLIN (Number of Lines Within Body)
FXLN (Number of Executable Lines)
VG (Cyclomatic Complexity V(G))
VOCF (Language Scope)
PATH (Number of Paths)
CALLING (Number of Calling Functions)
CALLS (Number of Called Functions)
NCALLS (Number of Call Occurences)
STMT (Number of instructions per function)
LEVEL (Number of call levels)
PARAM (Number of functions parameters)
GOTO (Number of Go to Statements)
Num_RETURN (Number of return points)
LOCAL_VARS_MAX (Estimated Size of Local Variables - Conservative)
LOCAL_VARS_MIN (Estimated Size of Local Variables - Optimistic)
LOCAL_VARS (Number of Local Non-Static Variables)
LOCAL_STATIC_VARS (Number of Local Static Variables)
Tests
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumFiles.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumIncludFiles.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/AP_CG_CYCLE.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/AP_CG_DIRECT_CYCLE.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumLines.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumLineNoCom.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/COMF.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FCO.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FLIN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FXLN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/VG.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/VOCF.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/PATH.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/CALLING.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/CALLS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NCALLS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/STMT.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LEVEL.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/PARAM.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/GOTO.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/Num_RETURN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS_MAX.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS_MIN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_STATIC_VARS.c
Tests
toolbox/qualkits/do/bugfinder/tests/code-metrics/CALLING.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS_MAX.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/VG.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/CALLS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_STATIC_VARS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FCO.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/COMF.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/Num_RETURN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/AP_CG_DIRECT_CYCLE.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumIncludFiles.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS_MIN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumLines.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/STMT.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/GOTO.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LOCAL_VARS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NCALLS.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FLIN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumLineNoCom.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/VOCF.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/NumFiles.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/PARAM.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/FXLN.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/PATH.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/AP_CG_CYCLE.c
toolbox/qualkits/do/bugfinder/tests/code-metrics/LEVEL.c
Code Metric
CALLING (Number of Calling Functions)
LOCAL_VARS_MAX (Estimated Size of Local Variables - Conservative)
VG (Cyclomatic Complexity V(G))
CALLS (Number of Called Functions)
LOCAL_STATIC_VARS (Number of Local Static Variables)
FCO (Estimated Function Coupling)
COMF (Comment Density)
Num_RETURN (Number of return points)
AP_CG_DIRECT_CYCLE (Number of Direct Recursions)
NumIncludFiles (Number of included header files)
LOCAL_VARS_MIN (Estimated Size of Local Variables - Optimistic)
NumLines (Number of lines)
STMT (Number of instructions per function)
GOTO (Number of Go to Statements)
LOCAL_VARS (Number of Local Non-Static Variables)
NCALLS (Number of Call Occurences)
FLIN (Number of Lines Within Body)
NumLineNoCom (Number of lines without comment)
VOCF (Language Scope)
NumFiles (Number of files)
PARAM (Number of functions parameters)
FXLN (Number of Executable Lines)
PATH (Number of Paths)
AP_CG_CYCLE (Number of Recursions)
LEVEL (Number of call levels)
Misra C 2004
1.1 (All code shall conform to Iso 9899:1990 'Programming languages - C'.)
1.2 (No reliance shall be placed on undefined or unspecified behaviour.)
1.3 (Multiple compilers and/or languages shall only be used if there is a common defined interface standard for object code to
1.4 (The compilers/linker shall be checked to ensure that 31 characters significance and case sensitivity are supported for exte
1.5 (Floating-point implementations should comply with a defined floating-point standard.)
2.1 (Assembly language shall be encapsulated and isolated.)
2.2 (source code shall only use /* ... */ style comments.)
2.3 (The character sequence /* shall not be used within a comment.)
2.4 (Sections of code should not be "commented out".)
3.1 (All usage of implementation-defined behaviour shall be documented.)
3.2 (The character set and the corresponding encoding shall be documented.)
3.3 (The implementation of integer division in the chosen compiler should be determined, documented and taken into account
3.4 (All uses of the #pragma directive shall be documented and explained.)
3.5 (The implementation-defined behaviour and packing of bitfields shall be documented if being relied upon.)
3.6 (All libraries used in production code shall be written to comply with provisions of this document, and shall have been subje
4.1 (Only those escape sequences that are defined in the ISO C standard shall be used.)
4.2 (Trigraphs shall not be used.)
5.1 (Identifiers (internal and external) shall not rely on the significance of more than 31 characters.)
5.2 (Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identif
5.3 (A typedef name shall be a unique identifier.)

5.4 (A tag name shall be a unique identifier.)
5.5 (No object or function identifier with static storage duration should be reused.)
5.6 (No identifier in one name space should have the same spelling as an identifier in another name space, with the exception
5.7 (No identifier name should be reused)
6.1 (The plain char type shall be used only for storage and use of character values.)
6.2 (signed and unsigned char type shall be used only for the storage and use of numeric values.)
6.3 (typdefs that indicate size and signedess should be used in place of the basic types.)
6.4 (Bit fields shall only be defined to be of type unsigned int or signed int.)
6.5 (Bit fields of type signed int shall be at least 2 bits long.)
7.1 (Octal constants (other than zero) and octal escape sequences shall not be used.)
8.1 (Functions shall have prototype declarations and the prototype shall be visible at both the function definition and call.)
8.2 (Whenever an object or function is declared or defined, its type shall be explicitly stated.)
8.3 (For each function parameter the type given in the declaration and definition shall be identical, and the return types shall a
8.4 (If objects or functions are declared more than once their types shall be compatible.)
8.5 (There shall be no definitions of objects or functions in a header file.)
8.6 (Functions shall be declared at file scope.)
8.7 (Objects shall be defined at block scope if they are only accessed from within a single function.)
8.8 (An external object or function shall be declared in one and only one file.)
8.9 (An identifier with external linkage shall have exactly one external definition.)
8.10 (All declarations and definitions of objects or functions at file scope shall have internal linkage unless external linkage is r
8.11 (The static storage class specifier shall be used in definitions and declarations of objects and functions that have internal
8.12 (When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisation.)
9.1 (All automatic variables shall have been assigned a value before being used.)
9.2 (Braces shall be used to indicate and match the structure in the non-zero initialisation of arrays and structures.)
9.3 (In an enumerator list, the "=" construct shall not be used to explicitly initialise members other than the first, unless all item
10.1 (The value of an expression of integer type shall not be implicitly converted to a different underling type if ...)
10.2 (The value of an expression of floating type shall not be implicitly converted to a different type if ...)
10.3 (The value of a complex expression of integer type may only be cast to a type that is narrower and of the same signedne
10.4 (The value of a complex expression of floating type may only be cast to a narrower floating type.)
10.5 (If the bitwise operators ~ and << are applied to an operand of underlying type unsigned char or unsigned short, the resu
10.6 (A "U" suffix shall be applied to all constants of unsigned type.)
11.1 (Conversions shall not be performed between a pointer to a function and any type other than an integral type.)
11.2 (Conversions shall not be performed between a pointer to object and any type other than an integral type, another pointe
11.3 (A cast should not be performed between a pointer type and an integral type.)
11.4 (A cast should not be performed between a pointer to object type and a different pointer to object type.)
11.5 (A cast should not be performed that removes any const or volatile qualification from the type addressed by a pointer.)
12.1 (Limited dependence should be placed on C's operator precedence rules in expressions.)
12.2 (The value of an expression shall be the same under any order of evaluation that the standard permits.)
12.3 (The sizeof operator shall not be used on expressions that contain side effects.)
12.4 (The right-hand operand of a logical && or || shall be primary-expressions.)
12.5 (The operand of logical && or || shall be primary-expressions.)
12.6 (The operand of logical operators (&& or || and !) should be effectively Boolean. Expressions that are effectively Boolean
and !).)
12.7 (Bitwise operators shall not be applied to operands whose underlying type is signed.)
12.8 (The right-hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying typ
12.9 (The unary minus operator shall not be applied to an expression whose underlying type is unsigned.)
12.10 (The comma operator shall not be used.)
12.11 (Evaluation of constant unsigned integer expressions should not lead to wrap-around.)
12.12 (The underlying bit representations of floating-point values shall not be used.)
12.13 (The increment (++) and decrement (--) operators should not be missed with other operators in an expression.)
13.1 (Assignment operators shall not be used in expressions that yield a Boolean value.)
13.2 (Tests of a value against zero should be made explicit, unless the operand is effectively Boolean.)
13.3 (Floating-point expressions shall not be tested for equality or inequality.)
13.4 (The controlling expression of a for statement shall not contain any objects of floating type.)
13.5 (The three expressions of a for statement shall not contain any objects of floating type.)
13.6 (Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.)
13.7 (Boolean operations whose results are invariant shall not be permitted.)
14.1 (There shall be no unreachable code.)
14.2 (All non-null statements shall either have at least one side effect however executed or cause control flow to change.)
14.3 (before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment provided that
character.)
14.4 (The goto statement shall not be used.)
14.5 (the continue statement shall not be used.)
14.6 (For any iteration statement there shall be at most one break statement used for loop termination.)
14.7 (A function shall have a single point of exit at the end of the function.)
14.8 (The statement forming the body of a switch, while, do >>> while or for statement be a compound statement.)
14.9 (An if(expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a c
14.10 (All if...else constructs shall be terminated with an else clause.)
15.0 (Misra Switch syntax rules)
15.1 (A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statemen
15.2 (An unconditional break statement shall terminate every non-empty switch clause.)
15.3 (The final clause of a switch statement shall be the default clause.)
15.4 (A switch expression shall not represent a value that is effectively Boolean.)
15.5 (Every switch statement shall have at least one case clause.)
16.1 (Functions shall not be defined with variable numbers of arguments.)
16.2 (Functions shall not be called themselves, either directly or indirectly.)
16.3 (Identifiers shall be given for all of the parameters in a function prototype declaration.)
16.4 (The identifiers used in declaration and definition of a function shall be identical.)
16.5 (Functions with no parameters shall be declared with parameter type void.)
16.6 (the number of arguments passed to a function shall match the number of parameters.)
16.7 (A pointer parameter in a function prototype should be declared as a pointer to const if the pointer is not used to modify th
16.8 (All exit paths from a function with non-void return type shall have an explicit return statement with an expression.)
16.9 (A function identifier shall only be used with either a preceding &, or with a parenthesized parameter list, which may be em
16.10 (If a function returns error information, then that error information shall be tested.)
17.1 (Pointer arithmetic shall only be applied to pointers that address an array or array element.)
17.2 (Pointer subtraction shall only be applied to pointers that address elements of the same array.)
17.3 (>, >=, <, <= shall not be applied to pointer types except where they point to the same array.)
17.4 (Array indexing shall be only allowed form of pointer arithmetic.)

17.5 (The declaration of objects should contain no more than 2 levels of pointer indirection.)
17.6 (The address of an object with automatic storage shall not be assigned to another object that may persist after the first ob
18.1 (All structure or union types shall be complete at the end of a translation unit.)
18.2 (An object shall not be assigned to an overlapping object.)
18.3 (An area of memory shall not be reused for unrelated purposes.)
18.4 (Unions shall not be used.)
19.1 (#include statements in a file should only be preceded by other preprocessor directives or comments.)
19.2 (Non-standard characters should not occur in header file names in #include directives.)
19.3 (The #include directive shall be followed by either a <filename> or "filename" sequence.)
19.4 (C macros shall only expand to a braced initialiser, a constant, a parenthesized expression, a type qualifier, a storage cla
19.5 (Macros shall not be #define'd or #undef'd within a block)
19.6 (#undef shall not be used)

19.7 (A function should not be used in preference to a function-like macro.)
19.8 (A function-like macro shall not ne invoked without all of its arguments.)
19.9 (Arguments to a function-like macro shall not contain tokens that look like preprocessing directives.)
19.10 (In the definition of a function-like macro each instance of a parameter shall be enclosed in parentheses unless it is use
19.11 (All macro identifiers in preprocessor directives shall be defined before use, except in #ifdef and #ifndef preprocessor di
19.12 (There shall be at most one occurrence of the # or ## preprocessor operators in a single macro definition.)
19.13 (The # and ## preprocessor operators should not be used.)
19.14 (The defined preprocessor operator shall only be used in one of the two standard forms.)
19.15 (Precautions shall be taken in order to prevent the contents of a header file being included twice.)
19.16 (Preprocessing directives shall be syntactically meaningful even when excluded by the preprocessor.)
19.17 (All #else, #elif, and #endif preprocessor directives shall reside in the same file as the #if or #ifdef directive to which they
20.1 (Reserved identifiers, macros and functions in the standard library, shall not be defined, redefined or undefined.)
20.2 (The names of standard library macros, objects and functions shall not be reused.)
20.3 (The validity of values passed to library functions shall be checked.)
20.4 (Dynamic heap memory allocation shall not be used.)
20.5 (The error indicator errno shall not be used.)
20.6 (The macro offsetof, in library <stddef.h>, shall not be used.)
20.7 (The setjmp macro and the longjmp function shall not be used.)
20.8 (The signal handling facilities of <signal.h> shall not be used.)
20.9 (The input/output library <stdio.h> shall not be used in production code.)
20.10 (The library functions atof, atoi and atol from library <stdlib.h> shall not be used.)
20.11 (The library functions abort, exit, getenv, and system from library <stdlib.h> shall not be used.)
20.12 (The time handling functions of library <time.h> shall not be used.)
21.1 (Minimisation of run-time failures shall be ensured by the use of ...)
Status
partly
notImp
notImp
notImp
notImp
partly
fully
fully
notImp
notImp
notImp
notImp
fully
notImp
notImp
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
partly
fully
fully
fully
partly
partly
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
partly
fully
fully
fully
fully
fully
fully
fully
fully
fully
partly
fully
fully
fully
partly
partly
partly
partly
fully
fully
fully
partly
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
partly
fully
fully
fully
fully
fully
fully
fully
partly
fully
partly
fully
fully
notImp
fully
fully
fully
fully
partly
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
partly
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
fully
Tests
toolbox/qualkits/do/bugfinder/tests/misrac/misra-1-1.c
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
EMPTY
toolbox/qualkits/do/bugfinder/tests/misrac/misra-5-3_1.c
EMPTY
Tests Status
toolbox/qualkits/do/bugfinder/tests/misrac/misra-1-1.c partly
toolbox/qualkits/do/bugfinder/tests/misrac/misra-6-1.c fully
toolbox/qualkits/do/bugfinder/tests/misrac/misra-17-4_2.c partly
toolbox/qualkits/do/bugfinder/tests/misrac/misra-10-1_2.c fully
toolbox/qualkits/do/bugfinder/tests/misrac/misra-17-4_1.c partly
Misra C 2004
1.1 (All code shall conform to Iso 9899:1990 'Programming languages - C'.)
6.1 (The plain char type shall be used only for storage and use of character values.)
11.3 (A cast should not be performed between a pointer type and an integral type.)
20.7 (The setjmp macro and the longjmp function shall not be used.)
14.4 (The goto statement shall not be used.)
13.4 (The controlling expression of a for statement shall not contain any objects of floating type.)
16.3 (Identifiers shall be given for all of the parameters in a function prototype declaration.)
12.7 (Bitwise operators shall not be applied to operands whose underlying type is signed.)
19.12 (There shall be at most one occurrence of the # or ## preprocessor operators in a single macro definition.)
9.2 (Braces shall be used to indicate and match the structure in the non-zero initialisation of arrays and structures.)
16.9 (A function identifier shall only be used with either a preceding &, or with a parenthesized parameter list, which may be em
5.5 (No object or function identifier with static storage duration should be reused.)
19.1 (#include statements in a file should only be preceded by other preprocessor directives or comments.)
5.4 (A tag name shall be a unique identifier.)
16.8 (All exit paths from a function with non-void return type shall have an explicit return statement with an expression.)
9.3 (In an enumerator list, the "=" construct shall not be used to explicitly initialise members other than the first, unless all item
17.1 (Pointer arithmetic shall only be applied to pointers that address an array or array element.)
19.13 (The # and ## preprocessor operators should not be used.)
12.6 (The operand of logical operators (&& or || and !) should be effectively Boolean. Expressions that are effectively Boolean
16.2 (Functions shall not be called themselves, either directly or indirectly.)
13.5 (The three expressions of a for statement shall not contain any objects of floating type.)
14.10 (All if...else constructs shall be terminated with an else clause.)
14.5 (the continue statement shall not be used.)
20.6 (The macro offsetof, in library <stddef.h>, shall not be used.)
11.2 (Conversions shall not be performed between a pointer to object and any type other than an integral type, another pointe
18.2 (An object shall not be assigned to an overlapping object.)
20.12 (The time handling functions of library <time.h> shall not be used.)
20.10 (The library functions atof, atoi and atol from library <stdlib.h> shall not be used.)
6.2 (signed and unsigned char type shall be used only for the storage and use of numeric values.)
8.2 (Whenever an object or function is declared or defined, its type shall be explicitly stated.)
14.7 (A function shall have a single point of exit at the end of the function.)
19.9 (Arguments to a function-like macro shall not contain tokens that look like preprocessing directives.)
20.4 (Dynamic heap memory allocation shall not be used.)
13.7 (Boolean operations whose results are invariant shall not be permitted.)
19.11 (All macro identifiers in preprocessor directives shall be defined before use, except in #ifdef and #ifndef preprocessor di
12.4 (The right-hand operand of a logical && or || shall be primary-expressions.)
17.3 (>, >=, <, <= shall not be applied to pointer types except where they point to the same array.)
10.3 (The value of a complex expression of integer type may only be cast to a type that is narrower and of the same signedne
9.1 (All automatic variables shall have been assigned a value before being used.)
15.4 (A switch expression shall not represent a value that is effectively Boolean.)
7.1 (Octal constants (other than zero) and octal escape sequences shall not be used.)
8.8 (An external object or function shall be declared in one and only one file.)
5.6 (No identifier in one name space should have the same spelling as an identifier in another name space, with the exception
19.3 (The #include directive shall be followed by either a <filename> or "filename" sequence.)
19.2 (Non-standard characters should not occur in header file names in #include directives.)
8.9 (An identifier with external linkage shall have exactly one external definition.)
5.7 (No identifier name should be reused)
15.5 (Every switch statement shall have at least one case clause.)
10.2 (The value of an expression of floating type shall not be implicitly converted to a different type if ...)
17.2 (Pointer subtraction shall only be applied to pointers that address elements of the same array.)
12.5 (The operand of logical && or || shall be primary-expressions.)
19.10 (In the definition of a function-like macro each instance of a parameter shall be enclosed in parentheses unless it is use
16.1 (Functions shall not be defined with variable numbers of arguments.)
13.6 (Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.)
20.5 (The error indicator errno shall not be used.)
14.6 (For any iteration statement there shall be at most one break statement used for loop termination.)
19.8 (A function-like macro shall not ne invoked without all of its arguments.)
11.1 (Conversions shall not be performed between a pointer to a function and any type other than an integral type.)
8.3 (For each function parameter the type given in the declaration and definition shall be identical, and the return types shall a
3.4 (All uses of the #pragma directive shall be documented and explained.)
6.3 (typdefs that indicate size and signedess should be used in place of the basic types.)
18.1 (All structure or union types shall be complete at the end of a translation unit.)
20.11 (The library functions abort, exit, getenv, and system from library <stdlib.h> shall not be used.)
20.1 (Reserved identifiers, macros and functions in the standard library, shall not be defined, redefined or undefined.)
14.2 (All non-null statements shall either have at least one side effect however executed or cause control flow to change.)
11.5 (A cast should not be performed that removes any const or volatile qualification from the type addressed by a pointer.)
8.7 (Objects shall be defined at block scope if they are only accessed from within a single function.)
16.5 (Functions with no parameters shall be declared with parameter type void.)
13.2 (Tests of a value against zero should be made explicit, unless the operand is effectively Boolean.)
17.6 (The address of an object with automatic storage shall not be assigned to another object that may persist after the first ob
12.1 (Limited dependence should be placed on C's operator precedence rules in expressions.)
19.14 (The defined preprocessor operator shall only be used in one of the two standard forms.)
15.1 (A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statemen
10.6 (A "U" suffix shall be applied to all constants of unsigned type.)
2.3 (The character sequence /* shall not be used within a comment.)
12.12 (The underlying bit representations of floating-point values shall not be used.)
14.8 (The statement forming the body of a switch, while, do >>> while or for statement be a compound statement.)
5.2 (Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identif
19.7 (A function should not be used in preference to a function-like macro.)
14.9 (An if(expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a c
12.13 (The increment (++) and decrement (--) operators should not be missed with other operators in an expression.)
2.2 (source code shall only use /* ... */ style comments.)
15.0 (Misra Switch syntax rules)
19.15 (Precautions shall be taken in order to prevent the contents of a header file being included twice.)
13.3 (Floating-point expressions shall not be tested for equality or inequality.)
16.4 (The identifiers used in declaration and definition of a function shall be identical.)
8.12 (When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisation.)
11.4 (A cast should not be performed between a pointer to object type and a different pointer to object type.)
8.6 (Functions shall be declared at file scope.)
14.3 (before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment provided that
4.1 (Only those escape sequences that are defined in the ISO C standard shall be used.)
18.4 (Unions shall not be used.)
6.4 (Bit fields shall only be defined to be of type unsigned int or signed int.)
12.8 (The right-hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying typ
14.1 (There shall be no unreachable code.)
20.2 (The names of standard library macros, objects and functions shall not be reused.)
8.4 (If objects or functions are declared more than once their types shall be compatible.)
16.6 (the number of arguments passed to a function shall match the number of parameters.)
8.10 (All declarations and definitions of objects or functions at file scope shall have internal linkage unless external linkage is r
13.1 (Assignment operators shall not be used in expressions that yield a Boolean value.)
17.5 (The declaration of objects should contain no more than 2 levels of pointer indirection.)
19.17 (All #else, #elif, and #endif preprocessor directives shall reside in the same file as the #if or #ifdef directive to which they
21.1 (Minimisation of run-time failures shall be ensured by the use of ...)
15.2 (An unconditional break statement shall terminate every non-empty switch clause.)
10.5 (If the bitwise operators ~ and << are applied to an operand of underlying type unsigned char or unsigned short, the resu
12.11 (Evaluation of constant unsigned integer expressions should not lead to wrap-around.)
19.5 (Macros shall not be #define'd or #undef'd within a block)
20.8 (The signal handling facilities of <signal.h> shall not be used.)
5.1 (Identifiers (internal and external) shall not rely on the significance of more than 31 characters.)
20.9 (The input/output library <stdio.h> shall not be used in production code.)
19.4 (C macros shall only expand to a braced initialiser, a constant, a parenthesized expression, a type qualifier, a storage cla
12.10 (The comma operator shall not be used.)
2.1 (Assembly language shall be encapsulated and isolated.)
10.4 (The value of a complex expression of floating type may only be cast to a narrower floating type.)
15.3 (The final clause of a switch statement shall be the default clause.)
12.3 (The sizeof operator shall not be used on expressions that contain side effects.)
19.16 (Preprocessing directives shall be syntactically meaningful even when excluded by the preprocessor.)
16.10 (If a function returns error information, then that error information shall be tested.)
16.7 (A pointer parameter in a function prototype should be declared as a pointer to const if the pointer is not used to modify th
8.11 (The static storage class specifier shall be used in definitions and declarations of objects and functions that have internal
8.5 (There shall be no definitions of objects or functions in a header file.)
20.3 (The validity of values passed to library functions shall be checked.)
6.5 (Bit fields of type signed int shall be at least 2 bits long.)
12.9 (The unary minus operator shall not be applied to an expression whose underlying type is unsigned.)
4.2 (Trigraphs shall not be used.)
Misra C 2012
D1.1 (Any implementation-defined behaviour on which the output of the program depends shall be documented and understoo
D2.1 (All source files shall compile without any compilation errors)
D3.1 (All code shall be traceable to documented requirements)
D4.1 (Run-time failures shall be minimized)
D4.2 (All usage of assembly language should be documented)
D4.3 (Assembly language shall be encapsulated and isolated)
D4.4 (Sections of code should not be âcommented outâ )
D4.5 (Identifiers in the same name space with overlapping visibility should be typographically unambiguous)
D4.6 (typedefs that indicate size and signedness should be used in place of the basic numerical types)
D4.7 (If a function returns error information, then that error information shall be tested)
D4.8 (If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object s
D4.9 (A function should be used in preference to a function-like macro where they are interchangeable)
D4.10 (Precautions shall be taken in order to prevent the contents of a header file being included more than once)
D4.11 (The validity of values passed to library functions shall be checked)
D4.12 (Dynamic memory allocation shall not be used)
D4.13 (Functions which are designed to provide operations on a resource should be called in an appropriate sequence)
D4.14 (The validity of values received from external sources shall be checked)
R1.1 (The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementati
R1.2 (Language extensions should not be used)
R1.3 (There shall be no occurrence of undefined or critical unspecified behaviour)
R2.1 (A project shall not contain unreachable code)
R2.2 (There shall be no dead code)
R2.3 (A project should not contain unused type declarations)
R2.4 (A project should not contain unused tag declarations)
R2.5 (A project should not contain unused macro declarations)
R2.6 (A function should not contain unused label declarations)
R2.7 (There should be no unused parameters in functions)
R3.1 (The character sequences /* and // shall not be used within a comment)
R3.2 (Line-splicing shall not be used in // comments)
R4.1 (Octal and hexadecimal escape sequences shall be terminated)
R4.2 (Trigraphs should not be used)
R5.1 (External identifiers shall be distinct)
R5.2 (Identifiers declared in the same scope and name space shall be distinct)
R5.3 (An identifier declared in an inner scope shall not hide an identifier declared in an outer scope)
R5.4 (Macro identifiers shall be distinct)
R5.5 (Identifiers shall be distinct from macro names)
R5.6 (A typedef name shall be a unique identifier)
R5.7 (A tag name shall be a unique identifier)
R5.8 (Identifiers that define objects or functions with external linkage shall be unique)
R5.9 (Identifiers that define objects or functions with internal linkage should be unique)
R6.1 (Bit-fields shall only be declared with an appropriate type)
R6.2 (Single-bit named bit fields shall not be of a signed type)
R7.1 (Octal constants shall not be used)
R7.2 (A âuâ or âUâ suffix shall be applied to all integer constants that are represented in an unsigned type)
R7.3 (The lowercase character âlâ shall not be used in a literal suffix)
R7.4 (A string literal shall not be assigned to an object unless the objectâ s type is â pointer to const-qualified char)
R8.1 (Types shall be explicitly specified)
R8.10 (An inline function shall be declared with the static storage class)
R8.11 (When an array with external linkage is declared, its size should be explicitly specified)
R8.12 (Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique)
R8.13 (A pointer should point to a const-qualified type whenever possible)
R8.14 (The restrict type qualifier shall not be used)
R8.2 (Function types shall be in prototype form with named parameters)
R8.3 (All declarations of an object or function shall use the same names and type qualifiers)
R8.4 (A compatible declaration shall be visible when an object or function with external linkage is defined)
R8.5 (An external object or function shall be declared once in one and only one file)
R8.6 (An identifier with external linkage shall have exactly one external definition)
R8.7 (Functions and objects should not be defined with external linkage if they are referenced in only one translation unit)
R8.8 (The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage)
R8.9 (An object should be defined at block scope if its identifier only appears in a single function)
R9.1 (The value of an object with automatic storage duration shall not be read before it has been set)
R9.2 (The initializer for an aggregate or union shall be enclosed in braces)
R9.3 (Arrays shall not be partially initialized)
R9.4 (An element of an object shall not be initialized more than once)
R9.5 (Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly)
R10.1 (Operands shall not be of an inappropriate essential type)
R10.2 (Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations)
R10.3 (The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential
R10.4 (Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential ty
R10.5 (The value of an expression should not be cast to an inappropriate essential type)
R10.6 (The value of a composite expression shall not be assigned to an object with wider essential type)
R10.7 (If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are perform
type)
R10.8 (The value of a composite expression shall not be cast to a different essential type category or a wider essential type)
R11.1 (Conversions shall not be performed between a pointer to a function and any other type)
R11.2 (Conversions shall not be performed between a pointer to an incomplete type and any other type)
R11.3 (A cast shall not be performed between a pointer to object type and a pointer to a different object type)
R11.4 (A conversion should not be performed between a pointer to object and an integer type)
R11.5 (A conversion should not be performed from pointer to void into pointer to object)
R11.6 (A cast shall not be performed between pointer to void and an arithmetic type)
R11.7 (A cast shall not be performed between pointer to object and a non-integer arithmetic type)
R11.8 (A cast shall not remove any const or volatile qualification from the type pointed to by a pointer)
R11.9 (The macro NULL shall be the only permitted form of integer null pointer constant)
R12.1 (The precedence of operators within expressions should be made explicit)
R12.2 (The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential ty
R12.3 (The comma operator should not be used)
R12.4 (Evaluation of constant expressions should not lead to unsigned integer wrap-around)
R12.5 (The sizeof operator shall not have an operand which is a function parameter declared as â array of typeâ )
R13.1 (Initializer lists shall not contain persistent side effects)
R13.2 (The value of an expression and its persistent side effects shall be the same under all permitted evaluation orders fix in
R13.3 (A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects ot
operator)
R13.4 (The result of an assignment operator should not be used)
R13.5 (The right hand operand of a logical && or ||operator shall not contain persistent side effects)
R13.6 (The operand of the sizeof operator shall not contain any expression which has potential side effects)
R14.1 (A loop counter shall not have essentially floating type fix in 15a)
R14.2 (A for loop shall be well-formed)
R14.3 (Controlling expressions shall not be invariant)
R14.4 (The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essent
R15.1 (The goto statement should not be used)
R15.2 (The goto statement shall jump to a label declared later in the same function)
R15.3 (Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statem
R15.4 (There should be no more than one break or goto statement used to terminate any iteration statement)
R15.5 (A function should have a single point of exit at the end)
R15.6 (The body of an iteration-statement or a selection-statement shall be a compound-statement)
R15.7 (All if â¦ else if constructs shall be terminated with an else statement)
R16.1 (All switch statements shall be well-formed)
R16.2 (A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch stateme
R16.3 (An unconditional break statement shall terminate every switch-clause)
R16.4 (Every switch statement shall have a default label)
R16.5 (A default label shall appear as either the first or the last switch label of a switch statement)
R16.6 (Every switch statement shall have at least two switch-clauses)
R16.7 (A switch-expression shall not have essentially Boolean type)
R17.1 (The features of <stdarg.h> shall not be used)
R17.2 (Functions shall not call themselves, either directly or indirectly)
R17.3 (A function shall not be declared implicitly)
R17.4 (All exit paths from a function with non-void return type shall have an explicit return statement with an expression)
R17.5 (The function argument corresponding to a parameter declared to have an array type shall have an appropriate number
R17.6 (The declaration of an array parameter shall not contain the static keyword between the [ ])
R17.7 (The value returned by a function having non-void return type shall be used)
R17.8 (A function parameter should not be modified)
R18.1 (A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer ope
R18.2 (Subtraction between pointers shall only be applied to pointers that address elements of the same array)
R18.3 (The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the
R18.4 (The +, -, += and -= operators should not be applied to an expression of pointer type)
R18.5 (Declarations should contain no more than two levels of pointer nesting)
R18.6 (The address of an object with automatic storage shall not be copied to another object that persists after the first object
R18.7 (Flexible array members shall not be declared)
R18.8 (Variable-length array types shall not be used)
R19.1 (An object shall not be assigned or copied to an overlapping object)
R19.2 (The union keyword should not be used)
R20.10 (The# and ## preprocessor operators should not be used)
R20.1 (#include directives should only be preceded by preprocessor directives or comments)
R20.11 (A macro parameter immediately following a # operator shall not immediately be followed by a ## operator)
R20.12 (A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement,
R20.13 (A line whose first token is # shall be a valid preprocessing directive)
R20.14 (All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to w
R20.2 (The', "or \characters and the /* or //character sequences shall not occur in a header file name)
R20.3 (The #include directive shall be followed by either a <filename> or \"filename\"sequence)
R20.4 (A macro shall not be defined with the same name as a keyword)
R20.5 (#undef should not be used)
R20.6 (Tokens that look like a preprocessing directive shall not occur within a macro argument)
R20.7 (Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses)
R20.8 (The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1)
R20.9 (All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #defineâ d before eva
R21.1 (#define and #undef shall not be used on a reserved identifier or reserved macro name)
R21.10 (The Standard Library time and date functions shall not be used)
R21.11 (The standard header file <tgmath.h> shall not be used)
R21.12 (The exception handling features of <fenv.h> should not be used)
R21.13 (Any value passed to a function in <ctype.h> shall be representable as an unsigned char or be the value EOF)
R21.14 (The Standard Library function memcmp shall not be used to compare null terminated strings)
R21.15 (The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualif
R21.16 (The pointer arguments to the Standard Library function memcmp shall point to either a pointer type, an essentially sig
Boolean type or an essentially enum type)
R21.18 (The size_t argument passed to any function in <string.h> shall have an appropriate value)
R21.19 (The pointers returned by the Standard Library functions localeconv, getenv, setlocale or, strerror shall only be used a
R21.20 (The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocal
the same function)
R21.2 (A reserved identifier or macro name shall not be declared)
R21.3 (The memory allocation and deallocation functions of <stdlib.h> shall not be used)
R21.4 (The standard header file <setjmp.h> shall not be used)
R21.5 (The standard header file <signal.h> shall not be used)
R21.6 (The Standard Library input/output functions shall not be used)
R21.7 (The atof, atoi, atol, and atoll functions of <stdlib.h> shall not be used)
R21.8 (The library functions abort, exit, getenv and system of <stdlib.h> shall not be used)
R21.9 (The library functions bsearch and qsort of <stdlib.h> shall not be used)
R22.1 (All resources obtained dynamically by means of Standard Library functions shall be explicitly released)
R22.2 (A block of memory shall only be freed if it was allocated by means of a Standard Library function)
R22.3 (The same file shall not be open for read and write access at the same time on different streams)
R22.4 (There shall be no attempt to write to a stream which has been opened as read-only)
R22.5 (A pointer to a FILE object shall not be dereferenced)
R22.6 (The value of a pointer to a FILE shall not be used after the associated stream has been closed)
R22.7 (The macro EOF shall only be compared with the unmodified return value from any Standard Library function capable o
R22.8 (The value of errno shall be set to zero prior to a call to an errno-setting-function)
R22.9 (The value of errno shall be tested against zero after calling an errno-setting-function)
R22.10 (The value of errno shall only be tested when the last function to be called was an errno-setting-function)
Status Tests
notImp EMPTY
Implem toolbox/qualkits/do/bugfinder/tests/misrac-2012/misrac-D2-1.c
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
Implem toolbox/qualkits/do/bugfinder/tests/misrac-2012/misrac-R1-1.c
Tests Status
toolbox/qualkits/do/bugfinder/tests/misrac-2012/misrac-R22-9.c Implem
toolbox/qualkits/do/bugfinder/tests/misrac-2012/misrac-D4-14.c Implem
Misra C 2012
R22.9 (The value of errno shall be tested against zero after calling an errno-setting-function)
D4.14 (The validity of values received from external sources shall be checked)
R9.4 (An element of an object shall not be initialized more than once)
R2.3 (A project should not contain unused type declarations)
R12.4 (Evaluation of constant expressions should not lead to unsigned integer wrap-around)
R17.3 (A function shall not be declared implicitly)
R7.4 (A string literal shall not be assigned to an object unless the objectâ s type is â pointer to const-qualified char)
R10.3 (The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential
R20.12 (A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement,
R5.3 (An identifier declared in an inner scope shall not hide an identifier declared in an outer scope)
R21.7 (The atof, atoi, atol, and atoll functions of <stdlib.h> shall not be used)
R15.4 (There should be no more than one break or goto statement used to terminate any iteration statement)
R21.10 (The Standard Library time and date functions shall not be used)
R20.4 (A macro shall not be defined with the same name as a keyword)
D4.6 (typedefs that indicate size and signedness should be used in place of the basic numerical types)
D4.7 (If a function returns error information, then that error information shall be tested)
R22.3 (The same file shall not be open for read and write access at the same time on different streams)
R5.9 (Identifiers that define objects or functions with internal linkage should be unique)
R8.7 (Functions and objects should not be defined with external linkage if they are referenced in only one translation unit)
R17.8 (A function parameter should not be modified)
R18.1 (A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer ope
R5.8 (Identifiers that define objects or functions with external linkage shall be unique)
R8.6 (An identifier with external linkage shall have exactly one external definition)
R10.8 (The value of a composite expression shall not be cast to a different essential type category or a wider essential type)
R16.1 (All switch statements shall be well-formed)
R22.2 (A block of memory shall only be freed if it was allocated by means of a Standard Library function)
R3.1 (The character sequences /* and // shall not be used within a comment)
R13.6 (The operand of the sizeof operator shall not contain any expression which has potential side effects)
R4.1 (Octal and hexadecimal escape sequences shall be terminated)
R20.5 (#undef should not be used)
R11.1 (Conversions shall not be performed between a pointer to a function and any other type)
R21.11 (The standard header file <tgmath.h> shall not be used)
R15.5 (A function should have a single point of exit at the end)
R20.13 (A line whose first token is # shall be a valid preprocessing directive)
R5.2 (Identifiers declared in the same scope and name space shall be distinct)
R21.6 (The Standard Library input/output functions shall not be used)
R10.2 (Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations)
R17.2 (Functions shall not call themselves, either directly or indirectly)
R12.5 (The sizeof operator shall not have an operand which is a function parameter declared as â array of typeâ )
R2.2 (There shall be no dead code)
R21.20 (The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocal
R9.5 (Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly)
R19.2 (The union keyword should not be used)
R22.8 (The value of errno shall be set to zero prior to a call to an errno-setting-function)
R21.19 (The pointers returned by the Standard Library functions localeconv, getenv, setlocale or, strerror shall only be used a
R11.9 (The macro NULL shall be the only permitted form of integer null pointer constant)
R15.7 (All if â¦ else if constructs shall be terminated with an else statement)
R20.11 (A macro parameter immediately following a # operator shall not immediately be followed by a ## operator)
R21.4 (The standard header file <setjmp.h> shall not be used)
R11.3 (A cast shall not be performed between a pointer to object type and a pointer to a different object type)
R21.13 (Any value passed to a function in <ctype.h> shall be representable as an unsigned char or be the value EOF)
R20.7 (Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses)
R14.4 (The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essent
D4.5 (Identifiers in the same name space with overlapping visibility should be typographically unambiguous)
R13.4 (The result of an assignment operator should not be used)
R16.3 (An unconditional break statement shall terminate every switch-clause)
R18.3 (The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the
R8.4 (A compatible declaration shall be visible when an object or function with external linkage is defined)
R8.5 (An external object or function shall be declared once in one and only one file)
R18.2 (Subtraction between pointers shall only be applied to pointers that address elements of the same array)
R22.1 (All resources obtained dynamically by means of Standard Library functions shall be explicitly released)
R16.2 (A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch stateme
R8.14 (The restrict type qualifier shall not be used)
R13.5 (The right hand operand of a logical && or ||operator shall not contain persistent side effects)
R3.2 (Line-splicing shall not be used in // comments)
R4.2 (Trigraphs should not be used)
R20.6 (Tokens that look like a preprocessing directive shall not occur within a macro argument)
R11.2 (Conversions shall not be performed between a pointer to an incomplete type and any other type)
R21.12 (The exception handling features of <fenv.h> should not be used)
R20.10 (The# and ## preprocessor operators should not be used)
R5.1 (External identifiers shall be distinct)
R21.5 (The standard header file <signal.h> shall not be used)
R15.6 (The body of an iteration-statement or a selection-statement shall be a compound-statement)
R18.8 (Variable-length array types shall not be used)
R10.1 (Operands shall not be of an inappropriate essential type)
R17.1 (The features of <stdarg.h> shall not be used)
R2.1 (A project shall not contain unreachable code)
R19.1 (An object shall not be assigned or copied to an overlapping object)
R21.18 (The size_t argument passed to any function in <string.h> shall have an appropriate value)
R11.8 (A cast shall not remove any const or volatile qualification from the type pointed to by a pointer)
R20.8 (The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1)
R9.2 (The initializer for an aggregate or union shall be enclosed in braces)
R17.5 (The function argument corresponding to a parameter declared to have an array type shall have an appropriate number
R7.2 (A âuâ or âUâ suffix shall be applied to all integer constants that are represented in an unsigned type)
R2.5 (A project should not contain unused macro declarations)
R12.2 (The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential ty
R20.14 (All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to w
R5.5 (Identifiers shall be distinct from macro names)
R21.1 (#define and #undef shall not be used on a reserved identifier or reserved macro name)
R15.2 (The goto statement shall jump to a label declared later in the same function)
R10.5 (The value of an expression should not be cast to an inappropriate essential type)
R14.1 (A loop counter shall not have essentially floating type fix in 15a)
R20.2 (The', "or \characters and the /* or //character sequences shall not occur in a header file name)
R1.1 (The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementati
R11.6 (A cast shall not be performed between pointer to void and an arithmetic type)
R21.16 (The pointer arguments to the Standard Library function memcmp shall point to either a pointer type, an essentially sig
R22.5 (A pointer to a FILE object shall not be dereferenced)
R6.1 (Bit-fields shall only be declared with an appropriate type)
R16.6 (Every switch statement shall have at least two switch-clauses)
R8.10 (An inline function shall be declared with the static storage class)
R13.1 (Initializer lists shall not contain persistent side effects)
R8.1 (Types shall be explicitly specified)
R18.6 (The address of an object with automatic storage shall not be copied to another object that persists after the first object
R18.7 (Flexible array members shall not be declared)
D4.1 (Run-time failures shall be minimized)
R16.7 (A switch-expression shall not have essentially Boolean type)
R8.11 (When an array with external linkage is declared, its size should be explicitly specified)
R22.4 (There shall be no attempt to write to a stream which has been opened as read-only)
R11.7 (A cast shall not be performed between pointer to object and a non-integer arithmetic type)
R20.3 (The #include directive shall be followed by either a <filename> or \"filename\"sequence)
R10.4 (Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential ty
R15.3 (Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statem
R22.10 (The value of errno shall only be tested when the last function to be called was an errno-setting-function)
R5.4 (Macro identifiers shall be distinct)
R12.3 (The comma operator should not be used)
R2.4 (A project should not contain unused tag declarations)
R7.3 (The lowercase character âlâ shall not be used in a literal suffix)
R17.4 (All exit paths from a function with non-void return type shall have an explicit return statement with an expression)
R20.9 (All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #defineâ d before eva
R9.3 (Arrays shall not be partially initialized)
D4.13 (Functions which are designed to provide operations on a resource should be called in an appropriate sequence)
D4.11 (The validity of values passed to library functions shall be checked)
D4.9 (A function should be used in preference to a function-like macro where they are interchangeable)
R9.1 (The value of an object with automatic storage duration shall not be read before it has been set)
R7.1 (Octal constants shall not be used)
R17.6 (The declaration of an array parameter shall not contain the static keyword between the [ ])
R12.1 (The precedence of operators within expressions should be made explicit)
R2.6 (A function should not contain unused label declarations)
R15.1 (The goto statement should not be used)
R8.8 (The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage)
R5.6 (A typedef name shall be a unique identifier)
R21.2 (A reserved identifier or macro name shall not be declared)
R10.6 (The value of a composite expression shall not be assigned to an object with wider essential type)
R20.1 (#include directives should only be preceded by preprocessor directives or comments)
R14.2 (A for loop shall be well-formed)
R11.5 (A conversion should not be performed from pointer to void into pointer to object)
R1.2 (Language extensions should not be used)
R16.5 (A default label shall appear as either the first or the last switch label of a switch statement)
R8.13 (A pointer should point to a const-qualified type whenever possible)
R22.6 (The value of a pointer to a FILE shall not be used after the associated stream has been closed)
R6.2 (Single-bit named bit fields shall not be of a signed type)
D4.3 (Assembly language shall be encapsulated and isolated)
R13.2 (The value of an expression and its persistent side effects shall be the same under all permitted evaluation orders fix in
R18.5 (Declarations should contain no more than two levels of pointer nesting)
R21.8 (The library functions abort, exit, getenv and system of <stdlib.h> shall not be used)
R8.2 (Function types shall be in prototype form with named parameters)
R21.9 (The library functions bsearch and qsort of <stdlib.h> shall not be used)
R8.3 (All declarations of an object or function shall use the same names and type qualifiers)
R18.4 (The +, -, += and -= operators should not be applied to an expression of pointer type)
R13.3 (A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects ot
R22.7 (The macro EOF shall only be compared with the unmodified return value from any Standard Library function capable o
R16.4 (Every switch statement shall have a default label)
R8.12 (Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique)
R1.3 (There shall be no occurrence of undefined or critical unspecified behaviour)
R11.4 (A conversion should not be performed between a pointer to object and an integer type)
R21.14 (The Standard Library function memcmp shall not be used to compare null terminated strings)
R14.3 (Controlling expressions shall not be invariant)
R10.7 (If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are perform
D2.1 (All source files shall compile without any compilation errors)
R8.9 (An object should be defined at block scope if its identifier only appears in a single function)
R5.7 (A tag name shall be a unique identifier)
R21.3 (The memory allocation and deallocation functions of <stdlib.h> shall not be used)
R2.7 (There should be no unused parameters in functions)
R17.7 (The value returned by a function having non-void return type shall be used)
D4.10 (Precautions shall be taken in order to prevent the contents of a header file being included more than once)
Misra C++
0-1-1 (A project shall not contain unreachable code)
0-1-2 (A project shall not contain infeasible paths)
0-1-3 (A project shall not contain unused variables)
0-1-4 (A project shall not contain non-volatile POD variables having only one use)
0-1-5 (A project shall not contain unused type declarations)
0-1-6 (A project shall not contain instances of non-volatile variables being given values that are never subsequently used)
0-1-7 (The value returned by a function having a non- void return type that is not an overloaded operator shall always be used
0-1-8 (All functions with void return type shall have external side effect(s))
0-1-9 (There shall be no dead code)
0-1-10 (Every defined function shall be called at least once)
0-1-11 (There shall be no unused parameters (named or unnamed) in non- virtual functions)
0-1-12 (There shall be no unused parameters (named or unnamed) in the set of parameters for a virtual function and all the fu
0-2-1 (An object shall not be assigned to an overlapping object)
0-3-1 (Minimization of run-time failures shall be ensured by the use of at least one of: (a) static analysis tools/techniques; (b) d
(c) explicit coding of checks to handle run-time faults)
0-3-2 (If a function generates error information, then that error information shall be tested)
0-4-1 (Use of scaled-integer or fixed-point arithmetic shall be documented)
0-4-2 (Use of floating-point arithmetic shall be documented)
0-4-3 (Floating-point implementations shall comply with a defined floating-point standard)
1-0-1 (All code shall conform to ISO/IEC 14882:2003 "The C++ Standard Incorporating Technical Corrigendum 1")
1-0-2 (Multiple compilers shall only be used if they have a common, defined interface)
1-0-3 (The implementation of integer division in the chosen compiler shall be determined and documented)
2-2-1 (The character set and the corresponding encoding shall be documented)
2-3-1 (Trigraphs shall not be used)
2-5-1 (Digraphs should not be used)
2-7-1 (The character sequence /* shall not be used within a C-style comment)
2-7-2 (Sections of code shall not be "commented out" using C-style comments)
2-7-3 (Sections of code should not be "commented out" using C++ comments)
2-10-1 (Different identifiers shall be typographically unambiguous)
2-10-2 (Identifiers declared in an inner scope shall not hide an identifier declared in an outer scope)
2-10-3 (A typedef name (including qualification, if any) shall be a unique identifier)
2-10-4 (A class, union or enum name (including qualification, if any) shall be a unique identifier)
2-10-5 (The identifier name of a non-member object or function with static storage duration should not be reused)
2-10-6 (If an identifier refers to a type, it shall not also refer to an object or a function in the same scope)
2-13-1 (Only those escape sequences that are defined in ISO/IEC 14882:2003 shall be used)
2-13-2 (Octal constants (other than zero) and octal escape sequences (other than "\0") shall not be used)
2-13-3 (A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type)
2-13-4 (Literal suffixes shall be upper case)
2-13-5 (Narrow and wide string literals shall not be concatenated)
3-1-1 (It shall be possible to include any header file in multiple translation units without violating the One Definition Rule)
3-1-2 (Functions shall not be declared at block scope)
3-1-3 (When an array is declared, its size shall either be stated explicitly or defined implicitly by initialization)
3-2-1 (All declarations of an object or function shall have compatible types)
3-2-2 (The One Definition Rule shall not be violated)
3-2-3 (A type, object or function that is used in multiple translation units shall be declared in one and only one file)
3-2-4 (An identifier with external linkage shall have exactly one definition)
3-3-1 (Objects or functions with external linkage shall be declared in a header file)
3-3-2 (If a function has internal linkage then all re-declarations shall include the static storage class specifier)
3-4-1 (An identifier declared to be an object or type shall be defined in a block that minimizes its visibility)
3-9-1 (The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all decl
3-9-2 (typedefs that indicate size and signedness should be used in place of the basic numerical types)
3-9-3 (The underlying bit representations of floating-point values shall not be used)
4-5-1 (Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the
equality operators == and !=, the unary & operator, and the conditional operator)
4-5-2 (Expressions with type enum shall not be used as operands to built- in operators other than the subscript operator [ ], the
equality operators == and !=, the unary & operator, and the relational operators <, <=, >, >=)
4-5-3 (Expressions with type (plain) char and wchar_t shall not be used as operands to built-in operators other than the assign
operators == and !=, and the unary & operator)
4-10-1 (NULL shall not be used as an integer value)
4-10-2 (Literal zero (0) shall not be used as the null-pointer-constant)
5-0-1 (The value of an expression shall be the same under any order of evaluation that the standard permits)
5-0-2 (Limited dependence should be placed on C++ operator precedence rules in expressions)
5-0-3 (A cvalue expression shall not be implicitly converted to a different underlying type)
5-0-4 (An implicit integral conversion shall not change the signedness of the underlying type)
5-0-5 (There shall be no implicit floating-integral conversions)
5-0-6 (An implicit integral or floating-point conversion shall not reduce the size of the underlying type)
5-0-7 (There shall be no explicit floating-integral conversions of a cvalue expression)
5-0-8 (An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expression)
5-0-9 (An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expression)
5-0-10 (If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short
cast to the underlying type of the operand)
5-0-11 (The plain char type shall only be used for the storage and use of character values)
5-0-12 (signed char and unsigned char type shall only be used for the storage and use of numeric values)
5-0-13 (The condition of an if-statement and the condition of an iteration- statement shall have type bool)
5-0-14 (The first operand of a conditional-operator shall have type bool)
5-0-15 (Array indexing shall be the only form of pointer arithmetic)
5-0-16 (A pointer operand and any pointer resulting from pointer arithmetic using that operand shall both address elements of
5-0-17 (Subtraction between pointers shall only be applied to pointers that address elements of the same array)
5-0-18 (>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same array)
5-0-19 (The declaration of objects shall contain no more than two levels of pointer indirection)
5-0-20 (Non-constant operands to a binary bitwise operator shall have the same underlying type)
5-0-21 (Bitwise operators shall only be applied to operands of unsigned underlying type)
5-2-1 (Each operand of a logical && or || shall be a postfix - expression)
5-2-2 (A pointer to a virtual base class shall only be cast to a pointer to a derived class by means of dynamic_cast)
5-2-3 (Casts from a base class to a derived class should not be performed on polymorphic types)
5-2-4 (C-style casts (other than void casts) and functional notation casts (other than explicit constructor calls) shall not be used
5-2-5 (A cast shall not remove any const or volatile qualification from the type of a pointer or reference)
5-2-6 (A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function type)
5-2-7 (An object with pointer type shall not be converted to an unrelated pointer type, either directly or indirectly)
5-2-8 (An object with integer type or pointer to void type shall not be converted to an object with pointer type)
5-2-9 (A cast should not convert a pointer type to an integral type)
5-2-10 (The increment ( ++ ) and decrement ( -- ) operators should not be mixed with other operators in an expression)
5-2-11 (The comma operator, && operator and the || operator shall not be overloaded)
5-2-12 (An identifier with array type passed as a function argument shall not decay to a pointer)
5-3-1 (Each operand of the ! operator, the logical && or the logical || operators shall have type bool)
5-3-2 (The unary minus operator shall not be applied to an expression whose underlying type is unsigned)
5-3-3 (The unary & operator shall not be overloaded)
5-3-4 (Evaluation of the operand to the sizeof operator shall not contain side effects)
5-8-1 (The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying typ
5-14-1 (The right hand operand of a logical && or || operator shall not contain side effects)
5-17-1 (The semantic equivalence between a binary operator and its assignment operator form shall be preserved)
5-18-1 (The comma operator shall not be used)
5-19-1 (Evaluation of constant unsigned integer expressions should not lead to wrap-around)
6-2-1 (Assignment operators shall not be used in sub-expressions)
6-2-2 (Floating-point expressions shall not be directly or indirectly tested for equality or inequality)
6-2-3 (Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided th
null statement is a white - space character)
6-3-1 (The statement forming the body of a switch, while, do ... while or for statement shall be a compound statement)
6-4-1 (An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a
statement)
6-4-2 (All if ... else if constructs shall be terminated with an else clause)
6-4-3 (A switch statement shall be a well-formed switch statement)
6-4-4 (A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch stateme
6-4-5 (An unconditional throw or break statement shall terminate every non - empty switch-clause)
6-4-6 (The final clause of a switch statement shall be the default-clause)
6-4-7 (The condition of a switch statement shall not have bool type)
6-4-8 (Every switch statement shall have at least one case-clause)
6-5-1 (A for loop shall contain a single loop-counter which shall not have floating type)
6-5-2 (If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <
6-5-3 (The loop-counter shall not be modified within condition or statement)
6-5-4 (The loop-counter shall be modified by one of: --, ++, -=n, or +=n ; where n remains constant for the duration of the loop)
6-5-5 (A loop-control-variable other than the loop-counter shall not be modified within condition or expression)
6-5-6 (A loop-control-variable other than the loop-counter which is modified in statement shall have type bool)
6-6-1 (Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statemen
6-6-2 (The goto statement shall jump to a label declared later in the same function body)
6-6-3 (The continue statement shall only be used within a well-formed for loop)
6-6-4 (For any iteration statement there shall be no more than one break or goto statement used for loop termination)
6-6-5 (A function shall have a single point of exit at the end of the function)
7-1-1 (A variable which is not modified shall be const qualified)
7-1-2 (A pointer or reference parameter in a function shall be declared as pointer to const or reference to const if the correspo
7-2-1 (An expression with enum underlying type shall only have values corresponding to the enumerators of the enumeration)
7-3-1 (The global namespace shall only contain main, namespace declarations and extern "C" declarations)
7-3-2 (The identifier main shall not be used for a function other than the global function main)
7-3-3 (There shall be no unnamed namespaces in header files)
7-3-4 (using-directives shall not be used)
7-3-5 (Multiple declarations for an identifier in the same namespace shall not straddle a using-declaration for that identifier)
7-3-6 (using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used i
7-4-1 (All usage of assembler shall be documented)
7-4-2 (Assembler instructions shall only be introduced using the asm declaration)
7-4-3 (Assembly language shall be encapsulated and isolated)
7-5-1 (A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the fu
7-5-2 (The address of an object with automatic storage shall not be assigned to another object that may persist after the first o
7-5-3 (A function shall not return a reference or a pointer to a parameter that is passed by reference or const reference)
7-5-4 (Functions should not call themselves, either directly or indirectly)
8-0-1 (An init-declarator-list or a member-declarator-list shall consist of a single init-declarator or member-declarator respective
8-3-1 (Parameters in an overriding virtual function shall either use the same default arguments as the function they override, o
arguments)
8-4-1 (Functions shall not be defined using the ellipsis notation)
8-4-2 (The identifiers used for the parameters in a re-declaration of a function shall be identical to those in the declaration)
8-4-3 (All exit paths from a function with non- void return type shall have an explicit return statement with an expression)
8-4-4 (A function identifier shall either be used to call the function or it shall be preceded by &)
8-5-1 (All variables shall have a defined value before they are used)
8-5-2 (Braces shall be used to indicate and match the structure in the non- zero initialization of arrays and structures)
8-5-3 (In an enumerator list, the = construct shall not be used to explicitly initialize members other than the first, unless all item
9-3-1 (const member functions shall not return non-const pointers or references to class-data)
9-3-2 (Member functions shall not return non-const handles to class-data)
9-3-3 (If a member function can be made static then it shall be made static, otherwise if it can be made const then it shall be m
9-5-1 (Unions shall not be used)
9-6-1 (When the absolute positioning of bits representing a bit-field is required, then the behaviour and packing of bit-fields sha
9-6-2 (Bit-fields shall be either bool type or an explicitly unsigned or signed integral type)
9-6-3 (Bit-fields shall not have enum type)
9-6-4 (Named bit-fields with signed integer type shall have a length of more than one bit)
10-1-1 (Classes should not be derived from virtual bases)
10-1-2 (A base class shall only be declared virtual if it is used in a diamond hierarchy)
10-1-3 (An accessible base class shall not be both virtual and non-virtual in the same hierarchy)
10-2-1 (All accessible entity names within a multiple inheritance hierarchy should be unique)
10-3-1 (There shall be no more than one definition of each virtual function on each path through the inheritance hierarchy)
10-3-2 (Each overriding virtual function shall be declared with the virtual keyword)
10-3-3 (A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtual)
11-0-1 (Member data in non- POD class types shall be private)
12-1-1 (An object's dynamic type shall not be used from the body of its constructor or destructor)
12-1-2 (All constructors of a class should explicitly call a constructor for all of its immediate base classes and all virtual base cl
12-1-3 (All constructors that are callable with a single argument of fundamental type shall be declared explicit)
12-8-1 (A copy constructor shall only initialize its base classes and the non- static members of the class of which it is a membe
12-8-2 (The copy assignment operator shall be declared protected or private in an abstract class)
14-5-1 (A non-member generic function shall only be declared in a namespace that is not an associated namespace)
14-5-2 (A copy constructor shall be declared when there is a template constructor with a single parameter that is a generic par
14-5-3 (A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a
14-6-1 (In a class template with a dependent base, any name that may be found in that dependent base shall be referred to us
14-6-2 (The function chosen by overload resolution shall resolve to a function declared previously in the translation unit)
14-7-1 (All class templates, function templates, class template member functions and class template static members shall be i
14-7-2 (For any given template specialization, an explicit instantiation of the template with the template-arguments used in the
program ill-formed)
14-7-3 (All partial and explicit specializations for a template shall be declared in the same file as the declaration of their primar
14-8-1 (Overloaded function templates shall not be explicitly specialized)
14-8-2 (The viable function set for a function call should either contain no function specializations, or only contain function spe
15-0-1 (Exceptions shall only be used for error handling)
15-0-2 (An exception object should not have pointer type)
15-0-3 (Control shall not be transferred into a try or catch block using a goto or a switch statement)
15-1-1 (The assignment-expression of a throw statement shall not itself cause an exception to be thrown)
15-1-2 (NULL shall not be thrown explicitly)
15-1-3 (An empty throw (throw;) shall only be used in the compound- statement of a catch handler)
15-3-1 (Exceptions shall be raised only after start-up and before termination of the program)
15-3-2 (There should be at least one exception handler to catch all otherwise unhandled exceptions)
15-3-3 (Handlers of a function-try-block implementation of a class constructor or destructor shall not reference non-static mem
15-3-4 (Each exception explicitly thrown in the code shall have a handler of a compatible type in all call paths that could lead t
15-3-5 (A class type exception shall always be caught by reference)
15-3-6 (Where multiple handlers are provided in a single try-catch statement or function-try-block for a derived class and some
shall be ordered most-derived to base class)
15-3-7 (Where multiple handlers are provided in a single try-catch statement or function-try-block, any ellipsis (catch-all) handl
15-4-1 (If a function is declared with an exception-specification, then all declarations of the same function (in other translation
same set of type-ids)
15-5-1 (A class destructor shall not exit with an exception)
15-5-2 (Where a function's declaration includes an exception-specification, the function shall only be capable of throwing exce
15-5-3 (The terminate() function shall not be called implicitly)
16-0-1 (#include directives in a file shall only be preceded by other preprocessor directives or comments)
16-0-2 (Macros shall only be #define 'd or #undef 'd in the global namespace)
16-0-3 (#undef shall not be used)
16-0-4 (Function-like macros shall not be defined)
16-0-5 (Arguments to a function-like macro shall not contain tokens that look like preprocessing directives)
16-0-6 (In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is us
16-0-7 (Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined
16-0-8 (If the # token appears as the first token on a line, then it shall be immediately followed by a preprocessing token)
16-1-1 (The defined preprocessor operator shall only be used in one of the two standard forms)
16-1-2 (All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if or #ifdef directive to which they
16-2-1 (The pre-processor shall only be used for file inclusion and include guards)
16-2-2 (C++ macros shall only be used for: include guards, type qualifiers, or storage class specifiers)
16-2-3 (Include guards shall be provided)
16-2-4 (The ', ", /* or // characters shall not occur in a header file name)
16-2-5 (The \ character should not occur in a header file name)
16-2-6 (The #include directive shall be followed by either a <filename> or "filename" sequence)
16-3-1 (There shall be at most one occurrence of the # or ## operators in a single macro definition)
16-3-2 (The # and ## operators should not be used)
16-6-1 (All uses of the #pragma directive shall be documented)
17-0-1 (Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefined)
17-0-2 (The names of standard library macros and objects shall not be reused)
17-0-3 (The names of standard library functions shall not be overridden)
17-0-4 (All library code shall conform to MISRA C++)
17-0-5 (The setjmp macro and the longjmp function shall not be used)
18-0-1 (The C library shall not be used)
18-0-2 (The library functions atof, atoi and atol from library <cstdlib> shall not be used)
18-0-3 (The library functions abort, exit, getenv and system from library <cstdlib> shall not be used)
18-0-4 (The time handling functions of library <ctime> shall not be used)
18-0-5 (The unbounded functions of library <cstring> shall not be used)
18-2-1 (The macro offsetof shall not be used)
18-4-1 (Dynamic heap memory allocation shall not be used)
18-7-1 (The signal handling facilities of <csignal> shall not be used)
19-3-1 (The error indicator errno shall not be used)
27-0-1 (The stream input/output library <cstdio> shall not be used)
Status Tests
fully toolbox/qualkits/do/bugfinder/tests/misracpp/misracpp-0-1-1.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
partly toolbox/qualkits/do/bugfinder/tests/misracpp/misracpp-3-2-2.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
Tests Status
toolbox/qualkits/do/bugfinder/tests/misracpp/misracpp-18-0-1.cpp fully
toolbox/qualkits/do/bugfinder/tests/misracpp/misracpp-3-2-2.cpp partly
Misra C++
18-0-1 (The C library shall not be used)
15-3-6 (Where multiple handlers are provided in a single try-catch statement or function-try-block for a derived class and some
2-10-5 (The identifier name of a non-member object or function with static storage duration should not be reused)
16-6-1 (All uses of the #pragma directive shall be documented)
19-3-1 (The error indicator errno shall not be used)
3-2-2 (The One Definition Rule shall not be violated)
2-10-2 (Identifiers declared in an inner scope shall not hide an identifier declared in an outer scope)
3-9-1 (The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all decl
12-1-2 (All constructors of a class should explicitly call a constructor for all of its immediate base classes and all virtual base cl
8-0-1 (An init-declarator-list or a member-declarator-list shall consist of a single init-declarator or member-declarator respective
7-5-1 (A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the fu
6-6-1 (Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statemen
5-2-12 (An identifier with array type passed as a function argument shall not decay to a pointer)
9-3-1 (const member functions shall not return non-const pointers or references to class-data)
16-1-2 (All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if or #ifdef directive to which they
5-3-1 (Each operand of the ! operator, the logical && or the logical || operators shall have type bool)
6-4-7 (The condition of a switch statement shall not have bool type)
14-5-3 (A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a
8-5-3 (In an enumerator list, the = construct shall not be used to explicitly initialize members other than the first, unless all item
9-6-3 (Bit-fields shall not have enum type)
4-5-3 (Expressions with type (plain) char and wchar_t shall not be used as operands to built-in operators other than the assign
9-6-4 (Named bit-fields with signed integer type shall have a length of more than one bit)
3-3-2 (If a function has internal linkage then all re-declarations shall include the static storage class specifier)
7-3-2 (The identifier main shall not be used for a function other than the global function main)
10-1-1 (Classes should not be derived from virtual bases)
7-3-5 (Multiple declarations for an identifier in the same namespace shall not straddle a using-declaration for that identifier)
5-2-8 (An object with integer type or pointer to void type shall not be converted to an object with pointer type)
16-0-2 (Macros shall only be #define 'd or #undef 'd in the global namespace)
3-4-1 (An identifier declared to be an object or type shall be defined in a block that minimizes its visibility)
5-0-15 (Array indexing shall be the only form of pointer arithmetic)
2-7-1 (The character sequence /* shall not be used within a C-style comment)
5-2-6 (A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function type)
5-0-12 (signed char and unsigned char type shall only be used for the storage and use of numeric values)
5-2-1 (Each operand of a logical && or || shall be a postfix - expression)
0-1-1 (A project shall not contain unreachable code)
15-5-2 (Where a function's declaration includes an exception-specification, the function shall only be capable of throwing exce
16-0-5 (Arguments to a function-like macro shall not contain tokens that look like preprocessing directives)
14-6-2 (The function chosen by overload resolution shall resolve to a function declared previously in the translation unit)
16-2-3 (Include guards shall be provided)
5-0-7 (There shall be no explicit floating-integral conversions of a cvalue expression)
5-0-20 (Non-constant operands to a binary bitwise operator shall have the same underlying type)
16-2-4 (The ', ", /* or // characters shall not occur in a header file name)
3-1-3 (When an array is declared, its size shall either be stated explicitly or defined implicitly by initialization)
6-2-3 (Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided th
2-13-4 (Literal suffixes shall be upper case)
8-4-3 (All exit paths from a function with non- void return type shall have an explicit return statement with an expression)
8-4-4 (A function identifier shall either be used to call the function or it shall be preceded by &)
5-0-9 (An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expression)
2-13-3 (A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type)
4-5-2 (Expressions with type enum shall not be used as operands to built- in operators other than the subscript operator [ ], the
5-14-1 (The right hand operand of a logical && or || operator shall not contain side effects)
10-2-1 (All accessible entity names within a multiple inheritance hierarchy should be unique)
6-4-8 (Every switch statement shall have at least one case-clause)
8-5-2 (Braces shall be used to indicate and match the structure in the non- zero initialization of arrays and structures)
18-2-1 (The macro offsetof shall not be used)
9-6-2 (Bit-fields shall be either bool type or an explicitly unsigned or signed integral type)
6-4-6 (The final clause of a switch statement shall be the default-clause)
14-5-2 (A copy constructor shall be declared when there is a template constructor with a single parameter that is a generic par
17-0-5 (The setjmp macro and the longjmp function shall not be used)
0-2-1 (An object shall not be assigned to an overlapping object)
12-8-1 (A copy constructor shall only initialize its base classes and the non- static members of the class of which it is a membe
5-18-1 (The comma operator shall not be used)
17-0-2 (The names of standard library macros and objects shall not be reused)
16-3-2 (The # and ## operators should not be used)
6-4-1 (An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a
14-7-3 (All partial and explicit specializations for a template shall be declared in the same file as the declaration of their primar
12-1-3 (All constructors that are callable with a single argument of fundamental type shall be declared explicit)
2-10-3 (A typedef name (including qualification, if any) shall be a unique identifier)
3-2-4 (An identifier with external linkage shall have exactly one definition)
15-3-7 (Where multiple handlers are provided in a single try-catch statement or function-try-block, any ellipsis (catch-all) handl
27-0-1 (The stream input/output library <cstdio> shall not be used)
2-10-4 (A class, union or enum name (including qualification, if any) shall be a unique identifier)
3-2-3 (A type, object or function that is used in multiple translation units shall be declared in one and only one file)
10-3-1 (There shall be no more than one definition of each virtual function on each path through the inheritance hierarchy)
11-0-1 (Member data in non- POD class types shall be private)
5-0-8 (An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expression)
2-13-2 (Octal constants (other than zero) and octal escape sequences (other than "\0") shall not be used)
6-2-2 (Floating-point expressions shall not be directly or indirectly tested for equality or inequality)
14-8-2 (The viable function set for a function call should either contain no function specializations, or only contain function spe
3-1-2 (Functions shall not be declared at block scope)
2-13-5 (Narrow and wide string literals shall not be concatenated)
8-4-2 (The identifiers used for the parameters in a re-declaration of a function shall be identical to those in the declaration)
5-0-1 (The value of an expression shall be the same under any order of evaluation that the standard permits)
1-0-1 (All code shall conform to ISO/IEC 14882:2003 "The C++ Standard Incorporating Technical Corrigendum 1")
6-5-6 (A loop-control-variable other than the loop-counter which is modified in statement shall have type bool)
16-2-5 (The \ character should not occur in a header file name)
5-0-21 (Bitwise operators shall only be applied to operands of unsigned underlying type)
6-5-1 (A for loop shall contain a single loop-counter which shall not have floating type)
16-2-2 (C++ macros shall only be used for: include guards, type qualifiers, or storage class specifiers)
5-19-1 (Evaluation of constant unsigned integer expressions should not lead to wrap-around)
5-0-6 (An implicit integral or floating-point conversion shall not reduce the size of the underlying type)
8-3-1 (Parameters in an overriding virtual function shall either use the same default arguments as the function they override, o
2-5-1 (Digraphs should not be used)
5-0-13 (The condition of an if-statement and the condition of an iteration- statement shall have type bool)
16-0-4 (Function-like macros shall not be defined)
16-0-3 (#undef shall not be used)
5-0-14 (The first operand of a conditional-operator shall have type bool)
0-1-7 (The value returned by a function having a non- void return type that is not an overloaded operator shall always be used
5-2-7 (An object with pointer type shall not be converted to an unrelated pointer type, either directly or indirectly)
0-1-12 (There shall be no unused parameters (named or unnamed) in the set of parameters for a virtual function and all the fu
7-3-4 (using-directives shall not be used)
5-2-9 (A cast should not convert a pointer type to an integral type)
0-1-9 (There shall be no dead code)
7-3-3 (There shall be no unnamed namespaces in header files)
3-1-1 (It shall be possible to include any header file in multiple translation units without violating the One Definition Rule)
14-8-1 (Overloaded function templates shall not be explicitly specialized)
6-2-1 (Assignment operators shall not be used in sub-expressions)
8-4-1 (Functions shall not be defined using the ellipsis notation)
10-3-2 (Each overriding virtual function shall be declared with the virtual keyword)
15-0-2 (An exception object should not have pointer type)
2-13-1 (Only those escape sequences that are defined in ISO/IEC 14882:2003 shall be used)
16-2-1 (The pre-processor shall only be used for file inclusion and include guards)
6-5-2 (If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <
5-0-5 (There shall be no implicit floating-integral conversions)
18-4-1 (Dynamic heap memory allocation shall not be used)
5-0-2 (Limited dependence should be placed on C++ operator precedence rules in expressions)
16-2-6 (The #include directive shall be followed by either a <filename> or "filename" sequence)
6-5-5 (A loop-control-variable other than the loop-counter shall not be modified within condition or expression)
7-4-3 (Assembly language shall be encapsulated and isolated)
5-2-4 (C-style casts (other than void casts) and functional notation casts (other than explicit constructor calls) shall not be used
5-0-10 (If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short
5-2-3 (Casts from a base class to a derived class should not be performed on polymorphic types)
16-0-7 (Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined
10-1-3 (An accessible base class shall not be both virtual and non-virtual in the same hierarchy)
0-1-11 (There shall be no unused parameters (named or unnamed) in non- virtual functions)
5-0-19 (The declaration of objects shall contain no more than two levels of pointer indirection)
2-3-1 (Trigraphs shall not be used)
8-5-1 (All variables shall have a defined value before they are used)
6-3-1 (The statement forming the body of a switch, while, do ... while or for statement shall be a compound statement)
4-5-1 (Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the
15-1-2 (NULL shall not be thrown explicitly)
17-0-1 (Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefined)
6-4-2 (All if ... else if constructs shall be terminated with an else clause)
16-3-1 (There shall be at most one occurrence of the # or ## operators in a single macro definition)
6-4-5 (An unconditional throw or break statement shall terminate every non - empty switch-clause)
12-8-2 (The copy assignment operator shall be declared protected or private in an abstract class)
5-3-4 (Evaluation of the operand to the sizeof operator shall not contain side effects)
7-5-3 (A function shall not return a reference or a pointer to a parameter that is passed by reference or const reference)
6-6-3 (The continue statement shall only be used within a well-formed for loop)
5-2-10 (The increment ( ++ ) and decrement ( -- ) operators should not be mixed with other operators in an expression)
6-6-4 (For any iteration statement there shall be no more than one break or goto statement used for loop termination)
5-3-3 (The unary & operator shall not be overloaded)
7-5-4 (Functions should not call themselves, either directly or indirectly)
18-0-3 (The library functions abort, exit, getenv and system from library <cstdlib> shall not be used)
3-9-3 (The underlying bit representations of floating-point values shall not be used)
18-0-4 (The time handling functions of library <ctime> shall not be used)
15-3-3 (Handlers of a function-try-block implementation of a class constructor or destructor shall not reference non-static mem
10-1-2 (A base class shall only be declared virtual if it is used in a diamond hierarchy)
0-1-10 (Every defined function shall be called at least once)
7-3-6 (using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used i
5-0-18 (>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same array)
9-5-1 (Unions shall not be used)
3-3-1 (Objects or functions with external linkage shall be declared in a header file)
7-3-1 (The global namespace shall only contain main, namespace declarations and extern "C" declarations)
16-0-8 (If the # token appears as the first token on a line, then it shall be immediately followed by a preprocessing token)
5-0-11 (The plain char type shall only be used for the storage and use of character values)
15-5-1 (A class destructor shall not exit with an exception)
0-1-2 (A project shall not contain infeasible paths)
5-2-2 (A pointer to a virtual base class shall only be cast to a pointer to a derived class by means of dynamic_cast)
16-0-6 (In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is us
14-6-1 (In a class template with a dependent base, any name that may be found in that dependent base shall be referred to us
16-0-1 (#include directives in a file shall only be preceded by other preprocessor directives or comments)
7-4-2 (Assembler instructions shall only be introduced using the asm declaration)
5-2-5 (A cast shall not remove any const or volatile qualification from the type of a pointer or reference)
5-0-3 (A cvalue expression shall not be implicitly converted to a different underlying type)
6-5-4 (The loop-counter shall be modified by one of: --, ++, -=n, or +=n ; where n remains constant for the duration of the loop)
6-5-3 (The loop-counter shall not be modified within condition or statement)
5-0-4 (An implicit integral conversion shall not change the signedness of the underlying type)
15-0-3 (Control shall not be transferred into a try or catch block using a goto or a switch statement)
10-3-3 (A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtual)
2-10-1 (Different identifiers shall be typographically unambiguous)
3-9-2 (typedefs that indicate size and signedness should be used in place of the basic numerical types)
18-0-5 (The unbounded functions of library <cstring> shall not be used)
15-3-2 (There should be at least one exception handler to catch all otherwise unhandled exceptions)
18-0-2 (The library functions atof, atoi and atol from library <cstdlib> shall not be used)
15-3-5 (A class type exception shall always be caught by reference)
2-10-6 (If an identifier refers to a type, it shall not also refer to an object or a function in the same scope)
3-2-1 (All declarations of an object or function shall have compatible types)
6-6-5 (A function shall have a single point of exit at the end of the function)
5-3-2 (The unary minus operator shall not be applied to an expression whose underlying type is unsigned)
15-4-1 (If a function is declared with an exception-specification, then all declarations of the same function (in other translation
18-7-1 (The signal handling facilities of <csignal> shall not be used)
7-5-2 (The address of an object with automatic storage shall not be assigned to another object that may persist after the first o
5-8-1 (The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying typ
12-1-1 (An object's dynamic type shall not be used from the body of its constructor or destructor)
16-1-1 (The defined preprocessor operator shall only be used in one of the two standard forms)
9-3-2 (Member functions shall not return non-const handles to class-data)
5-2-11 (The comma operator, && operator and the || operator shall not be overloaded)
6-6-2 (The goto statement shall jump to a label declared later in the same function body)
6-4-4 (A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch stateme
6-4-3 (A switch statement shall be a well-formed switch statement)
15-1-3 (An empty throw (throw;) shall only be used in the compound- statement of a catch handler)
JSF
001 (Any one function (or method) will contain no more than 200 logical source lines of code (L-SLOCs))
002 (There shall not be any self-modifying code)
003 (All functions shall have a cyclomatic complexity number of 20 or less)
004 (To break a "should" rule, the following approval must be received by the developer: approval from the software engineeri
005 (To break a "will" or a "shall" rule, the following approvals must be received by the developer: approval from the software e
lead; approval from the software product manager.)
006 (Each deviation from a "shall" rule shall be documented in the file that contains the deviation). Deviations from this rule sh
allowed, AV Rule 5 notwithstanding.)
007 (Approval will not be required for a deviation from a "shall" or "will" rule that complies with an exception specified by that ru
008 (All code shall conform to ISO/IEC 14882:2002(E) standard C++)
009 (Only those characters specified in the C++ basic source character set will be used.)
010 (Values of character types will be restricted to a defined and documented subset of ISO 10646-1.)
011 (Trigraphs will not be used.)
012 (The following digraphs will not be used: "<%", "%>", "<:", ":>", %:, %:%:.)
013 (Multi-byte characters and wide string literals will not be used.)
014 (Literal suffixes shall use uppercase rather than lowercase letters.)
015 (VERIFIER Provision shall be made for run-time checking (defensive programming).)
016 (Only DO-178C level A certifiable or SEAL 1 C/C++ libraries shall be used with safety-critical (i.e. SEAL 1) code)
017 (The error indicator errno shall not be used.)
018 (The macro offsetof, in library <stddef.h>, shall not be used.)
019 (<locale.h> and the setlocale function shall not be used.)
020 (The setjmp macro and the longjmp function shall not be used.)
021 (The signal handling facilities of <signal.h> shall not be used.)
022 (The input/output library <stdio.h> shall not be used)
023 (The library functions atof, atoi and atol from library <stdlib.h> shall not be used.)
024 (The library functions abort, exit, getenv and system from library <stdlib.h> shall not be used.)
025 (The time handling functions of library <time.h> shall not be used.)
026 (Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include.)
027 (#ifndef, #define and #endif will be used to prevent multiple inclusions of the same header file. Other techniques to preven
multiple inclusions of header files will not be used.)
028 (The #ifndef and #endif pre-processor directives will only be used as defined in AV Rule 27 to prevent multiple inclusions
same header file.)
029 (The #define pre-processor directive shall not be used to create inline macros. Inline functions shall be used instead.)
030 (The #define pre-processor directive shall not be used to define constant values. Instead, the const qualifier shall be appli
variable declarations to specify constant values.)
031 (The #define pre-processor directive will only be used as part of the technique to prevent multiple inclusions of the same h
032 (The #include pre-processor directive will only be used to include header (*.h) files.)
033 (The #include directive shall use the <filename.h> notation to include header files.)
034 (Header files should contain logically related declarations only.)
035 (A header file will contain a mechanism that prevents multiple inclusions of itself)
036 (Compilation dependencies should be minimized when possible.)
037 (Header (include) files should include only those header files that are required for them to successfully compile.)
038 (Declarations of classes that are only accessed via pointers (*) or references (&) should be supplied by forward headers th
only forward declarations.)
039 (Header files (*.h) will not contain non-const variable definitions or function definitions.)
040 (Every implementation file shall include the header files that uniquely define the inline functions, types, and templates use
041 (Source lines will be kept to a length of 120 characters or less.)
042 (Each expression-statement will be on a separate line.)
043 (Tabs should be avoided.)
044 (All indentations will be at least two spaces and be consistent within the same source file.)
045 (All words in an identifier will be separated by the '_' character.)
046 (User-specified identifiers (internal and external) will not rely on significance of more than 64 characters.)
047 (Identifiers will not begin with the underscore character '_'.)
048 (Identifiers will not differ by:)
049 (All acronyms in an identifier will be composed of uppercase letters.)
050 (The first word of the name of a class, structure, namespace, enumeration, or type created with typedef will begin with an
letter. All others letters will be lowercase)
051 (All letters contained in function and variables names will be composed entirely of lowercase letters.)
052 (Identifiers for constant and enumerator values shall be lowercase.)
053 (Header files will always have file name extension of ".h".)
053.1 (The following character sequences shall not appear in header file names: ', \, /*, //, or ".)
054 (Implementation files will always have a file name extension of ".cpp".)
055 (The name of a header file should reflect the logical entity for which it provides declarations.)
056 (The name of an implementation file should reflect the logical entity for which it provides definitions and have a ".cpp" exte
name will normally be identical to the header file that provides the corresponding declarations.))
057 (The public, protected, and private sections of a class will be declared in that order.)
058 (When declaring and defining functions with more than two parameters, the leading parenthesis and the first argument wil
on the same line as the function name. Each additional argument will be written on a separate line (with the closing parenthes
after the last argument).)
059 (The statements forming the body of an if, else if, else, while, do ... while or for statement shall always be enclosed in brac
the braces form an empty block.)
060 (Braces ("{}") which enclose a block will be placed in the same column, on separate lines directly before and after the bloc
061 (Braces ("{}") which enclose a block will have nothing else on the line except comments.)
062 (The dereference operator '*' and the address-of operator '&' will be directly connected with the type-specifier.)
063 (Spaces will not be used around '.' or '->', nor between unary operators and operands.)
064 (A class interface should be complete and minimal.)
065 (A structure should be used to model an entity that does not require an invariant.)
066 (A class should be used to model an entity that maintains an invariant.)
067 (Public and protected data should only be used in structs - not classes.)
068 (Unneeded implicitly generated member functions shall be explicitly disallowed.)
069 (A member function that does not affect the state of an object (its instance variables) will be declared const.)
070 (A class will have friends only when a function or object requires access to the private elements of the class, but is unable
member of the class for logical or efficiency reasons. N)
070.1 (An object shall not be improperly used before its lifetime begins or after its lifetime ends.)
071 (Calls to an externally visible operation of an object, other than its constructors, shall not be allowed until the object has be
initialized.)
071.1 (A class's virtual functions shall not be invoked from its destructor or any of its constructors.)
072 (The invariant for a class should be: a part of the postcondition of every class constructor; a part of the precondition of the
destructor (if any); a part of the precondition and postcondition of every other publicly accessible operation.)
073 (Unnecessary default constructors shall not be defined.)
074 (Initialization of nonstatic class members will be performed through the member initialization list rather than through assign
the body of a constructor.)
075 (Members of the initialization list shall be listed in the order in which they are declared in the class.)
076 (A copy constructor and an assignment operator shall be declared for classes that contain pointers to data items or nontriv
destructors.)
077 (A copy constructor shall copy all data members and bases that affect the class invariant.)
077.1 (The definition of a member function shall not contain default arguments that produce a signature identical to that of the
declared copy constructor for the corresponding class/structure.)
078 (All base classes with a virtual function shall define a virtual destructor.)
079 (All resources acquired by a class shall be released by the class's destructor.)
080 (The default copy and assignment operators will be used for classes when those operators offer reasonable semantics)
081 (The assignment operator shall handle self-assignment correctly.)
082 (An assignment operator shall return a reference to *this.)
083 (An assignment operator shall assign all data members and bases that affect the class invariant (a data element represen
cache, for example, would not need to be copied).)
084 (Operator overloading will be used sparingly and in a conventional manner.)
085 (When two operators are opposites (such as == and !=), both will be defined and one will be defined in terms of the other.
086 (Concrete types should be used to represent simple independent concepts.)
087 (Hierarchies should be based on abstract classes.)
088 (Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plu
one protected implementation.)
088.1 (A stateful virtual base shall be explicitly declared in each derived class that accesses it.)
089 (A base class shall not be both virtual and non-virtual in the same hierarchy.)
090 (Heavily used interfaces should be minimal, general and abstract.)
091 (Public inheritance will be used to implement "is-a" relationships.)
092 (A subtype (publicly derived classes) will conform to the following guidelines with respect to all classes ...)
093 ("has-a" or "is-implemented-in-terms-of" relationships will be modeled through membership or non-public inheritance.)
094 (An inherited nonvirtual function shall not be redefined in a derived class.)
095 (An inherited default parameter shall never be redefined.)
096 (Arrays shall not be treated polymorphically.)
097 (Arrays shall not be used in interface.)
097.1 (Neither operand of an equality operator (== or !=) shall be a pointer to a virtual member function.)
098 (Every nonlocal name, except main(), should be placed in some namespace.)
099 (Namespaces will not be nested more than two levels deep.)
100 (Elements from a namespace should be selected as follows: using declaration or explicit qualification for few (approximate
names, using directive for many names.)
101 (Templates shall be reviewed as follows: with respect to the template in isolation considering assumptions or requirement
its arguments. with respect to all functions instantiated by actual arguments.)
102 (Template tests shall be created to cover all actual template instantiations.)
103 (Constraint checks should be applied to template arguments.)
104 (A template specialization shall be declared before its use.)
105 (A template definition's dependence on its instantiation contexts should be minimized.)
106 (Specializations for pointer types should be made where appropriate.)
107 (Functions shall always be declared at file scope.)
108 (Functions with variable numbers of arguments shall not be used.)
109 (A function definition should not be placed in a class specification unless the function is intended to be inlined.)
110 (Functions with more than 7 arguments will not be used.)
111 (A function shall not return a pointer or reference to a non-static local object.)
112 (Function return values should not obscure resource ownership.)
113 (Functions will have a single exit point.)
114 (All exit points of value-returning functions shall be through return statements.)
115 (If a function returns error information, then that error information will be tested.)
116 (Small, concrete-type arguments (two or three words in size) should be passed by value if changes made to formal param
should not be reflected in the calling function.)
117 (Arguments should be passed by reference if NULL values are not possible.)
117.1 (An object should be passed as const T& if the function should not change the value of the object.)
117.2 (An object should be passed as T& if the function may change the value of the object.)
118 (Arguments should be passed via pointers if NULL values are possible.)
118.1 (An object should be passed as const T* if its value should not be modified.)
118.2 (An object should be passed as T* if its value may be modified.)
119 (Functions shall not call themselves, either directly or indirectly (i.e. recursion shall not be allowed).)
120 (Overloaded operations or methods should form families that use the same semantics, share the same name, have the sa
purpose, and that are differentiated by formal parameters.)
121 (Only functions with 1 or 2 statements should be considered candidates for inline functions.)
122 (Trivial accessor and mutator functions should be inlined.)
123 (The number of accessor and mutator functions should be minimized.)
124 (Trivial forwarding functions should be inlined.)
125 (Unnecessary temporary objects should be avoided.)
126 (Only valid C++ style comments (//) shall be used.)
127 (Code that is not used (commented out) shall be deleted.)
128 (Comments that document actions or sources (e.g. tables, figures, paragraphs, etc.) outside of the file being documented
allowed)
129 (Comments in header files should describe the externally visible behavior of the functions or classes being documented.)
130 (The purpose of every line of executable code should be explained by a comment, although one comment may describe m
one line of code.)
131 (One should avoid stating in comments what is better stated in code.)
132 (Each variable declaration, typedef, enumeration value, and structure member will be commented.)
133 (Every source file will be documented with an introductory comment that provides information on the file name, its content
program-required information.)
134 (Assumptions (limitations) made by functions should be documented in the function's preamble.)
135 (Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identi
136 (Declarations should be at the smallest feasible scope.)
137 (All declarations at file scope should be static where possible.)
138 (Identifiers shall not simultaneously have both internal and external linkage in the same translation unit.)
139 (External objects will not be declared in more than one file.)
140 (The register storage class specifier shall not be used.)
141 (A class, structure, or enumeration will not be declared in the definition of its type.)
142 (VERIFIER All variables shall be initialized before use.)
143 (Variables will not be introduced until they can be initialized with meaningful values. N)
144 (Braces shall be used to indicate and match the structure in the non-zero initialization of arrays and structures.)
145 (In an enumerator list, the '=' construct shall not be used to explicitly initialize members other than the first, unless all items
explicitly initialized.)
146 (Floating point implementations shall comply with a defined floating point standard.)
147 (The underlying bit representations of floating point numbers shall not be used in any way by the programmer.)
148 (Enumeration types shall be used instead of integer types (and constants) to select from a limited series of choices)
149 (Octal constants (other than zero) shall not be used.)
150 (Hexadecimal constants will be represented using all uppercase letters.)
151 (Numeric values in code will not be used; symbolic values will be used instead.)
151.1 (A string literal shall not be modified.)
152 (Multiple variable declarations shall not be allowed on the same line.)
153 (Unions shall not be used.)
154 (Bit-fields shall have explicitly unsigned integral or enumeration types only)
155 (Bit-fields will not be used to pack data into a word for the sole purpose of saving space.)
156 (All the members of a structure (or class) shall be named and shall only be accessed via their names.)
157 (The right hand operand of a && or || operator shall not contain side effects.)
158 (The operands of a logical && or || shall be parenthesized if the operands contain binary operators.)
159 (Operators ||, &&, and unary & shall not be overloaded.)
160 (An assignment expression shall be used only as the expression in an expression statement.)
162 (Signed and unsigned values shall not be mixed in arithmetic or comparison operations)
163 (Unsigned arithmetic shall not be used.)
164.1 (The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the left-hand ope
(inclusive).)
164 (The left-hand operand of a right-shift operator shall not have a negative value.)
165 (The unary minus operator shall not be applied to an unsigned expression.)
166 (The sizeof operator will not be used on expressions that contain side effects.)
167 (The implementation of integer division in the chosen compiler shall be determined, documented and taken into account.)
168 (The comma operator shall not be used.)
169 (Pointers to pointers should be avoided when possible.)
170 (More than 2 levels of pointer indirection shall not be used.)
171 (Relational operators shall not be applied to pointer types except where both operands are of the same type and point to:
object, the same function, members of the same object, or elements of the same array (including one past the end of the same
173 (The address of an object with automatic storage shall not be assigned to an object which persists after the object has cea
exist.)
174 (VERIFIER The null pointer shall not be de-referenced.)
175 (A pointer shall not be compared to NULL or be assigned NULL; use plain 0 instead.)
176 (A typedef will be used to simplify program syntax when declaring function pointers.)
177 (User-defined conversion functions should be avoided.)
178 (Down casting (casting from base to derived class) shall only be allowed through one of the following mechanism: Virtual
that act like dynamic casts (most likely useful in relatively simple cases). Use of the visitor (or similar) pattern (most likely usefu
complicated cases).)
179 (A pointer to a virtual base class shall not be converted to a pointer to a derived class.)
180 (Implicit conversions that may result in a loss of information shall not be used.)
181 (Redundant explicit casts will not be used.)
182 (Type casting from any type to or from pointers shall not be used.)
183 (Every possible measure should be taken to avoid type casting.)
184 (Floating point numbers shall not be converted to integers unless such a conversion is a specified algorithmic requiremen
necessary for a hardware interface.)
185 (C++ style casts (const_cast, reinterpret_cast, and static_cast) shall be used instead of the traditional C-style casts.)
186 (There shall be no unreachable code.)
187 (All non-null statements shall potentially have a side-effect.)
188 (Labels will not be used, except in switch statements.)
189 (The goto statement shall not be used.)
190 (The continue statement shall not be used.)
191 (The break statement shall not be used (except to terminate the cases of a switch statement).)
192 (All if, else if constructs will contain either a final else clause or a comment indicating why a final else clause is not necess
193 (Every non-empty case clause in a switch statement shall be terminated with a break statement.)
194 (All switch statements that do not intend to test for every enumeration value shall contain a final default clause.)
195 (A switch expression will not represent a Boolean value.)
196 (Every switch statement will have at least two cases and a potential default.)
197 (Floating point variables shall not be used as loop counters.)
198 (The initialization expression in a for loop will perform no actions other than to initialize the value of a single for loop param
199 (The increment expression in a for loop will perform no action other than to change a single loop parameter to the next va
loop.)
200 (Null initialize or increment expressions in for loops will not be used; a while loop will be used instead.)
201 (Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.)
202 (Floating point variables shall not be tested for exact equality or inequality.)
203 (Evaluation of expressions shall not lead to overflow/underflow.)
204 (A single operation with side-effects shall only be used in the following contexts:)
205 (The volatile keyword shall not be used unless directly interfacing with hardware.)
206 (Allocation/deallocation from/to the free store (heap) shall not occur after initialization.)
207 (Unencapsulated global data will be avoided.)
208 (C++ exceptions shall not be used.)
209 (The basic types of int, short, long, float and double shall not be used, but specific-length equivalents should be typedef'd
accordingly for each compiler, and these type names used in the code.)
210 (Algorithms shall not make assumptions concerning how data is represented in memory.)
210.1 (Algorithms shall not make assumptions concerning the order of allocation of nonstatic data members separated by an a
specifier.)
211 (Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses.)
212 (Underflow or overflow functioning shall not be depended on in any special way.)
213 (No dependence shall be placed on C++'s operator precedence rules, below arithmetic operators, in expressions.)
214 (Assuming that non-local static objects, in separate translation units, are initialized in a special order shall not be done.)
215 (Pointer arithmetic will not be used.)
216 (Programmers should not attempt to prematurely optimize code.)
217 (Compile-time and link-time errors should be preferred over run-time errors.)
218 (Compiler warning levels will be set in compliance with project policies.)
219 (All tests applied to a base class interface shall be applied to all derived class interfaces as well. If the derived class poses
postconditions/invariants, then the new postconditions /invariants shall be substituted in the derived class tests.)
220 (Structural coverage algorithms shall be applied against flattened classes.)
221 (Structural coverage of a class within an inheritance hierarchy containing virtual functions shall include testing every possi
resolution for each set of identical polymorphic references.)
Status Tests
fully toolbox/qualkits/do/bugfinder/tests/jsf/jsf-001.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
partly toolbox/qualkits/do/bugfinder/tests/jsf/jsf-031.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
fully toolbox/qualkits/do/bugfinder/tests/jsf/jsf-053-1.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
partly toolbox/qualkits/do/bugfinder/tests/jsf/jsf-071-1.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
partly toolbox/qualkits/do/bugfinder/tests/jsf/jsf-151-1.cpp
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
notImp EMPTY
Tests Status
toolbox/qualkits/do/bugfinder/tests/jsf/jsf-074.cpp fully
toolbox/qualkits/do/bugfinder/tests/jsf/jsf-186.cpp partly
toolbox/qualkits/do/bugfinder/tests/jsf/jsf-053-1.cpp fully
toolbox/qualkits/do/bugfinder/tests/jsf/jsf-151-1.cpp partly
toolbox/qualkits/do/bugfinder/tests/jsf/jsf-071-1.cpp partly
JSF
074 (Initialization of nonstatic class members will be performed through the member initialization list rather than through assign
008 (All code shall conform to ISO/IEC 14882:2002(E) standard C++)
150 (Hexadecimal constants will be represented using all uppercase letters.)
181 (Redundant explicit casts will not be used.)
157 (The right hand operand of a && or || operator shall not contain side effects.)
186 (There shall be no unreachable code.)
001 (Any one function (or method) will contain no more than 200 logical source lines of code (L-SLOCs))
159 (Operators ||, &&, and unary & shall not be overloaded.)
188 (Labels will not be used, except in switch statements.)
200 (Null initialize or increment expressions in for loops will not be used; a while loop will be used instead.)
033 (The #include directive shall use the <filename.h> notation to include header files.)
053.1 (The following character sequences shall not appear in header file names: ', \, /*, //, or ".)
048 (Identifiers will not differ by:)
099 (Namespaces will not be nested more than two levels deep.)
110 (Functions with more than 7 arguments will not be used.)
162 (Signed and unsigned values shall not be mixed in arithmetic or comparison operations)
046 (User-specified identifiers (internal and external) will not rely on significance of more than 64 characters.)
097 (Arrays shall not be used in interface.)
209 (The basic types of int, short, long, float and double shall not be used, but specific-length equivalents should be typedef'd
041 (Source lines will be kept to a length of 120 characters or less.)
119 (Functions shall not call themselves, either directly or indirectly (i.e. recursion shall not be allowed).)
165 (The unary minus operator shall not be applied to an unsigned expression.)
108 (Functions with variable numbers of arguments shall not be used.)
081 (The assignment operator shall handle self-assignment correctly.)
050 (The first word of the name of a class, structure, namespace, enumeration, or type created with typedef will begin with an
174 (VERIFIER The null pointer shall not be de-referenced.)
173 (The address of an object with automatic storage shall not be assigned to an object which persists after the object has cea
057 (The public, protected, and private sections of a class will be declared in that order.)
025 (The time handling functions of library <time.h> shall not be used.)
088 (Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plu
059 (The statements forming the body of an if, else if, else, while, do ... while or for statement shall always be enclosed in brac
022 (The input/output library <stdio.h> shall not be used)
133 (Every source file will be documented with an introductory comment that provides information on the file name, its content
017 (The error indicator errno shall not be used.)
199 (The increment expression in a for loop will perform no action other than to change a single loop parameter to the next va
148 (Enumeration types shall be used instead of integer types (and constants) to select from a limited series of choices)
151.1 (A string literal shall not be modified.)
197 (Floating point variables shall not be used as loop counters.)
062 (The dereference operator '*' and the address-of operator '&' will be directly connected with the type-specifier.)
190 (The continue statement shall not be used.)
141 (A class, structure, or enumeration will not be declared in the definition of its type.)
019 (<locale.h> and the setlocale function shall not be used.)
040 (Every implementation file shall include the header files that uniquely define the inline functions, types, and templates use
164 (The left-hand operand of a right-shift operator shall not have a negative value.)
163 (Unsigned arithmetic shall not be used.)
047 (Identifiers will not begin with the underscore character '_'.)
096 (Arrays shall not be treated polymorphically.)
208 (C++ exceptions shall not be used.)
035 (A header file will contain a mechanism that prevents multiple inclusions of itself)
098 (Every nonlocal name, except main(), should be placed in some namespace.)
206 (Allocation/deallocation from/to the free store (heap) shall not occur after initialization.)
111 (A function shall not return a pointer or reference to a non-static local object.)
201 (Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.)
116 (Small, concrete-type arguments (two or three words in size) should be passed by value if changes made to formal param
032 (The #include pre-processor directive will only be used to include header (*.h) files.)
097.1 (Neither operand of an equality operator (== or !=) shall be a pointer to a virtual member function.)
158 (The operands of a logical && or || shall be parenthesized if the operands contain binary operators.)
189 (The goto statement shall not be used.)
156 (All the members of a structure (or class) shall be named and shall only be accessed via their names.)
187 (All non-null statements shall potentially have a side-effect.)
075 (Members of the initialization list shall be listed in the order in which they are declared in the class.)
009 (Only those characters specified in the C++ basic source character set will be used.)
151 (Numeric values in code will not be used; symbolic values will be used instead.)
180 (Implicit conversions that may result in a loss of information shall not be used.)
164.1 (The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the left-hand ope
191 (The break statement shall not be used (except to terminate the cases of a switch statement).)
140 (The register storage class specifier shall not be used.)
018 (The macro offsetof, in library <stddef.h>, shall not be used.)
196 (Every switch statement will have at least two cases and a potential default.)
147 (The underlying bit representations of floating point numbers shall not be used in any way by the programmer.)
063 (Spaces will not be used around '.' or '->', nor between unary operators and operands.)
198 (The initialization expression in a for loop will perform no actions other than to initialize the value of a single for loop param
149 (Octal constants (other than zero) shall not be used.)
011 (Trigraphs will not be used.)
135 (Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identi
107 (Functions shall always be declared at file scope.)
023 (The library functions atof, atoi and atol from library <stdlib.h> shall not be used.)
024 (The library functions abort, exit, getenv and system from library <stdlib.h> shall not be used.)
089 (A base class shall not be both virtual and non-virtual in the same hierarchy.)
071.1 (A class's virtual functions shall not be invoked from its destructor or any of its constructors.)
058 (When declaring and defining functions with more than two parameters, the leading parenthesis and the first argument wil
109 (A function definition should not be placed in a class specification unless the function is intended to be inlined.)
051 (All letters contained in function and variables names will be composed entirely of lowercase letters.)
175 (A pointer shall not be compared to NULL or be assigned NULL; use plain 0 instead.)
195 (A switch expression will not represent a Boolean value.)
144 (Braces shall be used to indicate and match the structure in the non-zero initialization of arrays and structures.)
138 (Identifiers shall not simultaneously have both internal and external linkage in the same translation unit.)
060 (Braces ("{}") which enclose a block will be placed in the same column, on separate lines directly before and after the bloc
067 (Public and protected data should only be used in structs - not classes.)
192 (All if, else if constructs will contain either a final else clause or a comment indicating why a final else clause is not necess
015 (VERIFIER Provision shall be made for run-time checking (defensive programming).)
012 (The following digraphs will not be used: "<%", "%>", "<:", ":>", %:, %:%:.)
136 (Declarations should be at the smallest feasible scope.)
027 (#ifndef, #define and #endif will be used to prevent multiple inclusions of the same header file. Other techniques to preven
104 (A template specialization shall be declared before its use.)
213 (No dependence shall be placed on C++'s operator precedence rules, below arithmetic operators, in expressions.)
178 (Down casting (casting from base to derived class) shall only be allowed through one of the following mechanism: Virtual
020 (The setjmp macro and the longjmp function shall not be used.)
083 (An assignment operator shall assign all data members and bases that affect the class invariant (a data element represen
052 (Identifiers for constant and enumerator values shall be lowercase.)
176 (A typedef will be used to simplify program syntax when declaring function pointers.)
171 (Relational operators shall not be applied to pointer types except where both operands are of the same type and point to:
029 (The #define pre-processor directive shall not be used to create inline macros. Inline functions shall be used instead.)
160 (An assignment expression shall be used only as the expression in an expression statement.)
044 (All indentations will be at least two spaces and be consistent within the same source file.)
095 (An inherited default parameter shall never be redefined.)
043 (Tabs should be avoided.)
202 (Floating point variables shall not be tested for exact equality or inequality.)
031 (The #define pre-processor directive will only be used as part of the technique to prevent multiple inclusions of the same h
169 (Pointers to pointers should be avoided when possible.)
205 (The volatile keyword shall not be used unless directly interfacing with hardware.)
003 (All functions shall have a cyclomatic complexity number of 20 or less)
078 (All base classes with a virtual function shall define a virtual destructor.)
076 (A copy constructor and an assignment operator shall be declared for classes that contain pointers to data items or nontriv
077.1 (The definition of a member function shall not contain default arguments that produce a signature identical to that of the
152 (Multiple variable declarations shall not be allowed on the same line.)
184 (Floating point numbers shall not be converted to integers unless such a conversion is a specified algorithmic requiremen
170 (More than 2 levels of pointer indirection shall not be used.)
028 (The #ifndef and #endif pre-processor directives will only be used as defined in AV Rule 27 to prevent multiple inclusions
054 (Implementation files will always have a file name extension of ".cpp".)
082 (An assignment operator shall return a reference to *this.)
053 (Header files will always have file name extension of ".h".)
177 (User-defined conversion functions should be avoided.)
179 (A pointer to a virtual base class shall not be converted to a pointer to a derived class.)
021 (The signal handling facilities of <signal.h> shall not be used.)
026 (Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include.)
215 (Pointer arithmetic will not be used.)
013 (Multi-byte characters and wide string literals will not be used.)
137 (All declarations at file scope should be static where possible.)
068 (Unneeded implicitly generated member functions shall be explicitly disallowed.)
014 (Literal suffixes shall use uppercase rather than lowercase letters.)
193 (Every non-empty case clause in a switch statement shall be terminated with a break statement.)
142 (VERIFIER All variables shall be initialized before use.)
194 (All switch statements that do not intend to test for every enumeration value shall contain a final default clause.)
145 (In an enumerator list, the '=' construct shall not be used to explicitly initialize members other than the first, unless all items
139 (External objects will not be declared in more than one file.)
061 (Braces ("{}") which enclose a block will have nothing else on the line except comments.)
154 (Bit-fields shall have explicitly unsigned integral or enumeration types only)
185 (C++ style casts (const_cast, reinterpret_cast, and static_cast) shall be used instead of the traditional C-style casts.)
153 (Unions shall not be used.)
182 (Type casting from any type to or from pointers shall not be used.)
079 (All resources acquired by a class shall be released by the class's destructor.)
121 (Only functions with 1 or 2 statements should be considered candidates for inline functions.)
126 (Only valid C++ style comments (//) shall be used.)
204 (A single operation with side-effects shall only be used in the following contexts:)
113 (Functions will have a single exit point.)
203 (Evaluation of expressions shall not lead to overflow/underflow.)
114 (All exit points of value-returning functions shall be through return statements.)
030 (The #define pre-processor directive shall not be used to define constant values. Instead, the const qualifier shall be appli
168 (The comma operator shall not be used.)
042 (Each expression-statement will be on a separate line.)
166 (The sizeof operator will not be used on expressions that contain side effects.)
039 (Header files (*.h) will not contain non-const variable definitions or function definitions.)
088.1 (A stateful virtual base shall be explicitly declared in each derived class that accesses it.)
094 (An inherited nonvirtual function shall not be redefined in a derived class.)
ization list rather than through assignment in the body of a constructor.)
de (L-SLOCs))
be used instead.)
han 64 characters.)
gth equivalents should be typedef'd accordingly for each compiler, and these type names used in the code.)
t be allowed).)
eated with typedef will begin with an uppercase letter. All others letters will be lowercase)
hich persists after the object has ceased to exist.)
plus m private implementations, plus at most one protected implementation.)

ment shall always be enclosed in braces, even if the braces form an empty block.)
rmation on the file name, its contents, and any program-required information.)
single loop parameter to the next value for the loop.)

om a limited series of choices)
d with the type-specifier.)
functions, types, and templates used.)

ified in the body of the loop.)
ue if changes made to formal parameters should not be reflected in the calling function.)
mber function.)
ary operators.)
via their names.)
in the class.)
the width in bits of the left-hand operand (inclusive).)
way by the programmer.)
e the value of a single for loop parameter.)
scope, and therefore hide that identifier.)
arenthesis and the first argument will be written on the same line as the function name. Each additional argument will be written on a separ
is intended to be inlined.)
ercase letters.)
of arrays and structures.)

me translation unit.)
nes directly before and after the block.)
why a final else clause is not necessary.)
ader file. Other techniques to prevent the multiple inclusions of header files will not be used.)
ic operators, in expressions.)
of the following mechanism: Virtual functions that act like dynamic casts (most likely useful in relatively simple cases). Use of the visitor (or
s invariant (a data element representing a cache, for example, would not need to be copied).)
s are of the same type and point to: the same object, the same function, members of the same object, or elements of the same array (inclu
unctions shall be used instead.)
e standard permits.)
ent multiple inclusions of the same header file.)
ntain pointers to data items or nontrivial destructors.)

ce a signature identical to that of the implicitly-declared copy constructor for the corresponding class/structure.)
s a specified algorithmic requirement or is necessary for a hardware interface.)
ule 27 to prevent multiple inclusions of the same header file.)
tain a final default clause.)

s other than the first, unless all items are explicitly initialized.)
of the traditional C-style casts.)

ead, the const qualifier shall be applied to variable declarations to specify constant values.)
will be written on a separate line (with the closing parenthesis directly after the last argument).)
ses). Use of the visitor (or similar) pattern (most likely useful in complicated cases).)
s of the same array (including one past the end of the same array).)
Tests
toolbox/qualkits/do/bugfinder/tests/tor-checks/assert.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_delete.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_equal_equal_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_equal_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_file_access_mode_status.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_float_op.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_free.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_int_ptr_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_lock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_network_connect_order.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_plain_char_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_privilege_drop_order.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_ptr_scaling.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_umask.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_unlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bitwise_arith_mix.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bitwise_neg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/breaking_data_encapsulation.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/char_eof_confused.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/character_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/chroot_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/closed_resource_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/constant_object_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_bad_function.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_constant_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_constant_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_algorithm.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_data.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_final.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_predictable_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_predictable_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_weak_cipher.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_weak_mode.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dangerous_permissions.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dangerous_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_length_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_race.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_race_all.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_race_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/deactivated_code.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dead_code.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/deadlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/decl_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/delete_of_void_ptr.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/destroy_locked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_deallocation.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_lock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_resource_close.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_resource_open.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_unlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dtor_not_virtual.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/errno_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/errno_not_checked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/excp_caught_by_value.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/excp_handler_hidden.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/exit_abnormal_handler.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_absorption.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_zero_div.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/freed_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/func_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/func_ptr_absolute_addr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_buffer_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_loop_boundary.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_mem_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/improper_array_init.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_zero_div.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/invalid_memory_assumption.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/invalid_va_list_arg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/local_addr_escape.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/mem_leak.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/mem_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memcmp_padding_data.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memcmp_strings.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memset_invalid_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memset_invalid_value.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_base_assign_op_call.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_copy_ctor_call.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_errno_reset.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_explicit_keyword.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_freed_ptr_reset.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_null_char.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_privilege_drop_check.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_return.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_self_assign_test.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_switch_break.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_switch_case.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_virtual_inheritance.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/more_than_one_statement.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_member.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_ptr_conv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_var.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_positive_vla_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_reentrant_std_return.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_secure_temp_file.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/null_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/null_ptr_arith.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/object_size_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/object_slicing.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/obsolete_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/operator_precedence.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-310-off.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-310-on.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-311-167.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-321-U-off.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-321-U-on.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-340-on-2.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-350-off.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-350-on.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-356-cpp-off.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-356-cpp-on.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-359.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-370-off-2.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-378.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-378-2.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/other_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/out_bound_array.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/out_bound_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/overlapping_assign.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/overlapping_copy.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/partial_override.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/partially_accessed_array.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/pass_by_value.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/path_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/path_traversal.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/ptr_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/ptr_sizeof_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/qualifier_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/rand_seed_constant.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/rand_seed_predictable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/read_only_resource_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/readlink_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/relative_path_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/relative_path_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/resource_leak.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/return_not_checked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/return_not_ref_to_this.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_data_print.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_heap_not_cleared.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_stack_not_cleared.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/setjmp_longjmp_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/shift_neg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/shift_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sign_change.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sizeof_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/std_func_arg_mismatch.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/str_format_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/str_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/string_format.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/strlib_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/strlib_buffer_underflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_array_index.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_env_variable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_external_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_hostid.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_int_division.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_int_mod.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_loop_boundary.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_memory_alloc_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_path_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_path_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_ptr_offset.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_sign_change.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_string.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_string_format.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_vla_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/toctou.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/typedef_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uint_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uint_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uncalled_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unprotected_memory_allocation.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unreachable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_std_crypt.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_str_to_numeric.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unused_parameter.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/useless_if.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/useless_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/var_shadowing.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/virtual_func_hiding.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/vulnerable_prng.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/write_internal_buffer_returned_from_std_func.c
TOR
assert (Assertion)
bad_delete (Invalid deletion of pointer)
bad_equal_equal_use (Invalid use of == operator)
bad_equal_use (Invalid use of = operator)
bad_file_access_mode_status (Bad file access mode or status)
bad_float_op (Invalid use of floating point operation)
bad_free (Invalid free of pointer)
bad_int_ptr_cast (Unsafe conversion between pointer and integer)
bad_lock (Missing unlock)
bad_network_connect_order (Incorrect order of network connection operations)
bad_plain_char_use (Use of plain char type for numeric value)
bad_privilege_drop_order (Bad order of dropping privileges)
bad_ptr_scaling (Incorrect pointer scaling)
bad_umask (Umask used with chmod-style arguments)
bad_unlock (Missing lock)
bitwise_arith_mix (Bitwise and arithmetic operation on a same data)
bitwise_neg (Bitwise operation on negative value)
breaking_data_encapsulation (Return of non-const handle to encapsulated data member)
char_eof_confused (Character value confused with EOF)
character_misuse (Misuse of character value)
chroot_misuse (File manipulation after chroot() without chdir("/"))
closed_resource_use (Use of previously closed resource)
constant_object_write (Writing to const qualified object)
crypto_cipher_bad_function (Inconsistent cipher operations)
crypto_cipher_constant_iv (Constant block cipher initialization vector)
crypto_cipher_constant_key (Constant cipher key)
crypto_cipher_no_algorithm (Missing cipher algorithm)
crypto_cipher_no_data (Missing cipher data to process)
crypto_cipher_no_final (Missing cipher final step)
crypto_cipher_no_iv (Missing block cipher initialization vector)
crypto_cipher_no_key (Missing cipher key)
crypto_cipher_predictable_iv (Predictable block cipher initialization vector)
crypto_cipher_predictable_key (crypto_cipher_predictable_key)
crypto_cipher_weak_cipher (Weak cipher algorithm)
crypto_cipher_weak_mode (Weak cipher mode)
dangerous_permissions (Vulnerable permission assignments)
dangerous_std_func (Use of dangerous standard function)
data_length_mismatch (Mismatch between data length and size)
data_race (Data race)
data_race_all (Data race including atomic operations)
data_race_std_lib (Data race through standard library function call)
deactivated_code (Code deactivated by constant false condition)
dead_code (Dead code)
deadlock (Deadlock)
decl_mismatch (Declaration mismatch)
delete_of_void_ptr (Delete of void pointer)
destroy_locked (Destruction of locked mutex)
double_deallocation (Deallocation of previously deallocated pointer)
double_lock (Double lock)
double_resource_close (Closing previously closed resource)
double_resource_open (Opening previously opened resource)
double_unlock (Double unlock)
dtor_not_virtual (Base class destructor not virtual)
errno_misuse (Misuse of errno)
errno_not_checked (errno not checked)
excp_caught_by_value (Exception caught by value)
excp_handler_hidden (Exception handler hidden by previous handler)
exit_abnormal_handler (Abnormal termination of exit handler)
float_absorption (Absorption of float operand)
float_conv_ovfl (Float conversion overflow)
float_ovfl (Float overflow)
float_std_lib (Invalid use of standard library floating point routine)
float_zero_div (Float division by zero)
freed_ptr (Use of previously freed pointer)
func_cast (Unreliable cast of function pointer)
func_ptr_absolute_addr (Function pointer assigned with absolute address)
hard_coded_buffer_size (Hard-coded buffer size)
hard_coded_loop_boundary (Hard-coded loop boundary)
hard_coded_mem_size (Hard-coded object size used to manipulate memory)
improper_array_init (Improper array initialization)
int_conv_ovfl (Integer conversion overflow)
int_ovfl (Integer overflow)
int_std_lib (Invalid use of standard library integer routine)
int_zero_div (Integer division by zero)
invalid_memory_assumption (Invalid assumptions about memory organization)
invalid_va_list_arg (Invalid va_list argument)
local_addr_escape (Pointer or reference to stack variable leaving scope)
mem_leak (Memory leak)
mem_std_lib (Invalid use of standard library memory routine)
memcmp_padding_data (Memory comparison of padding data)
memcmp_strings (Memory comparison of strings)
memset_invalid_size (Use of memset with size argument zero)
memset_invalid_value (Call to memset family with unintended value)
missing_base_assign_op_call (Base class assignment operator not called)
missing_copy_ctor_call (Copy constructor not called in initialization list)
missing_errno_reset (Missing errno reset)
missing_explicit_keyword (Missing explicit keyword)
missing_freed_ptr_reset (Missing reset of a freed pointer)
missing_null_char (Missing null in string array)
missing_privilege_drop_check (Privilege drop not verified)
missing_return (Missing return statement)
missing_self_assign_test (Self assignment not tested in operator)
missing_switch_break (Undocumented missing break of switch case)
missing_switch_case (Missing case for switch condition)
missing_virtual_inheritance (Missing virtual inheritance)
more_than_one_statement (Line with more than one statement)
non_init_member (Member not initialized in constructor)
non_init_ptr (Non-initialized pointer)
non_init_ptr_conv (Pointer to non initialized value converted to const pointer)
non_init_var (Non-initialized variable)
non_positive_vla_size (Variable length array with non-positive size)
EMPTY
non_secure_temp_file (Use of non-secure temporary fil)
null_ptr (Null pointer)
null_ptr_arith (Arithmetic operation with NULL pointer)
object_size_mismatch (Wrong allocated object size for cast)
object_slicing (Object slicing)
obsolete_std_func (Use of obsolete standard function)
operator_precedence (Possibly unintended evaluation of expression because of operator precedence rules)
OR-310 (-asm-begin, -asm-end (command line only))
OR-311 (-target)
OR-312 (-functions-to-stub)
OR-320 (-I)
OR-320 (-I)
OR-321 (-D and -U)
OR-321 (-D and -U)
OR-321 (-D and -U)
OR-321 (-D and -U)
OR-322 (-include)
OR-322 (-include)
OR-331 (-to)
OR-331 (-to)
OR-340 (-lang)
OR-340 (-lang)
OR-341 (-prog)
OR-341 (-prog)
OR-343 (-sources-list-file)
OR-343 (-sources and -options-for-sources)
OR-345 (-results-dir)
OR-346 (-author)
OR-347 (-date)
OR-348 (-verif-version)
OR-350 (-compiler (C++))
OR-351 (-dos)
OR-351 (-dos)
OR-352 (-generate-results-for and do-not-generate-results-for)
OR-354 (-compiler & -sfr-types)
OR-356-cpp (-jsf-coding-rules)
OR-356 (-misra2, -allowed-pragmas)
OR-359 (license protection)
OR-367 (-post-analysis-command)
OR-370 (-entry-points, -interrupts, -preemptable-interrupts, -routine-disable-interrupts, -routine-enable-interrupts)
OR-371 (-critical-section-begin)
OR-371 (-critical-section-end)
OR-372 (-temporal-exclusions-file)
OR-373 (-disable-concurrency-detection)
OR-376 (-report-template -report-output-format -report-output-name)
OR-377 (User can annotate coding rule(s) and defect(s) in its source code)
OR-378 (-misra-cpp, -allowed-pragmas)
OR-380 (-post-preprocessing-command)
OR-383 (-custom-rules)
OR-384 (-stop-if-compile-error)
OR-385 (-timeout)
OR-385 (-timeout)
OR-386 (-misra-ac-agc)
OR-390 (Verifier allows user to define its own target processor (generic target))
OR-391 (-div-round-down)
OR-392 (-logical-signed-right-shift)
OR-393 (-enum-type-definition)
OR-407 (Source code metrics shall be generated by Polyspace Bug Finder)
OR-410 (-checkers (Polyspace Bug Finder can detect defects))
OR-411 (-disable-checkers (Polyspace Bug Finder detection can be disabled))
OR-414 (-termination-functions)
other_std_lib (Invalid use of standard library routine)
out_bound_array (Array access out of bounds)
out_bound_ptr (Pointer access out of bounds)
overlapping_assign (Overlapping assignment)
overlapping_copy (Copy of overlapping memory)
partial_override (Partial override of overloaded virtual functions)
partially_accessed_array (Partially accessed array)
pass_by_value (Large pass-by-value argument)
path_buffer_overflow (Use of path manipulation function without maximum-sized buffer checking)
path_traversal (Vulnerable path manipulation)
ptr_cast (Unreliable cast of pointer)
ptr_sizeof_mismatch (Wrong type used in sizeof)
qualifier_mismatch (Qualifier removed in conversion)
rand_seed_constant (Deterministic random output from constant seed)
rand_seed_predictable (Predictable random output from predictable seed)
read_only_resource_write (Writing to read-only resource)
readlink_misuse (Misuse of readlink())
relative_path_cmd (Execution of a binary from a relative path can be controlled by an external actor)
relative_path_lib (Load of library from a relative path can be controlled by an external actor)
resource_leak (Resource leak)
return_not_checked (Returned value of a sensitive function not checked)
return_not_ref_to_this (*this not returned in copy assignment operator)
sensitive_data_print (Sensitive data printed out)
sensitive_heap_not_cleared (Sensitive heap memory not cleared before release)
sensitive_stack_not_cleared (Uncleared sensitive data in stack)
setjmp_longjmp_use (Use of setjmp/longjmp)
shift_neg (Shift of a negative value)
shift_ovfl (Shift operation overflow)
sign_change (Sign change integer conversion overflow)
sizeof_misuse (Possible misuse of sizeof)
std_func_arg_mismatch (Standard function call with incorrect arguments)
str_format_buffer_overflow (Buffer overflow from incorrect string format specifier)
str_std_lib (Invalid use of standard library string routine)
string_format (Format string specifiers and arguments mismatch)
strlib_buffer_overflow (Destination buffer overflow in string manipulation)
strlib_buffer_underflow (Destination buffer underflow in string manipulation)
tainted_array_index (Array access with tainted index<)
tainted_env_variable (Use of externally controlled environment variable)
tainted_external_cmd (Execution of externally controlled command)
tainted_hostid (Host change using externally controlled elements)
tainted_int_division (Tainted division operand<)
tainted_int_mod (Tainted modulo operand)
tainted_loop_boundary (Loop bounded with tainted value)
tainted_memory_alloc_size (Memory allocation with tainted size)
tainted_path_cmd (Command executed from externally controlled path)
tainted_path_lib (Library loaded from externally controlled path)
tainted_ptr (Use of tainted pointer)
tainted_ptr_offset (Pointer dereference with tainted offset)
tainted_sign_change (Tainted sign change conversion)
tainted_string (Tainted NULL or non-null-terminated string)
tainted_string_format (Tainted string format)
tainted_vla_size (Tainted size of variable length array)
toctou (File access between time of check and use (TOCTOU))
typedef_mismatch (Typedef mismatch)
uint_conv_ovfl (Unsigned integer conversion overflow)
uint_ovfl (Unsigned integer overflow)
uncalled_func (Static uncalled function)
unprotected_memory_allocation (Unprotected dynamic memory allocation)
unreachable (Unreachable code)
unsafe_std_crypt (Unsafe standard encryption function)
unsafe_std_func (Unsafe standard function)
unsafe_str_to_numeric (Unsafe string to numeric value conversion)
unused_parameter (Unused parameter)
useless_if (Useless if)
useless_write (Write without a further read)
var_shadowing (Variable shadowing)
virtual_func_hiding (Incompatible types prevent overriding)
vulnerable_prng (Vulnerable pseudo-random number generator)
write_internal_buffer_returned_from_std_func (Modification of internal buffer returned from non-reentrant standard function)
TOR
OR-340 (-lang)
OR-343 (-sources-list-file)
OR-343 (-sources and -options-for-sources)
OR-351 (-dos)
OR-383 (-custom-rules)
OR-311 (-target)
OR-331 (-to)
OR-320 (-I)
OR-321 (-D and -U)
OR-322 (-include)
OR-341 (-prog)
OR-345 (-results-dir)
OR-346 (-author)
OR-347 (-date)
OR-348 (-verif-version)
OR-367 (-post-analysis-command)
OR-385 (-timeout)
OR-414 (-termination-functions)

OR-377 (User can annotate coding rule(s) and defect(s) in its source code)

OR-359 (license protection)
OR-407 (Source code metrics shall be generated by Polyspace Bug Finder)
OR-410 (-checkers (Polyspace Bug Finder can detect defects))
OR-411 (-disable-checkers (Polyspace Bug Finder detection can be disabled))
int_zero_div (Integer division by zero)
float_zero_div (Float division by zero)
int_conv_ovfl (Integer conversion overflow)
uint_conv_ovfl (Unsigned integer conversion overflow)
sign_change (Sign change integer conversion overflow)
float_conv_ovfl (Float conversion overflow)
int_ovfl (Integer overflow)
uint_ovfl (Unsigned integer overflow)
float_ovfl (Float overflow)
float_absorption (Absorption of float operand)
int_std_lib (Invalid use of standard library integer routine)
float_std_lib (Invalid use of standard library floating point routine)
shift_neg (Shift of a negative value)
shift_ovfl (Shift operation overflow)
bad_plain_char_use (Use of plain char type for numeric value)
bitwise_neg (Bitwise operation on negative value)
out_bound_array (Array access out of bounds)
null_ptr (Null pointer)

out_bound_ptr (Pointer access out of bounds)
func_cast (Unreliable cast of function pointer)
ptr_cast (Unreliable cast of pointer)
local_addr_escape (Pointer or reference to stack variable leaving scope)
mem_std_lib (Invalid use of standard library memory routine)
str_std_lib (Invalid use of standard library string routine)
null_ptr_arith (Arithmetic operation with NULL pointer)
object_size_mismatch (Wrong allocated object size for cast)
path_buffer_overflow (Use of path manipulation function without maximum-sized buffer checking)
str_format_buffer_overflow (Buffer overflow from incorrect string format specifier)
strlib_buffer_overflow (Destination buffer overflow in string manipulation)
strlib_buffer_underflow (Destination buffer underflow in string manipulation)
freed_ptr (Use of previously freed pointer)
unprotected_memory_allocation (Unprotected dynamic memory allocation)
double_deallocation (Deallocation of previously deallocated pointer)
bad_free (Invalid free of pointer)
mem_leak (Memory leak)
bad_delete (Invalid deletion of pointer)
useless_write (Write without a further read)
non_init_var (Non-initialized variable)
non_init_ptr (Non-initialized pointer)

var_shadowing (Variable shadowing)
missing_return (Missing return statement)
unreachable (Unreachable code)
dead_code (Dead code)
useless_if (Useless if)
partially_accessed_array (Partially accessed array)
uncalled_func (Static uncalled function)
non_init_ptr_conv (Pointer to non initialized value converted to const pointer)
deactivated_code (Code deactivated by constant false condition)
read_only_resource_write (Writing to read-only resource)
closed_resource_use (Use of previously closed resource)
double_resource_close (Closing previously closed resource)
double_resource_open (Opening previously opened resource)
resource_leak (Resource leak)
assert (Assertion)
bad_equal_use (Invalid use of = operator)
bad_equal_equal_use (Invalid use of == operator)
decl_mismatch (Declaration mismatch)
typedef_mismatch (Typedef mismatch)
bad_float_op (Invalid use of floating point operation)
missing_null_char (Missing null in string array)
qualifier_mismatch (Qualifier removed in conversion)
ptr_sizeof_mismatch (Wrong type used in sizeof)
operator_precedence (Possibly unintended evaluation of expression because of operator precedence rules)
excp_caught_by_value (Exception caught by value)
excp_handler_hidden (Exception handler hidden by previous handler)
std_func_arg_mismatch (Standard function call with incorrect arguments)
invalid_memory_assumption (Invalid assumptions about memory organization)
bad_ptr_scaling (Incorrect pointer scaling)
constant_object_write (Writing to const qualified object)
improper_array_init (Improper array initialization)
memset_invalid_size (Use of memset with size argument zero)
invalid_va_list_arg (Invalid va_list argument)
non_positive_vla_size (Variable length array with non-positive size)
overlapping_assign (Overlapping assignment)
overlapping_copy (Copy of overlapping memory)
sizeof_misuse (Possible misuse of sizeof)
bad_file_access_mode_status (Bad file access mode or status)
write_internal_buffer_returned_from_std_func (Modification of internal buffer returned from non-reentrant standard
function)
memset_invalid_value (Call to memset family with unintended value)
string_format (Format string specifiers and arguments mismatch)
other_std_lib (Invalid use of standard library routine)
bad_int_ptr_cast (Unsafe conversion between pointer and integer)
unsafe_str_to_numeric (Unsafe string to numeric value conversion)
exit_abnormal_handler (Abnormal termination of exit handler)
memcmp_strings (Memory comparison of strings)
memcmp_padding_data (Memory comparison of padding data)
errno_misuse (Misuse of errno)
missing_errno_reset (Missing errno reset)
character_misuse (Misuse of character value)
char_eof_confused (Character value confused with EOF)
object_slicing (Object slicing)
partial_override (Partial override of overloaded virtual functions)
virtual_func_hiding (Incompatible types prevent overriding)
missing_copy_ctor_call (Copy constructor not called in initialization list)
missing_base_assign_op_call (Base class assignment operator not called)
non_init_member (Member not initialized in constructor)
dtor_not_virtual (Base class destructor not virtual)
return_not_ref_to_this (*this not returned in copy assignment operator)
missing_explicit_keyword (Missing explicit keyword)
missing_self_assign_test (Self assignment not tested in operator)
breaking_data_encapsulation (Return of non-const handle to encapsulated data member)
missing_virtual_inheritance (Missing virtual inheritance)
data_race (Data race)

data_race_std_lib (Data race through standard library function call)
data_race_all (Data race including atomic operations)
deadlock (Deadlock)
bad_lock (Missing unlock)
bad_unlock (Missing lock)
double_lock (Double lock)
double_unlock (Double unlock)
destroy_locked (Destruction of locked mutex)
path_traversal (Vulnerable path manipulation)
dangerous_std_func (Use of dangerous standard function)
chroot_misuse (File manipulation after chroot() without chdir("/"))
bad_umask (Umask used with chmod-style arguments)
dangerous_permissions (Vulnerable permission assignments)
rand_seed_constant (Deterministic random output from constant seed)
rand_seed_predictable (Predictable random output from predictable seed)
vulnerable_prng (Vulnerable pseudo-random number generator)
func_ptr_absolute_addr (Function pointer assigned with absolute address)
toctou (File access between time of check and use (TOCTOU))
relative_path_lib (Load of library from a relative path can be controlled by an external actor)
relative_path_cmd (Execution of a binary from a relative path can be controlled by an external actor)
non_secure_temp_file (Use of non-secure temporary fil)
sensitive_stack_not_cleared (Uncleared sensitive data in stack)
sensitive_heap_not_cleared (Sensitive heap memory not cleared before release)
sensitive_data_print (Sensitive data printed out)
obsolete_std_func (Use of obsolete standard function)
bad_network_connect_order (Incorrect order of network connection operations)
data_length_mismatch (Mismatch between data length and size)
unsafe_std_func (Unsafe standard function)
unsafe_std_crypt (Unsafe standard encryption function)
missing_switch_case (Missing case for switch condition)
bad_privilege_drop_order (Bad order of dropping privileges)
missing_privilege_drop_check (Privilege drop not verified)
return_not_checked (Returned value of a sensitive function not checked)
readlink_misuse (Misuse of readlink())
errno_not_checked (errno not checked)
crypto_cipher_bad_function (Inconsistent cipher operations)
crypto_cipher_no_algorithm (Missing cipher algorithm)
crypto_cipher_no_key (Missing cipher key)
crypto_cipher_no_iv (Missing block cipher initialization vector)
crypto_cipher_no_data (Missing cipher data to process)
crypto_cipher_no_final (Missing cipher final step)
crypto_cipher_weak_cipher (Weak cipher algorithm)
crypto_cipher_weak_mode (Weak cipher mode)
crypto_cipher_constant_key (Constant cipher key)
crypto_cipher_constant_iv (Constant block cipher initialization vector)
crypto_cipher_predictable_key (crypto_cipher_predictable_key)
crypto_cipher_predictable_iv (Predictable block cipher initialization vector)
tainted_hostid (Host change using externally controlled elements)
tainted_env_variable (Use of externally controlled environment variable)
tainted_string_format (Tainted string format)
tainted_sign_change (Tainted sign change conversion)
tainted_loop_boundary (Loop bounded with tainted value)
tainted_memory_alloc_size (Memory allocation with tainted size)
tainted_path_lib (Library loaded from externally controlled path)
tainted_path_cmd (Command executed from externally controlled path)
tainted_external_cmd (Execution of externally controlled command)
tainted_vla_size (Tainted size of variable length array)
tainted_int_mod (Tainted modulo operand)
tainted_int_division (Tainted division operand<)
tainted_array_index (Array access with tainted index<)
tainted_ptr_offset (Pointer dereference with tainted offset)
tainted_ptr (Use of tainted pointer)
tainted_string (Tainted NULL or non-null-terminated string)

unused_parameter (Unused parameter)
pass_by_value (Large pass-by-value argument)
hard_coded_buffer_size (Hard-coded buffer size)
hard_coded_loop_boundary (Hard-coded loop boundary)
hard_coded_mem_size (Hard-coded object size used to manipulate memory)
setjmp_longjmp_use (Use of setjmp/longjmp)
more_than_one_statement (Line with more than one statement)
bitwise_arith_mix (Bitwise and arithmetic operation on a same data)
missing_freed_ptr_reset (Missing reset of a freed pointer)
missing_switch_break (Undocumented missing break of switch case)
delete_of_void_ptr (Delete of void pointer)
Tests
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-311-167.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-350-on.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-350-off.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-321-U-on.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-321-U-off.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-370-off-2.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-378.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/OR-378-2.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_zero_div.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_zero_div.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uint_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sign_change.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_conv_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uint_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_absorption.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/int_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/float_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/shift_neg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/shift_ovfl.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_plain_char_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bitwise_neg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/out_bound_array.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/null_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/out_bound_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/func_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/ptr_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/local_addr_escape.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/mem_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/str_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/object_size_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/path_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/str_format_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/strlib_buffer_overflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/strlib_buffer_underflow.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/freed_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unprotected_memory_allocation.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_deallocation.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_free.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/mem_leak.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_delete.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/useless_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_var.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/var_shadowing.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_return.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unreachable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dead_code.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/useless_if.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/partially_accessed_array.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/uncalled_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/deactivated_code.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/read_only_resource_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/closed_resource_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_resource_close.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_resource_open.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/resource_leak.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/assert.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_equal_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_equal_equal_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/decl_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/typedef_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_float_op.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_null_char.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/qualifier_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/ptr_sizeof_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/operator_precedence.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/excp_caught_by_value.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/excp_handler_hidden.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/std_func_arg_mismatch.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/invalid_memory_assumption.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_ptr_scaling.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/constant_object_write.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/improper_array_init.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memset_invalid_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/invalid_va_list_arg.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_positive_vla_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/overlapping_assign.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/overlapping_copy.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sizeof_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_file_access_mode_status.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/write_internal_buffer_returned_from_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memset_invalid_value.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/string_format.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/other_std_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_int_ptr_cast.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_str_to_numeric.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/exit_abnormal_handler.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memcmp_strings.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/memcmp_padding_data.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/errno_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_errno_reset.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/character_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/char_eof_confused.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/object_slicing.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/partial_override.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/virtual_func_hiding.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_copy_ctor_call.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_base_assign_op_call.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_init_member.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/dtor_not_virtual.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/return_not_ref_to_this.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_explicit_keyword.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_self_assign_test.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/breaking_data_encapsulation.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_virtual_inheritance.cpp
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_race.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/deadlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_lock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_unlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_lock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/double_unlock.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/destroy_locked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/path_traversal.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dangerous_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/chroot_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_umask.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/dangerous_permissions.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/rand_seed_constant.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/rand_seed_predictable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/vulnerable_prng.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/func_ptr_absolute_addr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/toctou.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/relative_path_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/relative_path_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/non_secure_temp_file.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_stack_not_cleared.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_heap_not_cleared.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/sensitive_data_print.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/obsolete_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_network_connect_order.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/data_length_mismatch.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_std_func.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unsafe_std_crypt.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_switch_case.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bad_privilege_drop_order.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_privilege_drop_check.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/return_not_checked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/readlink_misuse.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/errno_not_checked.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_bad_function.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_algorithm.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_data.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_no_final.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_weak_cipher.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_weak_mode.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_constant_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_constant_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_predictable_key.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/crypto_cipher_predictable_iv.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_hostid.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_env_variable.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_sign_change.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_loop_boundary.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_memory_alloc_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_path_lib.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_path_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_external_cmd.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_vla_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_int_mod.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_int_division.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_array_index.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_ptr.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/tainted_string.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/unused_parameter.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/pass_by_value.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_buffer_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_loop_boundary.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/hard_coded_mem_size.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/setjmp_longjmp_use.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/more_than_one_statement.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/bitwise_arith_mix.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_freed_ptr_reset.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/missing_switch_break.c
toolbox/qualkits/do/bugfinder/tests/tor-checks/delete_of_void_ptr.cpp
Report TOR
OR-412 (Polyspace Report - Export csv file)
OR-413-1-pdf (Polyspace Report - pdf format)
OR-413-2-word (Polyspace Report - word format)
OR-413-3-html (Polyspace Report - html format)
OR-414-1-bugfinder (Polyspace Report - BugFinder template)

OR-414-2-bugfindersummary (Polyspace Report - BugFinderSummary template)
OR-414-3-codemetrics (Polyspace Report - CodeMetrics template)
OR-414-4-codingrules (Polyspace Report - CodingRules template)

OR-414-5-securitycert (Polyspace report - SecurityCERT template)
OR-414-6-securitycwe (Polyspace report - SecurityCWE template)
OR-414-7-securityiso17961 (Polyspace report - SecurityISO_17961 template)
Tests
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-412.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-1-pdf.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-2-word.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-3-html.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-1-bugfinder_2.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-2-bugfindersummary.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-3-codemetrics_1.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-4-codingrules_3.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-4-codingrules_6.cpp
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-5-securitycert.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-6-securitycwe.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-7-securityiso17961.c
Tests
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-6-securitycwe.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-7-securityiso17961.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-412.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-1-pdf.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-3-html.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-2-bugfindersummary.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-414-5-securitycert.c
toolbox/qualkits/do/bugfinder/tests/report-generator/OR-413-2-word.c
Report TOR
OR-414-6-securitycwe (Polyspace report - SecurityCWE template)
OR-414-7-securityiso17961 (Polyspace report - SecurityISO_17961 template)
OR-412 (Polyspace Report - Export csv file)
OR-413-1-pdf (Polyspace Report - pdf format)
OR-413-3-html (Polyspace Report - html format)
OR-414-2-bugfindersummary (Polyspace Report - BugFinderSummary template)
OR-414-5-securitycert (Polyspace report - SecurityCERT template)
OR-413-2-word (Polyspace Report - word format)

Matrix Req To Tests

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Matrix Req To Tests

Încărcat de

Drepturi de autor:

Formate disponibile

Code Metric

NumFiles (Number of files)

5.3 (A typedef name shall be a unique identifier.)

17.4 (Array indexing shall be only allowed form of pointer arithmetic.)

19.6 (#undef shall not be used)

hich persists after the object has ceased to exist.)

plus m private implementations, plus at most one protected implementation.)

single loop parameter to the next value for the loop.)

d with the type-specifier.)

functions, types, and templates used.)

via their names.)

the width in bits of the left-hand operand (inclusive).)

way by the programmer.)

e the value of a single for loop parameter.)

scope, and therefore hide that identifier.)

of arrays and structures.)

why a final else clause is not necessary.)

ent multiple inclusions of the same header file.)

ntain pointers to data items or nontrivial destructors.)

s a specified algorithmic requirement or is necessary for a hardware interface.)

ule 27 to prevent multiple inclusions of the same header file.)

tain a final default clause.)

of the traditional C-style casts.)

OR-354 (-compiler & -sfr-types)

OR-352 (-generate-results-for and do-not-generate-results-for)

OR-356 (-misra2, -allowed-pragmas)

OR-310 (-asm-begin, -asm-end (command line only))

OR-350 (-compiler (C++))

OR-321 (-D and -U)

OR-370 (-entry-points, -interrupts, -preemptable-interrupts, -routine-disable-interrupts, -routine-enable-interrupts)

OR-376 (-report-template -report-output-format -report-output-name)

OR-378 (-misra-cpp, -allowed-pragmas)

null_ptr (Null pointer)

non_init_ptr (Non-initialized pointer)

data_race (Data race)

tainted_string (Tainted NULL or non-null-terminated string)

OR-414-1-bugfinder (Polyspace Report - BugFinder template)

OR-414-3-codemetrics (Polyspace Report - CodeMetrics template)

OR-414-4-codingrules (Polyspace Report - CodingRules template)

S-ar putea să vă placă și