GEP - Guideline Enforcement Plan

This section targets to provide an overview of Guidelines Enforcement Plan (GEP).

This document will only focus on STMicroelectronics NFC RF Abstraction Layer (RFAL).

The project has been designed to comply with the standard ISO/IEC 9899:1999 ([C99]).

1. Tools version

The tool used for MISRA compliance is:

PRQA Framework - v2.2.2


It is composed of the following subcomponents:

2. Configuration

This section targets to provide the main configuration options used for MISRA compliance.

The project complies to [C99],
the variables length has been consequently set to a dedicated value (cf 'namelength' option in table above).

Repository/components:

3. Assistance/Enforcement

GuidelineCategoryDescriptionAssistance/Enforcement Sub Rules
Dir-1.1 Required Any implementation-defined behaviour on which the output of the program depends shall be documented and understood
QacDescription
0202 [I] '-' character in '[]' conversion specification is implementation defined.
0284 [I] Multiple character constants have implementation defined values.
0285 [I] Character constant contains character which is not a member of the basic source character set.
0286 [I] String literal contains character which is not a member of the basic source character set.
0287 [I] Header name contains character which is not a member of the basic source character set.
0288 [I] Source file '%s' has comments containing characters which are not members of the basic source character set.
0289 [I] Source file '%s' has preprocessing tokens containing characters which are not members of the basic source character set.
0292 [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.
0299 [I] Source file '%s' includes #pragma directives containing characters which are not members of the basic source character set.
0314 [I] Cast from a pointer to object type to a pointer to void.
0315 [I] Implicit conversion from a pointer to object type to a pointer to void.
0371 [L] Nesting levels of blocks exceeds 127 - program does not conform strictly to ISO:C99.
0372 [L] More than 63 levels of nested conditional inclusion - program does not conform strictly to ISO:C99.
0375 [L] Nesting of parenthesized expressions exceeds 63 - program does not conform strictly to ISO:C99.
0380 [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.
0388 [L] '#include "%s"' causes nesting to exceed 15 levels - program does not conform strictly to ISO:C99.
0390 [L] Number of members in 'struct' or 'union' exceeds 1023 - program does not conform strictly to ISO:C99.
0391 [L] Number of enumeration constants exceeds 1023 - program does not conform strictly to ISO:C99.
0392 [L] Nesting of 'struct' or 'union' types exceeds 63 - program does not conform strictly to ISO:C99.
0581 [I] Floating-point constant may be too small to be representable.
0634 [I] Bit-fields in this struct/union have not been declared explicitly as unsigned or signed.
2850 Constant: Implicit conversion to a signed integer type of insufficient size.
2851 Definite: Implicit conversion to a signed integer type of insufficient size.
2852 Apparent: Implicit conversion to a signed integer type of insufficient size.
2855 Constant: Casting to a signed integer type of insufficient size.
2856 Definite: Casting to a signed integer type of insufficient size.
2857 Apparent: Casting to a signed integer type of insufficient size.
2860 Constant: Implementation-defined value resulting from left shift operation on expression of signed type.
2861 Definite: Implementation-defined value resulting from left shift operation on expression of signed type.
2862 Apparent: Implementation-defined value resulting from left shift operation on expression of signed type.
2895 Constant: Negative value cast to an unsigned type.
2896 Definite: Negative value cast to an unsigned type.
2897 Apparent: Negative value cast to an unsigned type.
3116 Unrecognized #pragma arguments '%s' This #pragma directive has been ignored.
Dir-2.1 Required All source files shall compile without any compilation errors Unassisted

Remarks:
Dedicated checks deployed in Jenkins.
Dir-3.1 Required All code shall be traceable to documented requirements Unassisted

Remarks:
Limited management of requirements.
Dir-4.1 Required Run-time failures shall be minimized
QacDescription
2791 Definite: Right hand operand of shift operator is negative or too large.
2792 Apparent: Right hand operand of shift operator is negative or too large.
2801 Definite: Overflow in signed arithmetic operation.
2802 Apparent: Overflow in signed arithmetic operation.
2811 Definite: Dereference of NULL pointer.
2812 Apparent: Dereference of NULL pointer.
2821 Definite: Arithmetic operation on NULL pointer.
2822 Apparent: Arithmetic operation on NULL pointer.
2831 Definite: Division by zero.
2832 Apparent: Division by zero.
2841 Definite: Dereference of an invalid pointer value.
2842 Apparent: Dereference of an invalid pointer value.
2845 Constant: Maximum number of characters to be written is larger than the target buffer size.
2846 Definite: Maximum number of characters to be written is larger than the target buffer size.
2847 Apparent: Maximum number of characters to be written is larger than the target buffer size.
2871 Infinite loop identified.
2872 This loop, if entered, will never terminate.
2877 This loop will never be executed more than once.
Dir-4.10 Required Precautions shall be taken in order to prevent the contents of a header file being included more then once
QacDescription
0883 Include file code is not protected against repeated inclusion
Dir-4.11 Required The validity of values passed to library functions shall be checked Unassisted

Remarks:
No automated check deployed.
Manual checks done by developers.
Dir-4.12 Required Dynamic memory allocation shall not be used Unassisted

Remarks:
No memory allocation functions (malloc(), calloc(), realloc()) being called in RFAL.
Dir-4.13 Advisory Functions which are designed to provide operations on a resource should be called in an appropriate sequence Unassisted
Dir-4.14 Required The validity of values received from external sources shall be checked
QacDescription
2956 Definite: Using object '%s' with tainted value.
Dir-4.2 Advisory All usage of assembly language should be documented
QacDescription
1003 [E] '#%s' is a language extension for in-line assembler. All statements located between #asm and #endasm will be ignored.
1006 [E] This in-line assembler construct is a language extension. The code has been ignored.
Dir-4.3 Required Assembly language shall be encapsulated and isolated
QacDescription
3006 This function contains a mixture of in-line assembler statements and C statements.
3008 This function contains a mixture of in-line assembler statements and C code.
Dir-4.4 Advisory Sections of code should not be "commented out" Unassisted
Dir-4.5 Advisory Identifiers in the same name space with overlapping visibility should be typographically unambiguous Unassisted
Dir-4.6 Advisory typedefs that indicate size and signedness should be used in place of the basic numerical types
QacDescription
5209 Use of basic type '%s'.
Dir-4.7 Required If a function returns error information, then that error information shall be tested Unassisted

Remarks:
Dir-4.7 is similar to Rule-17.7 which is currently dismissed.
This directive is consequently considered as disapplied.
Dir-4.8 Advisory If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden Unassisted
Dir-4.9 Advisory A function should be used in preference to a function-like macro where they are interchangeable
QacDescription
3453 A function could probably be used instead of this function-like macro.
Rule-1.1 Required The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits
QacDescription
0232 [C] Value of hex escape sequence is not representable in type 'unsigned char'.
0233 [C] Value of octal escape sequence is not representable in type 'unsigned char'.
0244 [C] Value of character constant is not representable in type 'int'.
0268 [S] Comment open at end of translation unit.
0321 [C] Declaration within 'for' statement defines an identifier '%s' which is not an object.
0322 [C] Illegal storage class specifier used in 'for' statement declaration.
0338 [C] Octal or hex escape sequence value is too large for 'unsigned char' or 'wchar_t' type.
0422 [C] Function call contains fewer arguments than prototype specifies.
0423 [C] Function call contains more arguments than prototype specifies.
0426 [C] Called function has incomplete return type.
0427 [C] Object identifier used as if it were a function or a function pointer identifier.
0429 [C] Function argument is not of arithmetic type.
0430 [C] Function argument is not of compatible 'struct'/'union' type.
0431 [C] Function argument points to a more heavily qualified type.
0432 [C] Function argument is not of compatible pointer type.
0435 [C] The 'struct'/'union' member '%s' does not exist.
0436 [C] Left operand of '.' must be a 'struct' or 'union' object.
0437 [C] Left operand of '->' must be a pointer to a 'struct' or 'union' object.
0446 [C] Operand of ++/-- must have scalar (arithmetic or pointer) type.
0447 [C] Operand of ++/-- must be a modifiable object.
0448 [C] Operand of ++/-- must not be a pointer to an object of unknown size.
0449 [C] Operand of ++/-- must not be a pointer to a function.
0450 [C] An expression of array type cannot be cast.
0451 [C] Subscripting requires a pointer (or array lvalue).
0452 [C] Cannot subscript a pointer to an object of unknown size.
0453 [C] An array subscript must have integral type.
0454 [C] The address-of operator '&' cannot be applied to an object declared with 'register'.
0456 [C] This expression does not have an address - '&' may only be applied to an lvalue or a function designator.
0457 [C] The address-of operator '&' cannot be applied to a bit-field.
0458 [C] Indirection operator '*' requires operand of pointer type.
0460 [C] The keyword static is used in the declaration of the index of an array which is not a function parameter.
0461 [C] The keyword static is used in the declaration of an inner index of a multi-dimensional array.
0462 [C] A type qualifier (const, volatile or restrict) is used in the declaration of the index of an array which is not a function parameter.
0463 [C] A type qualifier (const, volatile or restrict) is used in the declaration of an inner index of a multi-dimensional array.
0466 [C] Unary '+' requires arithmetic operand.
0467 [C] Operand of '!' must have scalar (arithmetic or pointer) type.
0468 [C] Unary '-' requires arithmetic operand.
0469 [C] Bitwise not '~' requires integral operand.
0476 [C] 'sizeof' cannot be applied to a bit-field.
0477 [C] 'sizeof' cannot be applied to a function.
0478 [C] 'sizeof' cannot be applied to an object of unknown size.
0481 [C] Only scalar expressions may be cast to other types.
0482 [C] Expressions may only be cast to 'void' or scalar types.
0483 [C] A pointer to an object of unknown size cannot be the operand of an addition operator.
0484 [C] A pointer to an object of unknown size cannot be the operand of a subtraction operator.
0485 [C] Only integral expressions may be added to pointers.
0486 [C] Only integral expressions and compatible pointers may be subtracted from pointers.
0487 [C] If two pointers are subtracted, they must be pointers that address compatible types.
0493 [C] Type of left operand is not compatible with this operator.
0494 [C] Type of right operand is not compatible with this operator.
0495 [C] Left operand of '%', '<<', '>>', '&', '^' or '|' must have integral type.
0496 [C] Right operand of '%', '<<', '>>', '&', '^' or '|' must have integral type.
0513 [C] Relational operator used to compare pointers to incompatible types.
0514 [C] Relational operator used to compare a pointer with an incompatible operand.
0515 [C] Equality operator used to compare a pointer with an incompatible operand.
0536 [C] First operand of '&&', '||' or '?' must have scalar (arithmetic or pointer) type.
0537 [C] Second operand of '&&' or '||' must have scalar (arithmetic or pointer) type.
0540 [C] 2nd and 3rd operands of conditional operator '?' must have compatible types.
0541 [C] Argument no. %s does not have object type.
0542 [C] Controlling expression must have scalar (arithmetic or pointer) type.
0546 [C] 'enum %s' has unknown content. Use of an enum tag with undefined content is not permitted.
0547 [C] This declaration of tag '%s' conflicts with a previous declaration.
0550 [C] Left operand of '+=' or '-=' is a pointer to an object of unknown size.
0554 [C] 'static %s()' has been declared and called but no definition has been given.
0555 [C] Invalid assignment to object of void type or array type.
0556 [C] Left operand of assignment must be a modifiable object.
0557 [C] Right operand of assignment is not of arithmetic type.
0558 [C] Right operand of '+=' or '-=' must have integral type when left operand is a pointer.
0559 [C] Right operand of '<<=', '>>=', '&=', '|=', '^=' or '%=' must have integral type.
0560 [C] Left operand of '<<=', '>>=', '&=', '|=', '^=' or '%=' must have integral type.
0561 [C] Right operand of assignment is not of compatible 'struct'/'union' type.
0562 [C] Right operand of assignment points to a more heavily qualified type.
0563 [C] Right operand of assignment is not of compatible pointer type.
0564 [C] Left operand of assignment must be an lvalue (it must designate an object).
0565 [C] Left operand of '+=' or '-=' must be of arithmetic or pointer to object type.
0580 [C] Constant is too large to be representable.
0588 [C] Width of bit-field must be an integral constant expression.
0589 [C] Enumeration constant must be an integral constant expression.
0590 [C] Array bound must be an integral constant expression.
0591 [C] A 'case' label must be an integral constant expression.
0605 [C] A declaration must declare a tag or an identifier.
0616 [C] Illegal combination of type specifiers or storage class specifiers.
0619 [C] The identifier '%s' has already been defined in the current scope within the ordinary identifier namespace.
0620 [C] Cannot initialize '%s' because it has unknown size.
0621 [C] The struct/union '%s' cannot be initialized because it has unknown size.
0622 [C] The identifier '%s' has been declared both with and without linkage in the same scope.
0627 [C] '%s' has different type to previous declaration in the same scope.
0628 [C] '%s' has different type to previous declaration at wider scope.
0629 [C] More than one definition of '%s' (with internal linkage).
0631 [C] More than one declaration of '%s' (with no linkage).
0638 [C] Duplicate member name '%s' in 'struct' or 'union'.
0640 [C] '%s' in 'struct' or 'union' type may not have 'void' type.
0641 [C] '%s' in 'struct' or 'union' type may not have function type.
0642 [C] '%s' in 'struct' or 'union' type may not be an array of unknown size.
0643 [C] '%s' in 'struct' or 'union' type may not be a 'struct' or 'union' with unknown content.
0644 [C] Width of bit-field must be no bigger than the width of an 'int'.
0645 [C] A zero width bit-field cannot be given a name.
0646 [C] Enumeration constants must have values representable as 'int's.
0649 [C] K&R style declaration of parameters is not legal after a function header that includes a parameter list.
0650 [C] Illegal storage class specifier on named function parameter.
0651 [C] Missing type specifiers in function declaration.
0653 [C] Duplicate definition of 'struct', 'union' or 'enum' tag '%s'.
0655 [C] Illegal storage class specifier on unnamed function parameter.
0656 [C] Function return type cannot be function or array type, or an incomplete struct/union (for function definition).
0657 [C] Unnamed parameter specified in function definition.
0659 [C] The identifier '%s' was not given in the parameter list.
0664 [C] Parameter specified with type 'void'.
0665 [C] Two parameters have been declared with the same name '%s'.
0669 [C] The restrict qualifier can only be applied to pointer types derived from object or incomplete types.
0671 [C] Initializer for object of arithmetic type is not of arithmetic type.
0673 [C] Initializer points to a more heavily qualified type.
0674 [C] Initializer for pointer is of incompatible type.
0675 [C] Initializer is not of compatible 'struct'/'union' type.
0677 [C] Array size is negative, or unrepresentable.
0682 [C] Initializer for object of a character type is a string literal.
0683 [C] Initializer for object of a character type is a wide string literal.
0684 [C] Too many initializers.
0685 [C] Initializer for any object with static storage duration must be a constant expression.
0690 [C] String literal contains too many characters to initialize object.
0698 [C] String literal used to initialize an object of incompatible type.
0699 [C] String literal used to initialize a pointer of incompatible type.
0708 [C] No definition found for the label '%s' in this function.
0709 [C] Initialization of locally declared 'extern %s' is illegal.
0736 [C] 'case' label does not have unique value within this 'switch' statement.
0737 [C] More than one 'default' label found in 'switch' statement.
0738 [C] Controlling expression in a 'switch' statement must have integral type.
0746 [C] 'return exp;' found in '%s()' whose return type is 'void'.
0747 [C] 'return exp;' found in '%s()' whose return type is qualified 'void'.
0755 [C] 'return' expression is not of arithmetic type.
0756 [C] 'return' expression is not of compatible 'struct'/'union' type.
0757 [C] 'return' expression points to a more heavily qualified type.
0758 [C] 'return' expression is not of compatible pointer type.
0766 [C] 'continue' statement found outside an iteration statement.
0767 [C] 'break' statement found outside a 'switch' or iteration statement.
0768 [C] 'case' or 'default' found outside a 'switch' statement.
0774 [C] 'auto' may not be specified on global declaration of '%s'.
0775 [C] 'register' may not be specified on global declaration of '%s'.
0801 [C] The '##' operator may not be the first token in a macro replacement list.
0802 [C] The '##' operator may not be the last token in a macro replacement list.
0803 [C] The '#' operator may only appear before a macro parameter.
0804 [C] Macro parameter '%s' is not unique.
0811 [C] The glue operator '##' may only appear in a '#define' preprocessing directive.
0812 [C] Header name token '' found outside '#include' preprocessing directive.
0817 [S] Closing quote or bracket '>' missing from include filename.
0818 [Q] Cannot find '%s' - Perhaps the appropriate search path was not given ?
0821 [C] '#include' does not identify a header or source file that can be processed.
0834 [C] Function-like macro '%s()' is being redefined as an object-like macro.
0835 [C] Macro '%s' is being redefined with different parameter names.
0844 [C] Macro '%s' is being redefined with a different replacement list.
0845 [C] Object-like macro '%s' is being redefined as a function-like macro.
0851 [C] More arguments in macro call than specified in definition.
0852 [S] Unable to find the ')' that marks the end of the macro call.
0866 [C] The string literal in a '#line' directive cannot be a 'wide string literal'.
0873 [C] Preprocessing token cannot be converted to an actual token.
0877 [C] '#if' and '#elif' expressions may contain only integral constants.
0940 [C] Illegal usage of a variably modified type.
0941 [C] A variable length array may not be initialized.
0943 [C] Jump to label '%s' is a jump into the scope of an identifier with variably modified type.
0944 [C] The label '%s' is inside the scope of an identifier with variably modified type.
1023 [C] Using '__alignof__' on function types is illegal.
1024 [C] Using '__alignof__' on incomplete types is illegal.
1025 [C] Using '__alignof__' on bit-fields is illegal.
1033 [C] The identifier __VA_ARGS__ may only be used in the replacement list of a variadic macro.
1047 [C] Function is being declared with default argument syntax after a previous call to the function. This is not allowed.
1048 [C] Default argument values are missing for some parameters in this function declaration. This is not allowed.
1050 [C] Nested functions cannot be 'extern' or 'static'.
1061 [C] Structure '%1s' with flexible array member '%2s' cannot be used in the declaration of structure member '%3s'.
1062 [C] Structure '%1s' with flexible array member '%2s' cannot be used in the declaration of array elements.
3236 [C] 'inline' may not be applied to function 'main'.
3237 [C] inline function '%1s' has external linkage and is defining an object, '%2s', with static storage duration.
3238 [C] inline function '%1s' has external linkage and is referring to an object, '%2s', with internal linkage.
3244 [C] 'inline' may only be used in the declaration of a function identifier.
Rule-1.2 Advisory Language extensions should not be used
QacDescription
0240 [E] This file contains the control-M character at the end of a line.
0241 [E] This file contains the control-Z character - was this transferred from a PC?
0246 [E] Binary integer constants are a language extension.
0551 [E] Cast may not operate on the left operand of the assignment operator.
0601 [E] Function 'main()' is not of type 'int (void)' or 'int (int, char *[])'.
0633 [E] Empty structures and unions are a language extension.
0635 [E] Bit-fields in this struct/union have been declared with types other than int, signed int, unsigned int or _Bool.
0660 [E] Defining an unnamed member in a struct or union. This is a language extension.
0662 [E] Accessing a member of an unnamed struct or union member in this way is a language extension.
0830 [E] Unrecognized text encountered after a preprocessing directive.
0831 [E] Use of '\\' in this '#include' line is a PC extension - this usage is non-portable.
0840 [E] Extra tokens at end of #include directive.
0883 Include file code is not protected against repeated inclusion
0899 [E] Unrecognized preprocessing directive has been ignored - assumed to be a language extension.
0981 [E] Redundant semicolon in 'struct' or 'union' member declaration list is a language extension.
1001 [E] '#include %s' is a VMS extension.
1002 [E] '%s' is not a legal identifier in ISO C.
1003 [E] '#%s' is a language extension for in-line assembler. All statements located between #asm and #endasm will be ignored.
1006 [E] This in-line assembler construct is a language extension. The code has been ignored.
1008 [E] '#%s' is not a legal ISO C preprocessing directive.
1012 [E] Use of a C++ reference type ('type &') will be treated as a language extension.
1014 [E] Non-standard type specifier - this will be treated as a language extension.
1015 [E] '%s' is not a legal keyword in ISO C - this will be treated as a language extension.
1019 [E] '@ address' is not supported in ISO C - this will be treated as a language extension.
1020 [E] '__typeof__' is not supported in ISO C, and is treated as a language extension.
1021 [E] A statement expression is not supported in ISO C, and is treated as a language extension.
1022 [E] '__alignof__' is not supported in ISO C, and is treated as a language extension.
1026 [E] The indicated @word construct has been ignored.
1028 [E] Use of the sizeof operator in a preprocessing directive is a language extension.
1029 [E] Whitespace encountered between backslash and new-line has been ignored.
1034 [E] Macro defined with named variable argument list. This is a language extension.
1035 [E] No macro arguments supplied for variable argument list. This is a language extension.
1036 [E] Comma before ## ignored in expansion of variadic macro. This is a language extension.
1037 [E] Arrays of length zero are a language extension.
1038 [E] The sequence ", ##__VA_ARGS__" is a language extension.
1039 [E] Treating array of length one as potentially flexible member.
1041 [E] Empty aggregate initializers are a language extension.
1042 [E] Using I64 or UI64 as an integer constant suffix. This is a language extension.
1043 [E] Defining an anonymous union object. This is a language extension.
1044 [E] Defining an anonymous struct object. This is a language extension.
1045 [E] Use of the #include_next preprocessing directive is a language extension.
1046 [E] Function is being declared with default argument syntax. This is a language extension.
1049 [E] Nested functions are a language extension.
3445 [E] Conditional expression with middle operand omitted is a language extension.
3664 [E] Using a dot operator to access an individual bit is a language extension.
Rule-1.3 Required There shall be no occurrence of undefined or critical unspecified behaviour
QacDescription
0160 [U] Using unsupported conversion specifier number %s.
0161 [U] Unknown length modifier used with 'i' or 'd' conversion specifier, number %s.
0162 [U] Unknown length modifier used with 'o' conversion specifier, number %s.
0163 [U] Unknown length modifier used with 'u' conversion specifier, number %s.
0164 [U] Unknown length modifier used with 'x' conversion specifier, number %s.
0165 [U] Unknown length modifier used with 'X' conversion specifier, number %s.
0166 [U] Unknown length modifier used with 'f' conversion specifier, number %s.
0167 [U] Unknown length modifier used with 'e' conversion specifier, number %s.
0168 [U] Unknown length modifier used with 'E' conversion specifier, number %s.
0169 [U] Unknown length modifier used with 'g' conversion specifier, number %s.
0170 [U] Unknown length modifier used with 'G' conversion specifier, number %s.
0171 [U] Unknown length modifier used with 'c' conversion specifier, number %s.
0172 [U] Unknown length modifier used with '%%' conversion specifier, number %s.
0173 [U] Unknown length modifier used with 's' conversion specifier, number %s.
0174 [U] Unknown length modifier used with 'n' conversion specifier, number %s.
0175 [U] Unknown length modifier used with 'p' conversion specifier, number %s.
0176 [U] Incomplete conversion specifier, number %s.
0177 [U] Field width of format conversion specifier exceeds 509 characters.
0178 [U] Precision of format conversion specifier exceeds 509 characters.
0179 [U] Argument type does not match conversion specifier number %s.
0184 [U] Insufficient arguments to satisfy conversion specifier, number %s.
0185 [U] Call contains more arguments than conversion specifiers.
0186 [U] A call to this function must include at least one argument.
0190 [U] Using unsupported conversion specifier number %s.
0191 [U] Unknown length modifier used with 'd/i/n' conversion specifier, number %s.
0192 [U] Unknown length modifier used with 'o' conversion specifier, number %s.
0193 [U] Unknown length modifier used with 'u' conversion specifier, number %s.
0194 [U] Unknown length modifier used with 'x/X' conversion specifier, number %s.
0195 [U] Unknown length modifier used with 'e/E/f/F/g/G' conversion specifier, number %s.
0196 [U] Unknown length modifier used with 's' conversion specifier, number %s.
0197 [U] Unknown length modifier used with 'p' conversion specifier, number %s.
0198 [U] Unknown length modifier used with '%%' conversion specifier, number %s.
0199 [U] Unknown length modifier used with '[' conversion specifier, number %s.
0200 [U] Unknown length modifier used with 'c' conversion specifier, number %s.
0201 [U] Incomplete conversion specifier, number %s.
0203 [U] Value of character prior to '-' in '[]' is greater than following character.
0204 [U] Field width of format conversion specifier exceeds 509 characters.
0206 [U] Argument type does not match conversion specifier number %s.
0207 [U] 'scanf' expects address of objects being stored into.
0208 [U] Same character occurs in scanset more than once.
0235 [U] Unknown escape sequence.
0275 [U] Floating value is out of range for conversion to destination type.
0301 [u] Cast between a pointer to object and a floating type.
0302 [u] Cast between a pointer to function and a floating type.
0304 [U] The address of an array declared 'register' may not be computed.
0307 [u] Cast between a pointer to object and a pointer to function.
0309 [U] Integral type is not large enough to hold a pointer value.
0327 [I] Cast between a pointer to void and an floating type.
0337 [U] String literal has undefined value. This may be a result of using '#' on \\.
0400 [U] '%s' is modified more than once between sequence points - evaluation order unspecified.
0401 [U] '%s' may be modified more than once between sequence points - evaluation order unspecified.
0402 [U] '%s' is modified and accessed between sequence points - evaluation order unspecified.
0403 [U] '%s' may be modified and accessed between sequence points - evaluation order unspecified.
0404 More than one read access to volatile objects between sequence points.
0405 More than one modification of volatile objects between sequence points.
0475 [u] Operand of 'sizeof' is an expression designating a bit-field.
0543 [U] 'void' expressions have no value and may not be used in expressions.
0544 [U] The value of an incomplete 'union' may not be used.
0545 [U] The value of an incomplete 'struct' may not be used.
0602 [U] The identifier '%s' is reserved for use by the library.
0603 [U] The macro identifier '%s' is reserved.
0623 [U] '%s' has incomplete type and no linkage - this is undefined.
0625 [U] '%s' has been declared with both internal and external linkage - the behaviour is undefined.
0626 [U] '%s' has different type to previous declaration (which is no longer in scope).
0630 [U] More than one definition of '%s' (with external linkage).
0632 [U] Tentative definition of '%s' with internal linkage cannot have unknown size.
0636 [U] There are no named members in this 'struct' or 'union'.
0654 [U] Using 'const' or 'volatile' in a function return type is undefined.
0658 [U] Parameter cannot have 'void' type.
0661 [U] '%s()' may not have a storage class specifier of 'static' when declared at block scope.
0667 [U] '%s' is declared as a typedef and may not be redeclared as an object at an inner scope without an explicit type specifier.
0668 [U] '%s' is declared as a typedef and may not be redeclared as a member of a 'struct' or 'union' without an explicit type specifier.
0672 [U] The initializer for a 'struct', 'union' or array is not enclosed in braces.
0676 [u] Array element is of function type. Arrays cannot be constructed from function types.
0678 [u] Array element is array of unknown size. Arrays cannot be constructed from incomplete types.
0680 [u] Array element is 'void' or an incomplete 'struct' or 'union'. Arrays cannot be constructed from incomplete types.
0706 [U] Label '%s' is not unique within this function.
0745 [U] 'return;' found in '%s()', which has been defined with a non-'void' return type.
0777 [U] External identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.
0779 [U] Identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.
0813 [U] Using any of the characters ' " or /* in '#include <%s>' gives undefined behaviour.
0814 [U] Using the characters ' or /* in '#include "%s"' gives undefined behaviour.
0836 [U] Definition of macro named 'defined'.
0837 [U] Use of '#undef' to remove the operator 'defined'.
0840 [E] Extra tokens at end of #include directive.
0848 [U] Attempting to #undef '%s', which is a predefined macro name.
0853 [U] Macro arguments contain a sequence of tokens that has the form of a preprocessing directive.
0854 [U] Attempting to #define '%s', which is a predefined macro name.
0864 [U] '#line' directive specifies line number which is not in the range 1 to 32767.
0865 [U] '#line' directive is badly formed.
0867 [U] '#line' has not been followed by a line number.
0872 [U] Result of '##' operator is not a legal preprocessing token.
0874 [U] Character string literal and wide character string literal are adjacent.
0885 [U] The token 'defined' is generated in the expansion of this macro.
0887 [U] Use of 'defined' must match either 'defined(identifier)' or 'defined identifier'.
0888 [U] 'defined' requires an identifier as an argument.
0914 [U] Source file does not end with a newline character.
0915 [U] Source file ends with a backslash character followed by a newline.
0942 [U] A * can only be used to specify array size within function prototype scope.
1331 Type or number of arguments doesn't match previous use of the function.
1332 Type or number of arguments doesn't match prototype found later.
1333 Type or number of arguments doesn't match function definition found later.
2800 Constant: Overflow in signed arithmetic operation.
2810 Constant: Dereference of NULL pointer.
2820 Constant: Arithmetic operation on NULL pointer.
2830 Constant: Division by zero.
2840 Constant: Dereference of an invalid pointer value.
3113 [U] 'return' statement includes no expression but function '%s()' is implicitly of type 'int'.
3114 [U] Function '%s()' is implicitly of type 'int' but ends without returning a value.
3239 [U] inline function '%1s' has external linkage, but is not defined within this translation unit.
3311 [u] An earlier jump to this statement will bypass the initialization of local variables.
3312 [u] This goto statement will jump into a previous block and bypass the initialization of local variables.
3319 [U] Function called with number of arguments which differs from number of parameters in definition.
3320 Type of argument no. %s differs from its type in definition of function.
3437 [u] The assert macro has been suppressed to call a function of that name.
3438 [U] #undef'ing the assert macro to call a function of that name causes undefined behaviour.
1509 '%1s' has external linkage and has multiple definitions.
1510 '%1s' has external linkage and has incompatible declarations.
Rule-10.1 Required Operands shall not be of an inappropriate essential type.
QacDescription
3101 Unary '-' applied to an operand of type unsigned int or unsigned long gives an unsigned result.
3102 Unary '-' applied to an operand whose underlying type is unsigned.
4500 An expression of 'essentially Boolean' type (%1s) is being used as an array subscript.
4501 An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).
4502 An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).
4503 An expression of 'essentially Boolean' type (%1s) is being used as the left-hand operand of this shift operator (%2s).
4504 An expression of 'essentially Boolean' type (%1s) is being used as the right-hand operand of this shift operator (%2s).
4505 An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this relational operator (%3s).
4507 An expression of 'essentially Boolean' type (%1s) is being used as the operand of this increment/decrement operator (%2s).
4510 An expression of 'essentially character' type (%1s) is being used as an array subscript.
4511 An expression of 'essentially character' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).
4512 An expression of 'essentially character' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).
4513 An expression of 'essentially character' type (%1s) is being used as the left-hand operand of this shift operator (%2s).
4514 An expression of 'essentially character' type (%1s) is being used as the right-hand operand of this shift operator (%2s).
4518 An expression of 'essentially character' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4519 An expression of 'essentially character' type (%1s) is being used as the first operand of this conditional operator (%2s).
4521 An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).
4522 An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).
4523 An expression of 'essentially enum' type (%1s) is being used as the left-hand operand of this shift operator (%2s).
4524 An expression of 'essentially enum' type (%1s) is being used as the right-hand operand of this shift operator (%2s).
4527 An expression of 'essentially enum' type is being used as the operand of this increment/decrement operator.
4528 An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4529 An expression of 'essentially enum' type (%1s) is being used as the first operand of this conditional operator (%2s).
4532 An expression of 'essentially signed' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).
4533 An expression of 'essentially signed' type (%1s) is being used as the left-hand operand of this shift operator (%2s).
4534 An expression of 'essentially signed' type (%1s) is being used as the right-hand operand of this shift operator (%2s).
4538 An expression of 'essentially signed' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4539 An expression of 'essentially signed' type (%1s) is being used as the first operand of this conditional operator (%2s).
4542 A non-negative constant expression of 'essentially signed' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).
4543 A non-negative constant expression of 'essentially signed' type (%1s) is being used as the left-hand operand of this shift operator (%2s).
4548 A non-negative constant expression of 'essentially signed' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4549 A non-negative constant expression of 'essentially signed' type (%1s) is being used as the first operand of this conditional operator (%2s).
4558 An expression of 'essentially unsigned' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4559 An expression of 'essentially unsigned' type (%1s) is being used as the first operand of this conditional operator (%2s).
4568 An expression of 'essentially floating' type (%1s) is being used as the %2s operand of this logical operator (%3s).
4569 An expression of 'essentially floating' type (%1s) is being used as the first operand of this conditional operator (%2s).
Rule-10.2 Required Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations
QacDescription
1810 An operand of 'essentially character' type is being added to another operand of 'essentially character' type.
1811 An operand of 'essentially character' type is being subtracted from an operand of 'essentially signed' type.
1812 An operand of 'essentially character' type is being subtracted from an operand of 'essentially unsigned' type.
1813 An operand of 'essentially character' type is being balanced with an operand of 'essentially floating' type in this arithmetic operation.
Rule-10.3 Required The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category.
QacDescription
0570 This switch case label of 'essential type' '%1s', is not consistent with a controlling expression of essential type '%2s'.
0572 This switch case label of 'essential type' '%1s' is not consistent with a controlling expression which has an essential type of lower rank (%2s).
1257 An integer constant suffixed with L or LL is being converted to a type of lower rank on assignment.
1264 A suffixed floating constant is being converted to a different floating type on assignment.
1265 An unsuffixed floating constant is being converted to a different floating type on assignment.
1266 A floating constant is being converted to integral type on assignment.
1291 An integer constant of 'essentially unsigned' type is being converted to signed type on assignment.
1292 An integer constant of 'essentially signed' type is being converted to type char on assignment.
1293 An integer constant of 'essentially unsigned' type is being converted to type char on assignment.
1294 An integer constant of 'essentially signed' type is being converted to type _Bool on assignment.
1295 An integer constant of 'essentially unsigned' type is being converted to type _Bool on assignment.
1296 An integer constant of 'essentially signed' type is being converted to enum type on assignment.
1297 An integer constant of 'essentially unsigned' type is being converted to enum type on assignment.
1298 An integer constant of 'essentially signed' type is being converted to floating type on assignment.
1299 An integer constant of 'essentially unsigned' type is being converted to floating type on assignment.
2850 Constant: Implicit conversion to a signed integer type of insufficient size.
2890 Constant: Negative value implicitly converted to an unsigned type.
2900 Constant: Positive integer value truncated by implicit conversion to a smaller unsigned type.
4401 An expression of 'essentially Boolean' type (%1s) is being converted to character type, '%2s' on assignment.
4402 An expression of 'essentially Boolean' type (%1s) is being converted to enum type, '%2s' on assignment.
4403 An expression of 'essentially Boolean' type (%1s) is being converted to signed type, '%2s' on assignment.
4404 An expression of 'essentially Boolean' type (%1s) is being converted to unsigned type, '%2s' on assignment.
4405 An expression of 'essentially Boolean' type (%1s) is being converted to floating type, '%2s' on assignment.
4410 An expression of 'essentially character' type (%1s) is being converted to Boolean type, '%2s' on assignment.
4412 An expression of 'essentially character' type (%1s) is being converted to enum type, '%2s' on assignment.
4413 An expression of 'essentially character' type (%1s) is being converted to signed type, '%2s' on assignment.
4414 An expression of 'essentially character' type (%1s) is being converted to unsigned type, '%2s' on assignment.
4415 An expression of 'essentially character' type (%1s) is being converted to floating type, '%2s' on assignment.
4420 An expression of 'essentially enum' type (%1s) is being converted to Boolean type, '%2s' on assignment.
4421 An expression of 'essentially enum' type (%1s) is being converted to character type, '%2s' on assignment.
4422 An expression of 'essentially enum' type (%1s) is being converted to a different enum type, '%2s' on assignment.
4423 An expression of 'essentially enum' type (%1s) is being converted to signed type, '%2s' on assignment.
4424 An expression of 'essentially enum' type (%1s) is being converted to unsigned type, '%2s' on assignment.
4425 An expression of 'essentially enum' type (%1s) is being converted to floating type, '%2s' on assignment.
4430 An expression of 'essentially signed' type (%1s) is being converted to Boolean type, '%2s' on assignment.
4431 An expression of 'essentially signed' type (%1s) is being converted to character type, '%2s' on assignment.
4432 An expression of 'essentially signed' type (%1s) is being converted to enum type, '%2s' on assignment.
4434 A non-constant expression of 'essentially signed' type (%1s) is being converted to unsigned type, '%2s' on assignment.
4435 A non-constant expression of 'essentially signed' type (%1s) is being converted to floating type, '%2s' on assignment.
4437 A constant expression of 'essentially signed' type (%1s) is being converted to floating type, '%2s' on assignment.
4440 An expression of 'essentially unsigned' type (%1s) is being converted to Boolean type, '%2s' on assignment.
4441 An expression of 'essentially unsigned' type (%1s) is being converted to character type, '%2s' on assignment.
4442 An expression of 'essentially unsigned' type (%1s) is being converted to enum type, '%2s' on assignment.
4443 A non-constant expression of 'essentially unsigned' type (%1s) is being converted to a wider signed type, '%2s' on assignment.
4445 An expression of 'essentially unsigned' type (%1s) is being converted to floating type, '%2s' on assignment.
4446 A non-constant expression of 'essentially unsigned' type (%1s) is being converted to signed type, '%2s' on assignment.
4447 A constant expression of 'essentially unsigned' type (%1s) is being converted to signed type, '%2s' on assignment.
4450 An expression of 'essentially floating' type (%1s) is being converted to Boolean type, '%2s' on assignment.
4451 An expression of 'essentially floating' type (%1s) is being converted to character type, '%2s' on assignment.
4452 An expression of 'essentially floating' type (%1s) is being converted to enum type, '%2s' on assignment.
4453 An expression of 'essentially floating' type (%1s) is being converted to signed type, '%2s' on assignment.
4454 An expression of 'essentially floating' type (%1s) is being converted to unsigned type, '%2s' on assignment.
4460 A non-constant expression of 'essentially signed' type (%1s) is being converted to narrower signed type, '%2s' on assignment.
4461 A non-constant expression of 'essentially unsigned' type (%1s) is being converted to narrower unsigned type, '%2s' on assignment.
4462 A non-constant expression of 'essentially floating' type (%1s) is being converted to narrower floating type, '%2s' on assignment.
4463 A constant expression of 'essentially signed' type (%1s) is being converted to narrower signed type, '%2s' on assignment.
4464 A constant expression of 'essentially unsigned' type (%1s) is being converted to narrower unsigned type, '%2s' on assignment.
4465 A constant expression of 'essentially floating' type (%1s) is being converted to narrower floating type, '%2s' on assignment.
Rule-10.4 Required Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category
QacDescription
1800 The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this arithmetic operation.
1802 The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this relational operation.
1803 The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this equality operation.
1804 The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this conditional operation.
1820 The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.
1821 The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.
1822 The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this relational operation.
1823 The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this equality operation.
1824 The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this conditional operation.
1830 The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.
1831 The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.
1832 The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this relational operation.
1833 The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this equality operation.
1834 The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this conditional operation.
1840 The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.
1841 The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.
1842 The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this relational operation.
1843 The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this equality operation.
1844 The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this conditional operation.
1850 The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this arithmetic operation.
1851 The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this bitwise operation.
1852 The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this relational operation.
1853 The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this equality operation.
1854 The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this conditional operation.
1860 The operands of this arithmetic operator are of different 'essential signedness' but will generate a result of type 'signed int'.
1861 The operands of this bitwise operator are of different 'essential signedness' but will generate a result of type 'signed int'.
1862 The operands of this relational operator are of different 'essential signedness' but will both be promoted to 'signed int' for comparison.
1863 The operands of this equality operator are of different 'essential signedness' but will both be promoted to 'signed int' for comparison.
1864 The 2nd and 3rd operands of this conditional operator are of different 'essential signedness'. The result will be in the promoted type 'signed int'.
1880 The operands of this relational operator are expressions of different 'essential type' categories (%1s and %2s).
1881 The operands of this equality operator are expressions of different 'essential type' categories (%1s and %2s).
1882 The 2nd and 3rd operands of this conditional operator are expressions of different 'essential type' categories (%1s and %2s).
Rule-10.5 Advisory The value of an expression should not be cast to an inappropriate essential type
QacDescription
4301 An expression of 'essentially Boolean' type (%1s) is being cast to character type '%2s'.
4302 An expression of 'essentially Boolean' type (%1s) is being cast to enum type '%2s'.
4303 An expression of 'essentially Boolean' type (%1s) is being cast to signed type '%2s'.
4304 An expression of 'essentially Boolean' type (%1s) is being cast to unsigned type '%2s'.
4305 An expression of 'essentially Boolean' type (%1s) is being cast to floating type '%2s'.
4310 An expression of 'essentially character' type (%1s) is being cast to Boolean type, '%2s'.
4312 An expression of 'essentially character' type (%1s) is being cast to enum type, '%2s'.
4315 An expression of 'essentially character' type (%1s) is being cast to floating type, '%2s'.
4320 An expression of 'essentially enum' type (%1s) is being cast to Boolean type, '%2s'.
4322 An expression of 'essentially enum' type (%1s) is being cast to a different enum type, '%2s'.
4330 An expression of 'essentially signed' type (%1s) is being cast to Boolean type '%2s'.
4332 An expression of 'essentially signed' type (%1s) is being cast to enum type, '%2s'.
4340 An expression of 'essentially unsigned' type (%1s) is being cast to Boolean type '%2s'.
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
4350 An expression of 'essentially floating' type (%1s) is being cast to Boolean type '%2s'.
4351 An expression of 'essentially floating' type (%1s) is being cast to character type '%2s'.
4352 An expression of 'essentially floating' type (%1s) is being cast to enum type, '%2s'.
Rule-10.6 Required The value of a composite expression shall not be assigned to an object with wider essential type
QacDescription
4490 A composite expression of 'essentially signed' type (%1s) is being converted to wider signed type, '%2s' on assignment.
4491 A composite expression of 'essentially unsigned' type (%1s) is being converted to wider unsigned type, '%2s' on assignment.
4492 A composite expression of 'essentially floating' type (%1s) is being converted to wider floating type, '%2s' on assignment.
4499 An expression which is the result of a ~ or << operation has been converted to a wider essential type on assignment.
Rule-10.7 Required If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type
QacDescription
1890 A composite expression of 'essentially signed' type (%1s) is being implicitly converted to a wider signed type, '%2s'.
1891 A composite expression of 'essentially unsigned' type (%1s) is being implicitly converted to a wider unsigned type, '%2s'.
1892 A composite expression of 'essentially floating' type (%1s) is being implicitly converted to a wider floating type, '%2s'.
1893 The 2nd and 3rd operands of this conditional operator are both 'essentially signed' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.
1894 The 2nd and 3rd operands of this conditional operator are both 'essentially unsigned' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.
1895 The 2nd and 3rd operands of this conditional operator are both 'essentially floating' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.
Rule-10.8 Required The value of a composite expression shall not be cast to a different essential type category or a wider essential type
QacDescription
4389 A composite expression of 'essentially char' type (%1s) is being cast to a different type category, '%2s'.
4390 A composite expression of 'essentially signed' type (%1s) is being cast to a wider signed type, '%2s'.
4391 A composite expression of 'essentially unsigned' type (%1s) is being cast to a wider unsigned type, '%2s'.
4392 A composite expression of 'essentially floating' type (%1s) is being cast to a wider floating type, '%2s'.
4393 A composite expression of 'essentially signed' type (%1s) is being cast to a different type category, '%2s'.
4394 A composite expression of 'essentially unsigned' type (%1s) is being cast to a different type category, '%2s'.
4395 A composite expression of 'essentially floating' type (%1s) is being cast to a different type category, '%2s'.
4398 An expression which is the result of a ~ or << operation has been cast to a different essential type category.
4399 An expression which is the result of a ~ or << operation has been cast to a wider type.
Rule-11.1 Required Conversions shall not be performed between a pointer to a function and any other type
QacDescription
0302 [u] Cast between a pointer to function and a floating type.
0305 [I] Cast between a pointer to function and an integral type.
0307 [u] Cast between a pointer to object and a pointer to function.
0313 Casting to different function pointer type.
Rule-11.2 Required Conversions shall not be performed between a pointer to an incomplete type and any other type
QacDescription
0308 Non-portable cast involving pointer to an incomplete type.
0323 [u] Cast between a pointer to incomplete type and a floating type.
0324 [u] Cast between a pointer to incomplete type and an integral type.
0325 [u] Cast between a pointer to incomplete type and a pointer to function.
Rule-11.3 Required A cast shall not be performed between a pointer to object type and a pointer to a different object type
QacDescription
0310 Casting to different object pointer type.
3305 Pointer cast to stricter alignment.
Rule-11.4 Advisory A conversion should not be performed between a pointer to object and an integer type
QacDescription
0303 [I] Cast between a pointer to volatile object and an integral type.
0306 [I] Cast between a pointer to object and an integral type.
0360 An expression of pointer type is being converted to type _Bool on assignment.
0361 An expression of pointer type is being cast to type _Bool.
0362 An expression of essentially Boolean type is being cast to a pointer.
Rule-11.5 Advisory A conversion should not be performed from pointer to void into pointer to object
QacDescription
0316 [I] Cast from a pointer to void to a pointer to object type.
0317 [I] Implicit conversion from a pointer to void to a pointer to object type.
Rule-11.6 Required A cast shall not be performed between pointer to void and an arithmetic type
QacDescription
0326 [I] Cast between a pointer to void and an integral type.
0327 [I] Cast between a pointer to void and an floating type.
Rule-11.7 Required A cast shall not be performed between pointer to object and a non-integer arithmetic type
QacDescription
0301 [u] Cast between a pointer to object and a floating type.
0328 [u] Cast between a pointer to object and an essential type other than signed/unsigned.
Rule-11.8 Required A cast shall not remove any const or volatile qualification from the type pointed to by a pointer
QacDescription
0311 Dangerous pointer cast results in loss of const qualification.
0312 Dangerous pointer cast results in loss of volatile qualification.
Rule-11.9 Required The macro NULL shall be the only permitted form of integer null pointer constant
QacDescription
3003 This character constant is being interpreted as a NULL pointer constant.
3004 This integral constant expression is being interpreted as a NULL pointer constant.
Rule-12.1 Advisory The precedence of operators within expressions should be made explicit
QacDescription
3389 Extra parentheses recommended to clarify the ordering of a % operator and another arithmetic operator (* / % + -).
3391 Extra parentheses recommended. A conditional operation is the operand of another conditional operator.
3392 Extra parentheses recommended. A shift, relational or equality operation is the operand of a second identical operator.
3394 Extra parentheses recommended. A shift, relational or equality operation is the operand of a different operator with the same precedence.
3395 Extra parentheses recommended. A * or / operation is the operand of a + or - operator.
3396 Extra parentheses recommended. A binary operation is the operand of a conditional operator.
3397 Extra parentheses recommended. A binary operation is the operand of a binary operator with different precedence.
Rule-12.2 Required 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 type of the left hand operand
QacDescription
0499 Right operand of shift operator is greater than or equal to the width of the essential type of the left operand.
2790 Constant: Right hand operand of shift operator is negative or too large.
2791 Definite: Right hand operand of shift operator is negative or too large.
2792 Apparent: Right hand operand of shift operator is negative or too large.
Rule-12.3 Advisory The comma operator should not be used
QacDescription
3417 The comma operator has been used outside a 'for' statement.
3418 The comma operator has been used in a 'for' statement.
Rule-12.4 Advisory Evaluation of constant expressions should not lead to unsigned integer wrap-around
QacDescription
2910 Constant: Wraparound in unsigned arithmetic operation.
Rule-12.5 Mandatory The sizeof operator shall not have an operand which is a function parameter declared as 'array of type'
QacDescription
1321 Operand of sizeof is a function parameter of array type.
Rule-13.1 Required Initializer lists shall not contain persistent side-effects
QacDescription
3421 Expression with possible side effects is used in an initializer list.
Rule-13.2 Required The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders
QacDescription
0400 [U] '%s' is modified more than once between sequence points - evaluation order unspecified.
0401 [U] '%s' may be modified more than once between sequence points - evaluation order unspecified.
0402 [U] '%s' is modified and accessed between sequence points - evaluation order unspecified.
0403 [U] '%s' may be modified and accessed between sequence points - evaluation order unspecified.
0404 More than one read access to volatile objects between sequence points.
0405 More than one modification of volatile objects between sequence points.
Rule-13.3 Advisory A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator
QacDescription
3440 Using the value resulting from a ++ or -- operation.
Rule-13.4 Advisory The result of an assignment operator should not be used
QacDescription
3226 The result of an assignment is being used in an arithmetic operation or another assigning operation.
3326 The result of an assignment is being used in a logical operation.
Rule-13.5 Required The right hand operand of a logical && or || operator shall not contain persistent side effects
QacDescription
3415 Right hand operand of '&&' or '||' is an expression with possible side effects.
Rule-13.6 Mandatory The operand of the sizeof operator shall not contain any expression which has potential side-effects
QacDescription
0945 [C99] Operand of sizeof is an expression of variable length array type with side effects.
3307 The operand of 'sizeof' is an expression with implied side effects, but they will not be evaluated.
Rule-14.1 Required A loop counter shall not have essentially floating type
QacDescription
3339 Floating point variable used as 'while' loop control variable.
3340 Floating point variable used as 'for' loop control variable.
3342 Controlling expression of 'for' loop is a floating point comparison.
Rule-14.2 Required A for loop shall be well-formed
QacDescription
2461 Loop control variable in this 'for' statement, %s, has file scope.
2462 The variable initialized in the first expression of this 'for' statement is not the variable identified as the 'loop control variable' (%s).
2463 The variable incremented in the third expression of this 'for' statement is not the variable identified as the 'loop control variable' (%s).
2464 Loop control variable, %s, modified twice in for-loop header.
2467 Loop control variable in this 'for' statement, %s, is not modified inside loop.
2468 Loop control variable in this 'for' statement, %s, is not modified inside loop but has file scope.
2469 Loop control variable in this 'for' statement, %s, is modified in the body of the loop.
2471 Unable to identify a loop control variable.
2472 More than one possible loop control variable.
Rule-14.3 Required Controlling expressions shall not be invariant
QacDescription
2741 This 'if' controlling expression is a constant expression and its value is 'true'.
2742 This 'if' controlling expression is a constant expression and its value is 'false'.
2990 The value of this loop controlling expression is always 'true'.
2991 The value of this 'if' controlling expression is always 'true'.
2992 The value of this 'if' controlling expression is always 'false'.
2993 The value of this 'do - while' loop controlling expression is always 'false'. The loop will only be executed once.
2994 The value of this 'while' or 'for' loop controlling expression is always 'false'. The loop will not be entered.
2997 The first operand of this conditional operator is always 'true'.
2998 The first operand of this conditional operator is always 'false'.
3493 The first operand of this conditional operator is always constant 'true'.
3494 The first operand of this conditional operator is always constant 'false'.
Rule-14.4 Required The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type
QacDescription
3344 Controlling expression is not an 'essentially Boolean' expression.
Rule-15.1 Advisory The goto statement should not be used
QacDescription
2001 A 'goto' statement has been used.
Rule-15.2 Required The goto statement shall jump to a label declared later in the same function
QacDescription
3310 This 'goto' statement involves a backward jump.
Rule-15.3 Required Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement
QacDescription
3327 This goto statement references a label that is declared in a separate block.
Rule-15.4 Advisory There should be no more than one break or goto statement used to terminate any iteration statement
QacDescription
0771 More than one 'break' statement has been used to terminate this iteration statement.
Rule-15.5 Advisory A function should have a single point of exit at the end
QacDescription
2889 This function has more than one 'return' path.
Rule-15.6 Required The body of an iteration-statement or a selection-statement shall be a compound-statement
QacDescription
2212 Body of control statement is not enclosed within braces.
2214 Body of control statement is on the same line and is not enclosed within braces.
2218 Body of switch statement is not enclosed within braces.
2219 Body of switch statement is on the same line and is not enclosed within braces.
3402 Braces are needed to clarify the structure of this 'if'-'if'-'else' statement.
Rule-15.7 Required All if ... else if constructs shall be terminated with an else statement
QacDescription
2004 No concluding 'else' exists in this 'if'-'else'-'if' statement.
2013 This 'if .. else if ' construct 'else' statement is empty.
Rule-16.1 Required All switch statements shall be well-formed
QacDescription
2008 Code statements precede the first label in this 'switch' construct.
3234 Declarations precede the first label in this 'switch' construct.
Rule-16.2 Required A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement
QacDescription
2019 'Switch' label is located within a nested code block.
Rule-16.3 Required An unconditional break statement shall terminate every switch-clause
QacDescription
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
2020 Final 'switch' clause does not end with an explicit 'jump' statement.
Rule-16.4 Required Every switch statement shall have a default label
QacDescription
2002 No 'default' label found in this 'switch' statement.
2016 This 'switch' statement 'default' clause is empty.
Rule-16.5 Required A default label shall appear as either the first or the last switch label of a switch statement
QacDescription
2012 This 'default' label is neither the first nor the last label within the 'switch' block.
Rule-16.6 Required Every switch statement shall have at least two switch-clauses
QacDescription
3315 This 'switch' statement is redundant.
Rule-16.7 Required A switch-expression shall not have essentially Boolean type
QacDescription
0735 Switch expression is of essentially Boolean type.
Rule-17.1 Required The features of shall not be used
QacDescription
5130 Use of standard header file .
1337 Function defined with a variable number of parameters.
Rule-17.2 Required Functions shall not call themselves, either directly or indirectly
QacDescription
3670 Recursive call to function containing this call.
1520 Functions are indirectly recursive.
Rule-17.3 Mandatory A function shall not be declared implicitly
QacDescription
3335 No function declaration. Implicit declaration inserted: 'extern int %s();'.
Rule-17.4 Mandatory All exit paths from a function with non-void return type shall have an explicit return statement with an expression
QacDescription
0745 [U] 'return;' found in '%s()', which has been defined with a non-'void' return type.
2887 Function 'main' ends with an implicit 'return' statement.
2888 This function has been declared with a non-void 'return' type but ends with an implicit 'return ;' statement.
3113 [U] 'return' statement includes no expression but function '%s()' is implicitly of type 'int'.
3114 [U] Function '%s()' is implicitly of type 'int' but ends without returning a value.
Rule-17.5 Advisory The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements
QacDescription
2781 Definite: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.
2782 Apparent: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.
2783 Suspicious: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.
2784 Possible: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.
Rule-17.6 Mandatory The declaration of an array parameter shall not contain the static keyword between the [ ]
QacDescription
1058 [C99] The keyword 'static' is used in the declaration of a function parameter of array type.
Rule-17.7 Required The value returned by a function having non-void return type shall be used
QacDescription
3200 '%s' returns a value which is not being used.
Rule-17.8 Advisory A function parameter should not be modified
QacDescription
1338 The parameter '%s' is being modified.
1339 Evaluating the address of the parameter '%s'.
1340 Storing the address of the parameter '%s' in a constant pointer.
Rule-18.1 Required A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand
QacDescription
2840 Constant: Dereference of an invalid pointer value.
2841 Definite: Dereference of an invalid pointer value.
2842 Apparent: Dereference of an invalid pointer value.
2930 Constant: Computing an invalid pointer value.
2931 Definite: Computing an invalid pointer value.
2932 Apparent: Computing an invalid pointer value.
Rule-18.2 Required Subtraction between pointers shall only be applied to pointers that address elements of the same array
QacDescription
2668 Subtraction of a pointer to an array and a pointer to a non array.
2761 Definite: Subtracting pointers that address different objects.
2762 Apparent: Subtracting pointers that address different objects.
Rule-18.3 Required The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object
QacDescription
2669 Comparison of a pointer to an array and a pointer to a non array.
2771 Definite: Comparing pointers that address different objects.
2772 Apparent: Comparing pointers that address different objects.
Rule-18.4 Advisory The +, -, += and -= operators should not be applied to an expression of pointer type
QacDescription
0488 Performing pointer arithmetic.
Rule-18.5 Advisory Declarations should contain no more than two levels of pointer nesting
QacDescription
3260 Typedef defined with more than 2 levels of indirection.
3261 Member of struct/union defined with more than 2 levels of indirection.
3262 Object defined or declared with more than 2 levels of indirection.
3263 Function defined or declared with a return type which has more than 2 levels of indirection.
Rule-18.6 Required The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist
QacDescription
3217 Address of automatic object exported to a pointer with linkage or wider scope.
3225 Address of automatic object exported using a function parameter.
3230 Address of automatic object assigned to local pointer with static storage duration.
4140 Address of automatic object exported in function return value.
Rule-18.7 Required Flexible array members shall not be declared
QacDescription
1060 [C99] A flexible array member has been declared.
Rule-18.8 Required Variable-length array types shall not be used
QacDescription
1051 [C99] A variable length array has been declared.
1052 [C99] A variable length array of unspecified size has been declared.
Rule-19.1 Mandatory An object shall not be assigned or copied to an overlapping object
QacDescription
0681 [U] Assignment between two incompatible members of the same union.
2776 Definite: Copy between overlapping objects.
2777 Apparent: Copy between overlapping objects.
Rule-19.2 Advisory The union keyword should not be used
QacDescription
0750 A union type specifier has been defined.
0759 An object of union type has been defined.
Rule-2.1 Required A project shall not contain unreachable code
QacDescription
0594 Negative 'case' label expression is incompatible with unsigned controlling expression in 'switch' statement.
1460 'Switch' label value, %s, not contained in enum type.
2744 This 'while' or 'for' loop controlling expression is a constant expression and its value is 'false'. The loop will not be entered.
2880 This code is unreachable.
2882 This 'switch' statement will bypass the initialization of local variables.
3219 Static function '%s()' is not used within this translation unit.
1503 The function '%1s' is defined but is not used within this project.
Rule-2.2 Required There shall be no dead code
QacDescription
2980 The value of this function parameter is never used before being modified.
2981 This initialization is redundant. The value of this object is never used before being modified.
2982 This assignment is redundant. The value of this object is never used before being modified.
2983 This assignment is redundant. The value of this object is never subsequently used.
2985 This operation is redundant. The value of the result is always that of the left-hand operand.
2986 This operation is redundant. The value of the result is always that of the right-hand operand.
2987 This function call produces no side effects and is redundant.
2995 The result of this logical operation is always 'true'.
2996 The result of this logical operation is always 'false'.
3110 The left-hand operand of this ',' has no side effects.
3112 This statement has no side-effect - it can be removed.
3404 Statement contains a redundant * operator at top level. *p++ means *(p++) not (*p)++.
3422 Statement contains a redundant operator at top level.
3423 Statement contains a redundant cast at top level.
3424 Statement contains a redundant & or | at top level.
3425 One branch of this conditional operation is a redundant expression.
3426 Right hand side of comma expression has no side effect and its value is not used.
3427 Right hand side of logical operator has no side effect and its value is not used.
Rule-2.3 Advisory A project should not contain unused type declarations
QacDescription
3205 The identifier '%s' is not used and could be removed.
Rule-2.4 Advisory A project should not contain unused tag declarations
QacDescription
3213 The tag '%s' is not used and could be removed.
1755 The tag '%1s' is declared but not used within this project.
Rule-2.5 Advisory A project should not contain unused macro declarations
QacDescription
3214 The macro '%s' is not used and could be removed.
Rule-2.6 Advisory A function should not contain unused label declarations
QacDescription
3202 The label '%s:' is not used in this function and could be removed.
Rule-2.7 Advisory There should be no unused parameters in functions
QacDescription
3206 The parameter '%s' is not used in this function.
Rule-20.1 Advisory #include directives should only be preceded by preprocessor directives or comments
QacDescription
5087 Use of #include directive after code fragment.
Rule-20.10 Advisory The # and ## preprocessor operators should not be used
QacDescription
0341 Using the stringify operator '#'.
0342 Using the glue operator '##'.
Rule-20.11 Required A macro parameter immediately following a # operator shall not immediately be followed by a ## operator
QacDescription
0892 This macro parameter is preceded by '#' and followed by '##'.
Rule-20.12 Required A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators
QacDescription
0893 Macro parameter '%s' is inconsistently subject to macro replacement.
Rule-20.13 Required A line whose first token is # shall be a valid preprocessing directive
QacDescription
3115 Unrecognized preprocessing directive has been ignored because of conditional inclusion directives.
Rule-20.14 Required All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related
QacDescription
3317 '#if...' not matched by '#endif' in included file. This is probably an error.
3318 '#else'/'#elif'/'#endif' in included file matched '#if...' in parent file. This is probably an error.
Rule-20.2 Required The ', " or \ characters and the /* or // character sequences shall not occur in a header file name
QacDescription
0813 [U] Using any of the characters ' " or /* in '#include <%s>' gives undefined behaviour.
0814 [U] Using the characters ' or /* in '#include "%s"' gives undefined behaviour.
0831 [E] Use of '\\' in this '#include' line is a PC extension - this usage is non-portable.
Rule-20.3 Required The #include directive shall be followed by either a or "filename" sequence
QacDescription
0817 [S] Closing quote or bracket '>' missing from include filename.
0821 [C] '#include' does not identify a header or source file that can be processed.
0840 [E] Extra tokens at end of #include directive.
Rule-20.4 Required A macro shall not be defined with the same name as a keyword
QacDescription
3439 Macro redefines a keyword.
3468 The name of this macro is a reserved identifier in C90 and a keyword in C99.
Rule-20.5 Advisory #undef should not be used
QacDescription
0841 Using '#undef'.
Rule-20.6 Required Tokens that look like a preprocessing directive shall not occur within a macro argument
QacDescription
0853 [U] Macro arguments contain a sequence of tokens that has the form of a preprocessing directive.
Rule-20.7 Required Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses
QacDescription
3430 Macro argument expression may require parentheses.
3432 Simple macro argument expression is not parenthesized.
Rule-20.8 Required The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1
QacDescription
0894 '#%s' directive controlling expression does not evaluate to zero or one.
Rule-20.9 Required All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation
QacDescription
3332 The macro '%s' used in this '#if' or '#elif' expression is not defined.
Rule-21.1 Required #define and #undef shall not be used on a reserved identifier or reserved macro name
QacDescription
0603 [U] The macro identifier '%s' is reserved.
0836 [U] Definition of macro named 'defined'.
0848 [U] Attempting to #undef '%s', which is a predefined macro name.
0854 [U] Attempting to #define '%s', which is a predefined macro name.
4600 The macro '%1s' is also defined in '<%2s>'.
4601 The macro '%1s' is the name of an identifier in '<%2s>'.
4620 The macro '%1s' may also be defined as a macro in '<%2s>'.
4621 The macro '%1s' may also be defined as a typedef in '<%2s>'.
Rule-21.10 Required The Standard Library time and date functions shall not be used
QacDescription
5127 Use of standard header file .
Rule-21.11 Required The standard header file shall not be used
QacDescription
5131 Use of standard header file .
Rule-21.12 Advisory The exception handling features of should not be used
QacDescription
5136 Use of exception handling identifier: feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag or fetestexcept.
Rule-21.13 Mandatory Any value passed to a function in shall be representable as an unsigned char or be the value EOF
QacDescription
2796 Definite: Calling a standard library character handling function with an invalid character value.
2797 Apparent: Calling a standard library character handling function with an invalid character value.
Rule-21.14 Required The Standard Library function memcmp shall not be used to compare null terminated strings
QacDescription
2785 Constant: Null terminated string is being passed as argument to Standard Library function memcmp.
2786 Definite: Null terminated string is being passed as argument to Standard Library function memcmp.
Rule-21.15 Required The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types
QacDescription
1487 Comparing the representations of objects of different types.
1495 Destination and source objects have incompatible types.
1496 Destination and source objects may have incompatible types.
Rule-21.16 Required The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type
QacDescription
1488 Comparison of a struct object representation.
1489 Comparison of a union object representation.
1490 Comparison of a floating point object representation.
1491 Comparison of an object representation.
1497 Comparison of a string object representation.
Rule-21.17 Mandatory Use of the string handling functions from shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters
QacDescription
2835 Constant: Non null terminated string used in a string function.
2836 Definite: Non null terminated string used in a string function.
Rule-21.18 Mandatory The size_t argument passed to any function in shall have an appropriate value
QacDescription
2840 Constant: Dereference of an invalid pointer value.
2841 Definite: Dereference of an invalid pointer value.
2842 Apparent: Dereference of an invalid pointer value.
2865 Constant: Using 0 as size parameter of a function call.
2866 Definite: Using 0 as size parameter of a function call.
2867 Apparent: Using 0 as size parameter of a function call.
2868 Suspicious: Using 0 as size parameter of a function call.
2869 Possible: Using 0 as size parameter of a function call.
Rule-21.19 Mandatory The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type
QacDescription
1492 The result of library function '%s' is used to modify the referenced object.
1493 The result of library function '%s' is used as a pointer to a modifiable object.
1494 The result of library function '%s' might be modified.
1498 The string referenced by type 'struct lconv' member '%s' is being modified.
Rule-21.2 Required A reserved identifier or macro name shall not be declared
QacDescription
0602 [U] The identifier '%s' is reserved for use by the library.
4602 The identifier '%1s' is declared as a macro in '<%2s>'.
4603 The object/function '%1s'is being defined with the same name as an ordinary identifier defined in '<%2s>'.
4604 The object/function '%1s' is being declared with the same name as an ordinary identifier defined in '<%2s>'.
4605 The typedef '%1s' is also defined in '<%2s>'.
4606 The typedef '%1s' has the same name as another ordinary identifier in '<%2s>'.
4607 The enum constant '%1s' has the same name as another ordinary identifier in '<%2s>'.
4608 The tag '%1s' is also defined in '<%2s>'.
Rule-21.20 Mandatory The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function
QacDescription
2681 Definite: Using an invalidated value '%s' returned from a Standard Library function.
2682 Apparent: Using an invalidated value '%s' returned from a Standard Library function.
Rule-21.3 Required The memory allocation and deallocation functions of shall not be used
QacDescription
5118 Use of memory allocation or deallocation function: calloc, malloc, realloc or free.
Rule-21.4 Required The standard header file shall not be used
QacDescription
5132 Use of standard header file .
Rule-21.5 Required The standard header file shall not be used
QacDescription
5123 Use of standard header file .
Rule-21.6 Required The Standard Library input/output functions shall not be used
QacDescription
5124 The Standard Library input/output functions shall not be used
Rule-21.7 Required The atof, atoi, atol and atoll functions of shall not be used
QacDescription
5125 Use of function: atof, atoi, atol or atoll.
Rule-21.8 Required The library functions abort, exit and system of shall not be used
QacDescription
5126 Use of function: abort, exit or system.
5128 Use of function: getenv.
Rule-21.9 Required The library functions bsearch and qsort of shall not be used
QacDescription
5135 Use of function: bsearch or qsort.
Rule-22.1 Required All resources obtained dynamically by means of Standard Library functions shall be explicitly released
QacDescription
2701 Definite: Opened file is not closed.
2702 Apparent: Opened file is not closed.
2706 Definite: Allocated memory is not deallocated.
2707 Apparent: Allocated memory is not deallocated.
2736 Definite: Created resource is not destroyed.
2737 Apparent: Created resource is not destroyed.
Rule-22.10 Required The value of errno shall only be tested when the last function to be called was an errno-setting-function
QacDescription
2503 Testing of 'errno' is not immediately preceded by a call to an 'errno' setting function.
Rule-22.2 Mandatory A block of memory shall only be freed if it was allocated by means of a Standard Library function
QacDescription
2721 Definite: Deallocation of non dynamic memory.
2722 Apparent: Deallocation of non dynamic memory.
Rule-22.3 Required The same file shall not be open for read and write access at the same time on different streams
QacDescription
2691 Definite: The same file will be open with write access and another mode.
2692 Apparent: The same file will be open with write access and another mode.
2693 Suspicious: The same file will be open with write access and another mode.
Rule-22.4 Mandatory There shall be no attempt to write to a stream which has been opened as read-only
QacDescription
2686 Definite: Writing to a file opened for reading.
2687 Apparent: Writing to a file opened for reading.
2688 Suspicious: Writing to a file opened for reading.
Rule-22.5 Mandatory A pointer to a FILE object shall not be dereferenced
QacDescription
1485 A pointer to a FILE object is dereferenced.
1486 A pointer to a FILE object is converted to a different type.
Rule-22.6 Mandatory The value of a pointer to a FILE shall not be used after the associated stream has been closed
QacDescription
2696 Definite: Attempt to access a file which has been closed.
2697 Apparent: Attempt to access a file which has been closed.
Rule-22.7 Required The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF
QacDescription
2671 Definite: The value being compared with macro EOF does not originate from an EOF returning function.
2676 Definite: The value originating from an EOF returning function was modified before being compared with macro EOF.
Rule-22.8 Required The value of errno shall be set to zero prior to a call to an errno-setting-function
QacDescription
2500 Call to '%s' is not immediately preceded by the zeroing of 'errno'.
Rule-22.9 Required The value of errno shall be tested against zero after calling an errno-setting-function
QacDescription
2501 Call to '%s' is not immediately followed by the testing of 'errno'.
Rule-3.1 Required The character sequences /* and // shall not be used within a comment.
QacDescription
3108 Nested comments are not recognized in the ISO standard.
Rule-3.2 Required Line-splicing shall not be used in // comments.
QacDescription
5134 C++ style comment uses line splicing.
Rule-4.1 Required Octal and hexadecimal escape sequences shall be terminated
QacDescription
3636 Octal escape sequence '%s' is not terminated.
3637 Hexadecimal escape sequence '%s' is not terminated.
Rule-4.2 Advisory Trigraphs should not be used
QacDescription
3601 Trigraphs (??x) are an ISO feature.
Rule-5.1 Required External identifiers shall be distinct
QacDescription
0777 [U] External identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.
Rule-5.2 Required Identifiers declared in the same scope and name space shall be distinct
QacDescription
0779 [U] Identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.
Rule-5.3 Required An identifier declared in an inner scope shall not hide an identifier declared in an outer scope
QacDescription
0795 Identifier matches other identifier(s) (e.g. '%s') in an outer scope within the specified number of significant characters.
2547 This declaration of tag '%s' hides a more global declaration.
3334 This declaration of '%s' hides a more global declaration.
Rule-5.4 Required Macro identifiers shall be distinct
QacDescription
0788 This identifier, '%s', is used as both a macro name and a function-like macro parameter name.
0791 [U] Macro identifier does not differ from other macro identifier(s) (e.g. '%s') within the specified number of significant characters.
Rule-5.5 Required Identifiers shall be distinct from macro names
QacDescription
0784 Identifier '%s' is also used as a macro name.
0785 Identifier matches other macro name(s) (e.g. '%s') in first 31 characters.
0786 Identifier matches other macro name(s) (e.g. '%s') in first 63 characters.
0787 Identifier does not differ from other macro name(s) (e.g. '%s') within the specified number of significant characters.
Rule-5.6 Required A typedef name shall be a unique identifier
QacDescription
1506 The identifier '%1s' is declared as a typedef and is used elsewhere for a different kind of declaration.
1507 '%1s' is used as a typedef for different types.
1508 The typedef '%1s' is declared in more than one location.
Rule-5.7 Required A tag name shall be a unique identifier
QacDescription
2547 This declaration of tag '%s' hides a more global declaration.
1750 '%1s' has multiple definitions.
Rule-5.8 Required Identifiers that define objects or functions with external linkage shall be unique
QacDescription
1525 Object/function with external linkage has same identifier as another object/function with internal linkage.
1526 Object with no linkage has same identifier as another object/function with external linkage.
1756 External identifier '%1s' shall be unique.
Rule-5.9 Advisory Identifiers that define objects or functions with internal linkage should be unique
QacDescription
1525 Object/function with external linkage has same identifier as another object/function with internal linkage.
1527 Object/function with internal linkage has same identifier as another object/function with internal linkage.
1528 Object with no linkage has same identifier as another object/function with internal linkage.
Rule-6.1 Required Bit-fields shall only be declared with an appropriate type
QacDescription
0634 [I] Bit-fields in this struct/union have not been declared explicitly as unsigned or signed.
0635 [E] Bit-fields in this struct/union have been declared with types other than int, signed int, unsigned int or _Bool.
Rule-6.2 Required Single-bit named bit fields shall not be of a signed type
QacDescription
3660 Named bit-field consisting of a single bit declared with a signed type.
Rule-7.1 Required Octal constants shall not be used
QacDescription
0336 Macro defined as an octal constant.
0339 Octal constant used.
Rule-7.2 Required A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type
QacDescription
1281 Integer literal constant is of an unsigned type but does not include a "U" suffix.
Rule-7.3 Required The lowercase character "l" shall not be used in a literal suffix
QacDescription
1280 A lowercase letter L (l) has been used in an integer or floating suffix.
Rule-7.4 Required A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"
QacDescription
0752 String literal passed as argument to function whose parameter is not a 'pointer to const'.
0753 String literal assigned to pointer which is not a 'pointer to const'.
Rule-8.1 Required Types shall be explicitly specified
QacDescription
2050 The 'int' type specifier has been omitted from a function declaration.
2051 The 'int' type specifier has been omitted from an object declaration.
1525 Object/function with external linkage has same identifier as another object/function with internal linkage.
Rule-8.10 Required An inline function shall be declared with the static storage class
QacDescription
3240 inline function '%s' is being defined with external linkage.
3243 inline function '%s' is also an 'external definition'.
Rule-8.11 Advisory When an array with external linkage is declared, its size should be explicitly specified
QacDescription
3684 Array declared with unknown size.
Rule-8.12 Required Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique
QacDescription
0724 The value of this implicitly-specified enumeration constant is not unique.
Rule-8.13 Advisory A pointer should point to a const-qualified type whenever possible
QacDescription
3673 The object addressed by the pointer parameter '%s' is not modified and so the pointer could be of type 'pointer to const'.
Rule-8.14 Required The restrict type qualifier shall not be used
QacDescription
1057 [C99] The keyword 'restrict' has been used.
Rule-8.2 Required Function types shall be in prototype form with named parameters
QacDescription
1335 Parameter identifiers missing in function prototype declaration.
1336 Parameter identifiers missing in declaration of a function type.
3001 Function has been declared with an empty parameter list.
3002 Defining '%s()' with an identifier list and separate parameter declarations is an obsolescent feature.
3007 "void" has been omitted when defining a function with no parameters.
Rule-8.3 Required All declarations of an object or function shall use the same names and type qualifiers
QacDescription
0624 Function '%s' is declared using typedefs which are different to those in a previous declaration.
1330 The parameter identifiers in this function declaration differ from those in a previous declaration.
3675 Function parameter declared with type qualification which differs from previous declaration.
Rule-8.4 Required A compatible declaration shall be visible when an object or function with external linkage is defined
QacDescription
3408 '%s' has external linkage and is being defined without any previous declaration.
Rule-8.5 Required An external object or function shall be declared once in one and only one file
QacDescription
3449 Multiple declarations of external object or function.
3451 The global identifier '%s' has been declared in more than one file.
1513 Identifier '%1s' with external linkage has separate non-defining declarations in more than one location.
Rule-8.6 Required An identifier with external linkage shall have exactly one external definition
QacDescription
0630 [U] More than one definition of '%s' (with external linkage).
3406 Object/function '%s', with external linkage, has been defined in a header file.
1509 '%1s' has external linkage and has multiple definitions.
1752 The object '%1s' with external linkage is declared but not defined within this project.
1753 The function '%1s' with external linkage is declared but not defined within this project.
Rule-8.7 Advisory Functions and objects should not be defined with external linkage if they are referenced in only one translation unit
QacDescription
1504 The object '%1s' is only referenced in the translation unit where it is defined.
1505 The function '%1s' is only referenced in the translation unit where it is defined.
1531 The object '%1s' is referenced in only one translation unit - but not the one in which it is defined.
1532 The function '%1s' is only referenced in one translation unit - but not the one in which it is defined.
Rule-8.8 Required The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage
QacDescription
3224 This identifier has previously been declared with internal linkage but is not declared here with the static storage class specifier.
Rule-8.9 Advisory An object should be defined at block scope if its identifier only appears in a single function
QacDescription
3218 File scope static, '%s', is only accessed in one function.
1514 The object '%1s' is only referenced by function '%2s', in the translation unit where it is defined
1533 The object '%1s' is only referenced by function '%2s'.
Rule-9.1 Mandatory The value of an object with automatic storage duration shall not be read before it has been set
QacDescription
2883 This 'goto' statement will always bypass the initialization of local variables.
2961 Definite: Using value of uninitialized automatic object '%s'.
2962 Apparent: Using value of uninitialized automatic object '%s'.
2971 Definite: Passing address of uninitialized object '%s' to a function parameter declared as a pointer to const.
2972 Apparent: Passing address of uninitialized object '%s' to a function parameter declared as a pointer to const.
Rule-9.2 Required The initializer for an aggregate or union shall be enclosed in braces
QacDescription
0693 Struct initializer is missing the optional {.
0694 Array initializer is missing the optional {.
Rule-9.3 Required Arrays shall not be partially initialized
QacDescription
0686 Array has fewer initializers than its declared size. Default initialization is applied to the remainder of the array elements.
Rule-9.4 Required An element of an object shall not be initialized more than once
QacDescription
1397 Array element '%s' has already been initialized.
1398 Structure member '%s' has already been initialized.
1399 A union member has already been initialized.
Rule-9.5 Required Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly
QacDescription
3676 Designators are used to initialize an array of unspecified size.

GRP - Guideline Recategorization Plan

This section targets to provide an overview of Guidelines Recategorization Plan.

GuidelineDescriptionCategoryRevised Category
Dir-1.1 Any implementation-defined behaviour on which the output of the program depends shall be documented and understood Required Required
Dir-2.1 All source files shall compile without any compilation errors Required Disapplied
Dir-3.1 All code shall be traceable to documented requirements Required Disapplied
Dir-4.1 Run-time failures shall be minimized Required Required
Dir-4.10 Precautions shall be taken in order to prevent the contents of a header file being included more then once Required Required
Dir-4.11 The validity of values passed to library functions shall be checked Required Disapplied
Dir-4.12 Dynamic memory allocation shall not be used Required Disapplied
Dir-4.13 Functions which are designed to provide operations on a resource should be called in an appropriate sequence Advisory Disapplied
Dir-4.14 The validity of values received from external sources shall be checked Required Required
Dir-4.2 All usage of assembly language should be documented Advisory Advisory
Dir-4.3 Assembly language shall be encapsulated and isolated Required Required
Dir-4.4 Sections of code should not be "commented out" Advisory Disapplied
Dir-4.5 Identifiers in the same name space with overlapping visibility should be typographically unambiguous Advisory Disapplied
Dir-4.6 typedefs that indicate size and signedness should be used in place of the basic numerical types Advisory Advisory
Dir-4.7 If a function returns error information, then that error information shall be tested Required Disapplied
Dir-4.8 If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden Advisory Disapplied
Dir-4.9 A function should be used in preference to a function-like macro where they are interchangeable Advisory Disapplied
Rule-1.1 The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits Required Required
Rule-1.2 Language extensions should not be used Advisory Advisory
Rule-1.3 There shall be no occurrence of undefined or critical unspecified behaviour Required Required
Rule-10.1 Operands shall not be of an inappropriate essential type. Required Required
Rule-10.2 Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations Required Required
Rule-10.3 The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category. Required Required
Rule-10.4 Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category Required Required
Rule-10.5 The value of an expression should not be cast to an inappropriate essential type Advisory Advisory
Rule-10.6 The value of a composite expression shall not be assigned to an object with wider essential type Required Required
Rule-10.7 If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type Required Required
Rule-10.8 The value of a composite expression shall not be cast to a different essential type category or a wider essential type Required Required
Rule-11.1 Conversions shall not be performed between a pointer to a function and any other type Required Required
Rule-11.2 Conversions shall not be performed between a pointer to an incomplete type and any other type Required Required
Rule-11.3 A cast shall not be performed between a pointer to object type and a pointer to a different object type Required Required
Rule-11.4 A conversion should not be performed between a pointer to object and an integer type Advisory Advisory
Rule-11.5 A conversion should not be performed from pointer to void into pointer to object Advisory Advisory
Rule-11.6 A cast shall not be performed between pointer to void and an arithmetic type Required Required
Rule-11.7 A cast shall not be performed between pointer to object and a non-integer arithmetic type Required Required
Rule-11.8 A cast shall not remove any const or volatile qualification from the type pointed to by a pointer Required Required
Rule-11.9 The macro NULL shall be the only permitted form of integer null pointer constant Required Disapplied
Rule-12.1 The precedence of operators within expressions should be made explicit Advisory Advisory
Rule-12.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 type of the left hand operand Required Required
Rule-12.3 The comma operator should not be used Advisory Advisory
Rule-12.4 Evaluation of constant expressions should not lead to unsigned integer wrap-around Advisory Advisory
Rule-12.5 The sizeof operator shall not have an operand which is a function parameter declared as 'array of type' Mandatory Mandatory
Rule-13.1 Initializer lists shall not contain persistent side-effects Required Required
Rule-13.2 The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders Required Required
Rule-13.3 A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator Advisory Disapplied
Rule-13.4 The result of an assignment operator should not be used Advisory Advisory
Rule-13.5 The right hand operand of a logical && or || operator shall not contain persistent side effects Required Required
Rule-13.6 The operand of the sizeof operator shall not contain any expression which has potential side-effects Mandatory Mandatory
Rule-14.1 A loop counter shall not have essentially floating type Required Required
Rule-14.2 A for loop shall be well-formed Required Required
Rule-14.3 Controlling expressions shall not be invariant Required Required
Rule-14.4 The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type Required Required
Rule-15.1 The goto statement should not be used Advisory Advisory
Rule-15.2 The goto statement shall jump to a label declared later in the same function Required Required
Rule-15.3 Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement Required Required
Rule-15.4 There should be no more than one break or goto statement used to terminate any iteration statement Advisory Advisory
Rule-15.5 A function should have a single point of exit at the end Advisory Disapplied
Rule-15.6 The body of an iteration-statement or a selection-statement shall be a compound-statement Required Required
Rule-15.7 All if ... else if constructs shall be terminated with an else statement Required Required
Rule-16.1 All switch statements shall be well-formed Required Required
Rule-16.2 A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement Required Required
Rule-16.3 An unconditional break statement shall terminate every switch-clause Required Required
Rule-16.4 Every switch statement shall have a default label Required Required
Rule-16.5 A default label shall appear as either the first or the last switch label of a switch statement Required Required
Rule-16.6 Every switch statement shall have at least two switch-clauses Required Required
Rule-16.7 A switch-expression shall not have essentially Boolean type Required Required
Rule-17.1 The features of shall not be used Required Required
Rule-17.2 Functions shall not call themselves, either directly or indirectly Required Required
Rule-17.3 A function shall not be declared implicitly Mandatory Mandatory
Rule-17.4 All exit paths from a function with non-void return type shall have an explicit return statement with an expression Mandatory Mandatory
Rule-17.5 The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements Advisory Advisory
Rule-17.6 The declaration of an array parameter shall not contain the static keyword between the [ ] Mandatory Mandatory
Rule-17.7 The value returned by a function having non-void return type shall be used Required Disapplied
Rule-17.8 A function parameter should not be modified Advisory Advisory
Rule-18.1 A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand Required Required
Rule-18.2 Subtraction between pointers shall only be applied to pointers that address elements of the same array Required Required
Rule-18.3 The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object Required Required
Rule-18.4 The +, -, += and -= operators should not be applied to an expression of pointer type Advisory Advisory
Rule-18.5 Declarations should contain no more than two levels of pointer nesting Advisory Advisory
Rule-18.6 The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist Required Required
Rule-18.7 Flexible array members shall not be declared Required Required
Rule-18.8 Variable-length array types shall not be used Required Required
Rule-19.1 An object shall not be assigned or copied to an overlapping object Mandatory Mandatory
Rule-19.2 The union keyword should not be used Advisory Advisory
Rule-2.1 A project shall not contain unreachable code Required Required
Rule-2.2 There shall be no dead code Required Required
Rule-2.3 A project should not contain unused type declarations Advisory Disapplied
Rule-2.4 A project should not contain unused tag declarations Advisory Advisory
Rule-2.5 A project should not contain unused macro declarations Advisory Disapplied
Rule-2.6 A function should not contain unused label declarations Advisory Advisory
Rule-2.7 There should be no unused parameters in functions Advisory Advisory
Rule-20.1 #include directives should only be preceded by preprocessor directives or comments Advisory Advisory
Rule-20.10 The # and ## preprocessor operators should not be used Advisory Advisory
Rule-20.11 A macro parameter immediately following a # operator shall not immediately be followed by a ## operator Required Required
Rule-20.12 A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators Required Required
Rule-20.13 A line whose first token is # shall be a valid preprocessing directive Required Required
Rule-20.14 All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related Required Required
Rule-20.2 The ', " or \ characters and the /* or // character sequences shall not occur in a header file name Required Required
Rule-20.3 The #include directive shall be followed by either a or "filename" sequence Required Required
Rule-20.4 A macro shall not be defined with the same name as a keyword Required Required
Rule-20.5 #undef should not be used Advisory Advisory
Rule-20.6 Tokens that look like a preprocessing directive shall not occur within a macro argument Required Required
Rule-20.7 Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses Required Required
Rule-20.8 The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1 Required Required
Rule-20.9 All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation Required Required
Rule-21.1 #define and #undef shall not be used on a reserved identifier or reserved macro name Required Required
Rule-21.10 The Standard Library time and date functions shall not be used Required Required
Rule-21.11 The standard header file shall not be used Required Required
Rule-21.12 The exception handling features of should not be used Advisory Advisory
Rule-21.13 Any value passed to a function in shall be representable as an unsigned char or be the value EOF Mandatory Mandatory
Rule-21.14 The Standard Library function memcmp shall not be used to compare null terminated strings Required Required
Rule-21.15 The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types Required Required
Rule-21.16 The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type Required Required
Rule-21.17 Use of the string handling functions from shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters Mandatory Mandatory
Rule-21.18 The size_t argument passed to any function in shall have an appropriate value Mandatory Mandatory
Rule-21.19 The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type Mandatory Mandatory
Rule-21.2 A reserved identifier or macro name shall not be declared Required Required
Rule-21.20 The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function Mandatory Mandatory
Rule-21.3 The memory allocation and deallocation functions of shall not be used Required Required
Rule-21.4 The standard header file shall not be used Required Required
Rule-21.5 The standard header file shall not be used Required Required
Rule-21.6 The Standard Library input/output functions shall not be used Required Required
Rule-21.7 The atof, atoi, atol and atoll functions of shall not be used Required Required
Rule-21.8 The library functions abort, exit and system of shall not be used Required Required
Rule-21.9 The library functions bsearch and qsort of shall not be used Required Required
Rule-22.1 All resources obtained dynamically by means of Standard Library functions shall be explicitly released Required Required
Rule-22.10 The value of errno shall only be tested when the last function to be called was an errno-setting-function Required Required
Rule-22.2 A block of memory shall only be freed if it was allocated by means of a Standard Library function Mandatory Mandatory
Rule-22.3 The same file shall not be open for read and write access at the same time on different streams Required Required
Rule-22.4 There shall be no attempt to write to a stream which has been opened as read-only Mandatory Mandatory
Rule-22.5 A pointer to a FILE object shall not be dereferenced Mandatory Mandatory
Rule-22.6 The value of a pointer to a FILE shall not be used after the associated stream has been closed Mandatory Mandatory
Rule-22.7 The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF Required Required
Rule-22.8 The value of errno shall be set to zero prior to a call to an errno-setting-function Required Required
Rule-22.9 The value of errno shall be tested against zero after calling an errno-setting-function Required Required
Rule-3.1 The character sequences /* and // shall not be used within a comment. Required Required
Rule-3.2 Line-splicing shall not be used in // comments. Required Required
Rule-4.1 Octal and hexadecimal escape sequences shall be terminated Required Required
Rule-4.2 Trigraphs should not be used Advisory Advisory
Rule-5.1 External identifiers shall be distinct Required Required
Rule-5.2 Identifiers declared in the same scope and name space shall be distinct Required Required
Rule-5.3 An identifier declared in an inner scope shall not hide an identifier declared in an outer scope Required Required
Rule-5.4 Macro identifiers shall be distinct Required Required
Rule-5.5 Identifiers shall be distinct from macro names Required Required
Rule-5.6 A typedef name shall be a unique identifier Required Required
Rule-5.7 A tag name shall be a unique identifier Required Required
Rule-5.8 Identifiers that define objects or functions with external linkage shall be unique Required Required
Rule-5.9 Identifiers that define objects or functions with internal linkage should be unique Advisory Advisory
Rule-6.1 Bit-fields shall only be declared with an appropriate type Required Required
Rule-6.2 Single-bit named bit fields shall not be of a signed type Required Required
Rule-7.1 Octal constants shall not be used Required Required
Rule-7.2 A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type Required Required
Rule-7.3 The lowercase character "l" shall not be used in a literal suffix Required Required
Rule-7.4 A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char" Required Required
Rule-8.1 Types shall be explicitly specified Required Required
Rule-8.10 An inline function shall be declared with the static storage class Required Required
Rule-8.11 When an array with external linkage is declared, its size should be explicitly specified Advisory Advisory
Rule-8.12 Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique Required Required
Rule-8.13 A pointer should point to a const-qualified type whenever possible Advisory Advisory
Rule-8.14 The restrict type qualifier shall not be used Required Required
Rule-8.2 Function types shall be in prototype form with named parameters Required Required
Rule-8.3 All declarations of an object or function shall use the same names and type qualifiers Required Required
Rule-8.4 A compatible declaration shall be visible when an object or function with external linkage is defined Required Required
Rule-8.5 An external object or function shall be declared once in one and only one file Required Required
Rule-8.6 An identifier with external linkage shall have exactly one external definition Required Required
Rule-8.7 Functions and objects should not be defined with external linkage if they are referenced in only one translation unit Advisory Disapplied
Rule-8.8 The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage Required Required
Rule-8.9 An object should be defined at block scope if its identifier only appears in a single function Advisory Advisory
Rule-9.1 The value of an object with automatic storage duration shall not be read before it has been set Mandatory Mandatory
Rule-9.2 The initializer for an aggregate or union shall be enclosed in braces Required Required
Rule-9.3 Arrays shall not be partially initialized Required Required
Rule-9.4 An element of an object shall not be initialized more than once Required Required
Rule-9.5 Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly Required Required

GCS - Guideline Compliance Summary

This section targets to provide an overview of Guidelines Compliance Summary.

GuidelineCategoryDescriptionCompliance
Dir-1.1 Required Any implementation-defined behaviour on which the output of the program depends shall be documented and understood Compliant

with deviations:
QacDescription
0292 [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.
0315 [I] Implicit conversion from a pointer to object type to a pointer to void.
0380 [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.
Dir-2.1 Required All source files shall compile without any compilation errors Disapplied
Dir-3.1 Required All code shall be traceable to documented requirements Disapplied
Dir-4.1 Required Run-time failures shall be minimized Compliant
Dir-4.10 Required Precautions shall be taken in order to prevent the contents of a header file being included more then once Compliant
Dir-4.11 Required The validity of values passed to library functions shall be checked Disapplied
Dir-4.12 Required Dynamic memory allocation shall not be used Disapplied
Dir-4.13 Advisory Functions which are designed to provide operations on a resource should be called in an appropriate sequence Disapplied
Dir-4.14 Required The validity of values received from external sources shall be checked Compliant
Dir-4.2 Advisory All usage of assembly language should be documented Compliant
Dir-4.3 Required Assembly language shall be encapsulated and isolated Compliant
Dir-4.4 Advisory Sections of code should not be "commented out" Disapplied
Dir-4.5 Advisory Identifiers in the same name space with overlapping visibility should be typographically unambiguous Disapplied
Dir-4.6 Advisory typedefs that indicate size and signedness should be used in place of the basic numerical types Compliant
Dir-4.7 Required If a function returns error information, then that error information shall be tested Disapplied
Dir-4.8 Advisory If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden Disapplied
Dir-4.9 Advisory A function should be used in preference to a function-like macro where they are interchangeable Disapplied
Rule-1.1 Required The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits Compliant
Rule-1.2 Advisory Language extensions should not be used Compliant
Rule-1.3 Required There shall be no occurrence of undefined or critical unspecified behaviour Compliant
Rule-10.1 Required Operands shall not be of an inappropriate essential type. Compliant
Rule-10.2 Required Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations Compliant
Rule-10.3 Required The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category. Compliant
Rule-10.4 Required Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category Compliant
Rule-10.5 Advisory The value of an expression should not be cast to an inappropriate essential type Compliant
Rule-10.6 Required The value of a composite expression shall not be assigned to an object with wider essential type Compliant
Rule-10.7 Required If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type Compliant
Rule-10.8 Required The value of a composite expression shall not be cast to a different essential type category or a wider essential type Compliant
Rule-11.1 Required Conversions shall not be performed between a pointer to a function and any other type Compliant
Rule-11.2 Required Conversions shall not be performed between a pointer to an incomplete type and any other type Compliant
Rule-11.3 Required A cast shall not be performed between a pointer to object type and a pointer to a different object type Compliant
Rule-11.4 Advisory A conversion should not be performed between a pointer to object and an integer type Compliant

with deviations:
QacDescription
0306 [I] Cast between a pointer to object and an integral type.
Rule-11.5 Advisory A conversion should not be performed from pointer to void into pointer to object Compliant
Rule-11.6 Required A cast shall not be performed between pointer to void and an arithmetic type Compliant
Rule-11.7 Required A cast shall not be performed between pointer to object and a non-integer arithmetic type Compliant
Rule-11.8 Required A cast shall not remove any const or volatile qualification from the type pointed to by a pointer Compliant
Rule-11.9 Required The macro NULL shall be the only permitted form of integer null pointer constant Disapplied
Rule-12.1 Advisory The precedence of operators within expressions should be made explicit Compliant
Rule-12.2 Required 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 type of the left hand operand Compliant
Rule-12.3 Advisory The comma operator should not be used Compliant
Rule-12.4 Advisory Evaluation of constant expressions should not lead to unsigned integer wrap-around Compliant
Rule-12.5 Mandatory The sizeof operator shall not have an operand which is a function parameter declared as 'array of type' Compliant
Rule-13.1 Required Initializer lists shall not contain persistent side-effects Compliant
Rule-13.2 Required The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders Compliant
Rule-13.3 Advisory A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator Disapplied
Rule-13.4 Advisory The result of an assignment operator should not be used Compliant
Rule-13.5 Required The right hand operand of a logical && or || operator shall not contain persistent side effects Compliant
Rule-13.6 Mandatory The operand of the sizeof operator shall not contain any expression which has potential side-effects Compliant
Rule-14.1 Required A loop counter shall not have essentially floating type Compliant
Rule-14.2 Required A for loop shall be well-formed Compliant
Rule-14.3 Required Controlling expressions shall not be invariant Compliant

with deviations:
QacDescription
2991 The value of this 'if' controlling expression is always 'true'.
2992 The value of this 'if' controlling expression is always 'false'.
2998 The first operand of this conditional operator is always 'false'.
3493 The first operand of this conditional operator is always constant 'true'.
3494 The first operand of this conditional operator is always constant 'false'.
Rule-14.4 Required The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type Compliant
Rule-15.1 Advisory The goto statement should not be used Compliant
Rule-15.2 Required The goto statement shall jump to a label declared later in the same function Compliant
Rule-15.3 Required Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement Compliant
Rule-15.4 Advisory There should be no more than one break or goto statement used to terminate any iteration statement Compliant
Rule-15.5 Advisory A function should have a single point of exit at the end Disapplied
Rule-15.6 Required The body of an iteration-statement or a selection-statement shall be a compound-statement Compliant
Rule-15.7 Required All if ... else if constructs shall be terminated with an else statement Compliant
Rule-16.1 Required All switch statements shall be well-formed Compliant
Rule-16.2 Required A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement Compliant
Rule-16.3 Required An unconditional break statement shall terminate every switch-clause Compliant
Rule-16.4 Required Every switch statement shall have a default label Compliant
Rule-16.5 Required A default label shall appear as either the first or the last switch label of a switch statement Compliant
Rule-16.6 Required Every switch statement shall have at least two switch-clauses Compliant
Rule-16.7 Required A switch-expression shall not have essentially Boolean type Compliant
Rule-17.1 Required The features of shall not be used Compliant
Rule-17.2 Required Functions shall not call themselves, either directly or indirectly Compliant
Rule-17.3 Mandatory A function shall not be declared implicitly Compliant
Rule-17.4 Mandatory All exit paths from a function with non-void return type shall have an explicit return statement with an expression Compliant
Rule-17.5 Advisory The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements Compliant
Rule-17.6 Mandatory The declaration of an array parameter shall not contain the static keyword between the [ ] Compliant
Rule-17.7 Required The value returned by a function having non-void return type shall be used Disapplied
Rule-17.8 Advisory A function parameter should not be modified Compliant
Rule-18.1 Required A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand Compliant
Rule-18.2 Required Subtraction between pointers shall only be applied to pointers that address elements of the same array Compliant
Rule-18.3 Required The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object Compliant
Rule-18.4 Advisory The +, -, += and -= operators should not be applied to an expression of pointer type Compliant
Rule-18.5 Advisory Declarations should contain no more than two levels of pointer nesting Compliant
Rule-18.6 Required The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist Compliant
Rule-18.7 Required Flexible array members shall not be declared Compliant
Rule-18.8 Required Variable-length array types shall not be used Compliant
Rule-19.1 Mandatory An object shall not be assigned or copied to an overlapping object Compliant
Rule-19.2 Advisory The union keyword should not be used Compliant
Rule-2.1 Required A project shall not contain unreachable code Compliant

with deviations:
QacDescription
1503 The function '%1s' is defined but is not used within this project.
Rule-2.2 Required There shall be no dead code Compliant

with deviations:
QacDescription
2982 This assignment is redundant. The value of this object is never used before being modified.
2983 This assignment is redundant. The value of this object is never subsequently used.
2985 This operation is redundant. The value of the result is always that of the left-hand operand.
2986 This operation is redundant. The value of the result is always that of the right-hand operand.
2995 The result of this logical operation is always 'true'.
2996 The result of this logical operation is always 'false'.
3112 This statement has no side-effect - it can be removed.
Rule-2.3 Advisory A project should not contain unused type declarations Disapplied
Rule-2.4 Advisory A project should not contain unused tag declarations Compliant
Rule-2.5 Advisory A project should not contain unused macro declarations Disapplied
Rule-2.6 Advisory A function should not contain unused label declarations Compliant
Rule-2.7 Advisory There should be no unused parameters in functions Compliant
Rule-20.1 Advisory #include directives should only be preceded by preprocessor directives or comments Compliant
Rule-20.10 Advisory The # and ## preprocessor operators should not be used Compliant
Rule-20.11 Required A macro parameter immediately following a # operator shall not immediately be followed by a ## operator Compliant
Rule-20.12 Required A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators Compliant
Rule-20.13 Required A line whose first token is # shall be a valid preprocessing directive Compliant
Rule-20.14 Required All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related Compliant
Rule-20.2 Required The ', " or \ characters and the /* or // character sequences shall not occur in a header file name Compliant
Rule-20.3 Required The #include directive shall be followed by either a or "filename" sequence Compliant
Rule-20.4 Required A macro shall not be defined with the same name as a keyword Compliant
Rule-20.5 Advisory #undef should not be used Compliant
Rule-20.6 Required Tokens that look like a preprocessing directive shall not occur within a macro argument Compliant
Rule-20.7 Required Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses Compliant
Rule-20.8 Required The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1 Compliant
Rule-20.9 Required All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation Compliant
Rule-21.1 Required #define and #undef shall not be used on a reserved identifier or reserved macro name Compliant
Rule-21.10 Required The Standard Library time and date functions shall not be used Compliant
Rule-21.11 Required The standard header file shall not be used Compliant
Rule-21.12 Advisory The exception handling features of should not be used Compliant
Rule-21.13 Mandatory Any value passed to a function in shall be representable as an unsigned char or be the value EOF Compliant
Rule-21.14 Required The Standard Library function memcmp shall not be used to compare null terminated strings Compliant
Rule-21.15 Required The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types Compliant
Rule-21.16 Required The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type Compliant
Rule-21.17 Mandatory Use of the string handling functions from shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters Compliant
Rule-21.18 Mandatory The size_t argument passed to any function in shall have an appropriate value Compliant
Rule-21.19 Mandatory The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type Compliant
Rule-21.2 Required A reserved identifier or macro name shall not be declared Compliant
Rule-21.20 Mandatory The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function Compliant
Rule-21.3 Required The memory allocation and deallocation functions of shall not be used Compliant
Rule-21.4 Required The standard header file shall not be used Compliant
Rule-21.5 Required The standard header file shall not be used Compliant
Rule-21.6 Required The Standard Library input/output functions shall not be used Compliant
Rule-21.7 Required The atof, atoi, atol and atoll functions of shall not be used Compliant
Rule-21.8 Required The library functions abort, exit and system of shall not be used Compliant

with deviations:
QacDescription
5128 Use of function: getenv.
Rule-21.9 Required The library functions bsearch and qsort of shall not be used Compliant
Rule-22.1 Required All resources obtained dynamically by means of Standard Library functions shall be explicitly released Compliant
Rule-22.10 Required The value of errno shall only be tested when the last function to be called was an errno-setting-function Compliant
Rule-22.2 Mandatory A block of memory shall only be freed if it was allocated by means of a Standard Library function Compliant
Rule-22.3 Required The same file shall not be open for read and write access at the same time on different streams Compliant
Rule-22.4 Mandatory There shall be no attempt to write to a stream which has been opened as read-only Compliant
Rule-22.5 Mandatory A pointer to a FILE object shall not be dereferenced Compliant
Rule-22.6 Mandatory The value of a pointer to a FILE shall not be used after the associated stream has been closed Compliant
Rule-22.7 Required The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF Compliant
Rule-22.8 Required The value of errno shall be set to zero prior to a call to an errno-setting-function Compliant
Rule-22.9 Required The value of errno shall be tested against zero after calling an errno-setting-function Compliant
Rule-3.1 Required The character sequences /* and // shall not be used within a comment. Compliant
Rule-3.2 Required Line-splicing shall not be used in // comments. Compliant
Rule-4.1 Required Octal and hexadecimal escape sequences shall be terminated Compliant
Rule-4.2 Advisory Trigraphs should not be used Compliant
Rule-5.1 Required External identifiers shall be distinct Compliant
Rule-5.2 Required Identifiers declared in the same scope and name space shall be distinct Compliant
Rule-5.3 Required An identifier declared in an inner scope shall not hide an identifier declared in an outer scope Compliant
Rule-5.4 Required Macro identifiers shall be distinct Compliant
Rule-5.5 Required Identifiers shall be distinct from macro names Compliant
Rule-5.6 Required A typedef name shall be a unique identifier Compliant
Rule-5.7 Required A tag name shall be a unique identifier Compliant
Rule-5.8 Required Identifiers that define objects or functions with external linkage shall be unique Compliant
Rule-5.9 Advisory Identifiers that define objects or functions with internal linkage should be unique Compliant
Rule-6.1 Required Bit-fields shall only be declared with an appropriate type Compliant
Rule-6.2 Required Single-bit named bit fields shall not be of a signed type Compliant
Rule-7.1 Required Octal constants shall not be used Compliant
Rule-7.2 Required A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type Compliant
Rule-7.3 Required The lowercase character "l" shall not be used in a literal suffix Compliant
Rule-7.4 Required A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char" Compliant
Rule-8.1 Required Types shall be explicitly specified Compliant
Rule-8.10 Required An inline function shall be declared with the static storage class Compliant
Rule-8.11 Advisory When an array with external linkage is declared, its size should be explicitly specified Compliant
Rule-8.12 Required Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique Compliant
Rule-8.13 Advisory A pointer should point to a const-qualified type whenever possible Compliant
Rule-8.14 Required The restrict type qualifier shall not be used Compliant
Rule-8.2 Required Function types shall be in prototype form with named parameters Compliant
Rule-8.3 Required All declarations of an object or function shall use the same names and type qualifiers Compliant
Rule-8.4 Required A compatible declaration shall be visible when an object or function with external linkage is defined Compliant
Rule-8.5 Required An external object or function shall be declared once in one and only one file Compliant
Rule-8.6 Required An identifier with external linkage shall have exactly one external definition Compliant
Rule-8.7 Advisory Functions and objects should not be defined with external linkage if they are referenced in only one translation unit Disapplied
Rule-8.8 Required The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage Compliant
Rule-8.9 Advisory An object should be defined at block scope if its identifier only appears in a single function Compliant
Rule-9.1 Mandatory The value of an object with automatic storage duration shall not be read before it has been set Compliant
Rule-9.2 Required The initializer for an aggregate or union shall be enclosed in braces Compliant
Rule-9.3 Required Arrays shall not be partially initialized Compliant
Rule-9.4 Required An element of an object shall not be initialized more than once Compliant
Rule-9.5 Required Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly Compliant

Deviation Permits

This section targets to provide an overview of Deviation Permits.
All the rules corresponding to the deviation permits are disabled inside PRQA and will not cause any violation or deviation in the Deviation records section below.

GuidelineCategoryDescriptionRatioSub RulesCharacteristicsReason
Dir-1.1 Required Any implementation-defined behaviour on which the output of the program depends shall be documented and understood 3/34
QacDescription
0292 [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.
0315 [I] Implicit conversion from a pointer to object type to a pointer to void.
0380 [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.
Maintainability / Analysability 0292: Invalid characters in comments: Doxygen comments are used.
0315: Library string.h functions (memcpy, etc.) are used and trigger this implicit conversion.
0380: Already CMSIS and STM32HAL trigger this.
Dir-4.9 Advisory A function should be used in preference to a function-like macro where they are interchangeable 1/1
QacDescription
3453 A function could probably be used instead of this function-like macro.
Performance / Resource utilization Suppressed due to code optimization and efficiency.
Rule-11.4 Advisory A conversion should not be performed between a pointer to object and an integer type 1/5
QacDescription
0306 [I] Cast between a pointer to object and an integral type.
Maintainability / Modifiability Using STM32 HAL already creates many violations. Also needed to do pointer arithmetic, calculating offsets inside a buffer.
Rule-11.9 Required The macro NULL shall be the only permitted form of integer null pointer constant 1/2
QacDescription
3004 This integral constant expression is being interpreted as a NULL pointer constant.
Keil stddef.h: "define NULL 0" causes violations. PRQA acknowledged this as a false positive.
Rule-13.3 Advisory A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator 1/1
QacDescription
3440 Using the value resulting from a ++ or -- operation.
Maintainability / Analysability RFAL uses the increment often for building buffers (array[i++] = 42; ...). Splitting this would decrease readability.
Rule-14.3 Required Controlling expressions shall not be invariant 6/11
QacDescription
3440 Using the value resulting from a ++ or -- operation.
2991 The value of this 'if' controlling expression is always 'true'.
2992 The value of this 'if' controlling expression is always 'false'.
2998 The first operand of this conditional operator is always 'false'.
3493 The first operand of this conditional operator is always constant 'true'.
3494 The first operand of this conditional operator is always constant 'false'.
Portability / Adaptability RFAL is configurable through compile time switches. This causes some ifs to have invariant conditions at the used configuration. Suppress 14.3 for if statements.
Rule-15.5 Advisory A function should have a single point of exit at the end 1/1
QacDescription
2889 This function has more than one 'return' path.
Maintainability / Analysability Suppressed due to readability and simplicity of code logic.
Rule-17.7 Required The value returned by a function having non-void return type shall be used 1/1
QacDescription
3200 '%s' returns a value which is not being used.
Maintainability / Analysability Treating the return codes of functions in all places without exception handling would makes the code hard to read and maintain. Error checking has been reduced to the places where needed.
Rule-2.1 Required A project shall not contain unreachable code 1/7
QacDescription
1503 The function '%1s' is defined but is not used within this project.
Maintainability / Modularity RFAL provides many functions - some are not used within the checked project.
Rule-2.2 Required There shall be no dead code 7/18
QacDescription
2982 This assignment is redundant. The value of this object is never used before being modified.
2983 This assignment is redundant. The value of this object is never subsequently used.
2985 This operation is redundant. The value of the result is always that of the left-hand operand.
2986 This operation is redundant. The value of the result is always that of the right-hand operand.
2996 The result of this logical operation is always 'false'.
2997 The first operand of this conditional operator is always 'true'.
3112 This statement has no side-effect - it can be removed.
Usability / User error protection All the violations were checked and fixing the violation would deteriorate robustness: Removing checks which are unnecessary at the given position, removing trailing iterator increment, etc.
Rule-2.3 Advisory A project should not contain unused type declarations 1/1
QacDescription
3205 The identifier '%s' is not used and could be removed.
Compatibility / Interoperability RFAL defines enums for all identifiers available in NFC Forum - some are unused.
Rule-2.5 Advisory A project should not contain unused macro declarations 1/1
QacDescription
3214 The macro '%s' is not used and could be removed.
Compatibility / Interoperability RFAL defines macros for all identifiers of NFC Forum and RF chip register map - some are not used.
Rule-8.7 Advisory Functions and objects should not be defined with external linkage if they are referenced in only one translation unit 4/4
QacDescription
1504 The object '%1s' is only referenced in the translation unit where it is defined.
1505 The function '%1s' is only referenced in the translation unit where it is defined.
1531 The object '%1s' is referenced in only one translation unit - but not the one in which it is defined.
1532 The function '%1s' is only referenced in one translation unit - but not the one in which it is defined.
Maintainability / Modularity RFAL defines functions which could be called by the user but are not called in the current project.

Deviation Records

This section targets to provide an overview of Deviation Records.

1. Suppressions by File

File: .../ST25R3916_nucleo/rfal/source/rfal_isoDep.c

LinesCountSuppressed QacsComment
2266-2267 1
0310 Casting to different object pointer type.
MISRA 11.3 - Intentional safe cast to avoiding buffer duplication
421-421 1
0750 A union type specifier has been defined.
MISRA 19.2 - Members of the union will not be used concurrently, only one frame at a time
797-797 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2519-2519 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created
2693-2693 1
0310 Casting to different object pointer type.
MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication
1351-1351 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1028-1028 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2756-2756 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2615-2615 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created
2602-2602 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created
2175-2176 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalIsoDepFSxI is guaranteed whithin 4bit range
2526-2526 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created
1391-1393 2
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and above masks guarantee no invalid enum values to be created

File: .../ST25R3916_nucleo/rfal/source/rfal_nfc.c

LinesCountSuppressed QacsComment
1612-1612 1
0310 Casting to different object pointer type.
MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication
81-81 1
0750 A union type specifier has been defined.
MISRA 19.2 - Members of the union will not be used concurrently, only one interface at a time
190-190 1
2880 This code is unreachable.
MISRA 2.1 - Unreachable code due to configuration option being set/unset
1828-1828 1
0310 Casting to different object pointer type.
MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication

File: .../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c

LinesCountSuppressed QacsComment
1901-1903 2
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of enum rfalBitRate and definition of rfalNfcDepBRS2DSI guarantee no invalid enum values to be created
2595-2595 1
0310 Casting to different object pointer type.
MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication
1589-1589 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
902-902 1
2880 This code is unreachable.
MISRA 2.1 - Guard code to prevent unexpected behavior
1661-1661 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2654-2654 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1269-1269 1
2880 This code is unreachable.
MISRA 2.1 - Guard code to prevent unexpected behavior

File: .../ST25R3916_nucleo/rfal/source/rfal_nfca.c

LinesCountSuppressed QacsComment
278-278 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
637-638 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Guaranteed that no invalid enum values are created: see guard_eq_RFAL_NFCA_T2T, ....

File: .../ST25R3916_nucleo/rfal/source/rfal_nfcb.c

LinesCountSuppressed QacsComment
391-392 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Layout of rfalNfcbSlots and above loop guarantee that no invalid enum values are created.

File: .../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c

LinesCountSuppressed QacsComment
3344-3344 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
3108-3108 1
0759 An object of union type has been defined.
MISRA 19.2 - Allocating Union where members are of the same type, just different names. Thus no problem can occur.
227-227 1
0750 A union type specifier has been defined.
MISRA 19.2 - Both members are of the same type, just different names. Thus no problem can occur.
2046-2046 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
3364-3364 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.
2179-2179 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1867-1867 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1851-1851 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2447-2447 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1972-1972 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
1837-1837 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2341-2341 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
2254-2254 1
2003 The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.
MISRA 16.3 - Intentional fall through
3563-3563 1
4342 An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.
MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.
1494-1494 1
5209 Use of basic type '%s'.
MISRA 4.9 - External function (sqrt()) requires double

2. Suppressions by Group

FileRequiredAdvisoryTotal
.../ST25R3916_nucleo/rfal/include/rfal_nfcv.h 0 1 1
.../ST25R3916_nucleo/rfal/include/rfal_nfcDep.h 0 1 1
.../ST25R3916_nucleo/rfal/include/rfal_isoDep.h 0 1 1
.../ST25R3916_nucleo/rfal/include/rfal_nfc.h 0 3 3
.../ST25R3916_nucleo/rfal/include/rfal_analogConfig.h 1 0 1
.../ST25R3916_nucleo/rfal/source/rfal_nfca.c 1 1 2
.../ST25R3916_nucleo/rfal/source/rfal_nfc.c 3 1 4
.../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c 6 2 8
.../ST25R3916_nucleo/rfal/source/rfal_isoDep.c 6 8 14
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c 10 5 15
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_analogConfigTbl.h 1 1 2
.../ST25R3916_nucleo/rfal/source/rfal_nfcb.c 0 1 1
Total 28 25 53

3. Redundant Suppressions

o Duplicated Suppressions

There are no duplicated suppressions.

o Unused Suppressions

File: .../ST25R3916_nucleo/rfal/source/rfal_isoDep.c

LineUnused QacsComment
1414
2880 This code is unreachable.
MISRA 2.1 - Unreachable code due to configuration option being set/unset above (RFAL_SUPPORT_BR_CE_A_xxx)

4. Continuous Suppressions by File

There are no continuous suppressions by file.

5. File Status

Active Diagnostics refers to diagnostics that are not suppressed (note: no suppressed diagnostics have been taken into account for the calculation of information in this document).

FilesActive DiagnosticsViolated RulesViolation CountCompliance Index
.../ST25R3916_nucleo/rfal/include/rfal_analogConfig.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_chip.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_isoDep.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfc.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfcDep.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfca.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfcb.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfcf.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_nfcv.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_rf.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_st25tb.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/include/rfal_t1t.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_analogConfig.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_crc.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_crc.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_iso15693_2.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_iso15693_2.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_isoDep.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfc.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfca.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfcb.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfcf.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_nfcv.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_st25tb.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/rfal_t1t.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_analogConfigTbl.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_features.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25R3916_irq.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_com.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_com.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_irq.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_irq.h 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_led.c 0 0 0 100.00
.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_led.h 0 0 0 100.00
Total 0 0 0 100.00


Nota: Calculation of Compliance Index
The Compliance Index is the percentage of groups which have no messages in them.
For each file it is calculated as follows:

( Ntotal - Nerror ) / Ntotal x 100

Ntotal is the total number of enforced rules (i.e. the number of rules that have at least one message mapped to it directly).
Nerror is the number of rules for which messages appear in that file.
The File Compliance Index is the mean of all the individual file compliances.