## PRQA GEP/GCS/GRP Report

#### Note: This report is generated using the software (PRQA Framework) of Programming Research Limited and is the Intellectual Property of Programming Research Limited.

Project : .../ST25R3916_nucleo/nucleo/Firmware/nucleo/X-NUCLEO-NFC06A1/STM32
Status at: 25 Jun, 2019 at 15:36:15
MISRA report script last update: 07/11/18

## 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:

- #### Component: qacpp

Version: 4.2.0

Target: C++

- #### Component: rcma

Version: 1.6.0

Target: C_CPP

- #### Component: m3cm

Version: 2.3.1

Target: C

- #### Component: qac

Version: 9.3.1

Target: C

- ##### Options:

-d : __schedule_barrier=_ignore_semi

-namelength : 63

### 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:

- MCU target:

STM32

- Parent repository:

ST25R3916_nucleo

- RFAL informations:

Path: .../ST25R3916_nucleo/rfal

Version: v2.0.10

- Project repositories SHA1:

.../ST25R3916_nucleo: 959b80e

.../ST25R3916_nucleo/common: f953a19

.../ST25R3916_nucleo/nucleo: 22a04ae

.../ST25R3916_nucleo/rfal: b566bd2

### 3. Assistance/Enforcement

Guideline | Category | Description | Assistance/Enforcement Sub Rules
--- | --- | --- | ---
Dir-1.1 | Required | Any implementation-defined behaviour on which the output of the program depends shall be documented and understood |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
2956 | Definite: Using object '%s' with tainted value.

Dir-4.2 | Advisory | All usage of assembly language should be documented |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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. |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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. |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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' |

Qac | Description
--- | ---
1321 | Operand of sizeof is a function parameter of array type.

Rule-13.1 | Required | Initializer lists shall not contain persistent side-effects |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3440 | Using the value resulting from a ++ or -- operation.

Rule-13.4 | Advisory | The result of an assignment operator should not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3344 | Controlling expression is not an 'essentially Boolean' expression.

Rule-15.1 | Advisory | The goto statement should not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
2019 | 'Switch' label is located within a nested code block.

Rule-16.3 | Required | An unconditional break statement shall terminate every switch-clause |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3315 | This 'switch' statement is redundant.

Rule-16.7 | Required | A switch-expression shall not have essentially Boolean type |

Qac | Description
--- | ---
0735 | Switch expression is of essentially Boolean type.

Rule-17.1 | Required | The features of shall not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3670 | Recursive call to function containing this call.
1520 | Functions are indirectly recursive.

Rule-17.3 | Mandatory | A function shall not be declared implicitly |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 [ ] |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3200 | '%s' returns a value which is not being used.

Rule-17.8 | Advisory | A function parameter should not be modified |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
0488 | Performing pointer arithmetic.

Rule-18.5 | Advisory | Declarations should contain no more than two levels of pointer nesting |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
1060 | [C99] A flexible array member has been declared.

Rule-18.8 | Required | Variable-length array types shall not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3205 | The identifier '%s' is not used and could be removed.

Rule-2.4 | Advisory | A project should not contain unused tag declarations |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3214 | The macro '%s' is not used and could be removed.

Rule-2.6 | Advisory | A function should not contain unused label declarations |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
5087 | Use of #include directive after code fragment.

Rule-20.10 | Advisory | The # and ## preprocessor operators should not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
0841 | Using '#undef'.

Rule-20.6 | Required | Tokens that look like a preprocessing directive shall not occur within a macro argument |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
5127 | Use of standard header file .

Rule-21.11 | Required | The standard header file shall not be used |

Qac | Description
--- | ---
5131 | Use of standard header file .

Rule-21.12 | Advisory | The exception handling features of should not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
5132 | Use of standard header file .

Rule-21.5 | Required | The standard header file shall not be used |

Qac | Description
--- | ---
5123 | Use of standard header file .

Rule-21.6 | Required | The Standard Library input/output functions shall not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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. |

Qac | Description
--- | ---
3108 | Nested comments are not recognized in the ISO standard.

Rule-3.2 | Required | Line-splicing shall not be used in // comments. |

Qac | Description
--- | ---
5134 | C++ style comment uses line splicing.

Rule-4.1 | Required | Octal and hexadecimal escape sequences shall be terminated |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3601 | Trigraphs (??x) are an ISO feature.

Rule-5.1 | Required | External identifiers shall be distinct |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
3660 | Named bit-field consisting of a single bit declared with a signed type.

Rule-7.1 | Required | Octal constants shall not be used |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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" |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
1057 | [C99] The keyword 'restrict' has been used.

Rule-8.2 | Required | Function types shall be in prototype form with named parameters |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
0693 | Struct initializer is missing the optional {.
0694 | Array initializer is missing the optional {.

Rule-9.3 | Required | Arrays shall not be partially initialized |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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.

Guideline | Description | Category | Revised 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.

Guideline | Category | Description | Compliance
--- | --- | --- | ---
Dir-1.1 | Required | Any implementation-defined behaviour on which the output of the program depends shall be documented and understood | Compliant with deviations:

Qac | Description
--- | ---
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:

Qac | Description
--- | ---
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:

Qac | Description
--- | ---
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:

Qac | Description
--- | ---
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:

Qac | Description
--- | ---
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:

Qac | Description
--- | ---
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.

Guideline | Category | Description | Ratio | Sub Rules | Characteristics | Reason
--- | --- | --- | --- | --- | --- | ---
Dir-1.1 | Required | Any implementation-defined behaviour on which the output of the program depends shall be documented and understood | 3/34 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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 |

Qac | Description
--- | ---
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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
1292-1292 | 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
2286-2286 | 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
1332-1334 | 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
2460-2460 | 1 |

0310 | Casting to different object pointer type.

MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication
2369-2369 | 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
2293-2293 | 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
962-962 | 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
2382-2382 | 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
744-744 | 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

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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
172-172 | 1 |

2880 | This code is unreachable.

MISRA 2.1 - Unreachable code due to configuration option being set/unset

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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
1879-1881 | 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
1574-1574 | 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
1646-1646 | 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
887-887 | 1 |

2880 | This code is unreachable.

MISRA 2.1 - Guard code to prevent unexpected behavior
1254-1254 | 1 |

2880 | This code is unreachable.

MISRA 2.1 - Guard code to prevent unexpected behavior

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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
495-496 | 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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
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

Lines | Count | Suppressed Qacs | Comment
--- | --- | --- | ---
2293-2293 | 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
1998-1998 | 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
1803-1803 | 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
3312-3312 | 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.
226-226 | 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.
1924-1924 | 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
1819-1819 | 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
3511-3511 | 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.
2206-2206 | 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
1789-1789 | 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
2131-2131 | 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
3056-3056 | 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.
3292-3292 | 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
2396-2396 | 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
1474-1474 | 1 |

5209 | Use of basic type '%s'.

MISRA 4.9 - External function (sqrt()) requires double

### 2. Suppressions by Group

File | Required | Advisory | Total
--- | --- | --- | ---
.../ST25R3916_nucleo/rfal/include/rfal_nfcv.h | 0 | 1 | 1
.../ST25R3916_nucleo/rfal/include/rfal_nfc.h | 0 | 3 | 3
.../ST25R3916_nucleo/rfal/include/rfal_nfcDep.h | 0 | 1 | 1
.../ST25R3916_nucleo/rfal/include/rfal_analogConfig.h | 1 | 0 | 1
.../ST25R3916_nucleo/rfal/include/rfal_isoDep.h | 0 | 1 | 1
.../ST25R3916_nucleo/rfal/source/rfal_isoDep.c | 4 | 6 | 10
.../ST25R3916_nucleo/rfal/source/rfal_nfcb.c | 0 | 1 | 1
.../ST25R3916_nucleo/rfal/source/rfal_nfca.c | 0 | 1 | 1
.../ST25R3916_nucleo/rfal/source/rfal_nfc.c | 1 | 0 | 1
.../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c | 4 | 2 | 6
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_analogConfigTbl.h | 1 | 1 | 2
.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c | 10 | 5 | 15
Total | 21 | 22 | 43

### 3. Redundant Suppressions

#### o Duplicated Suppressions

There are no duplicated suppressions.

#### o Unused Suppressions

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

Line | Unused Qacs | Comment
--- | --- | ---
1355 |

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).

Files | Active Diagnostics | Violated Rules | Violation Count | Compliance 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.