V2650. MISRA. Controlling expression of generic selection should have essential type that matches its standard type

This diagnostic rule is based on the MISRA (Motor Industry Software Reliability Association) software development guidelines.

This diagnostic rule is relevant only for C.

The essential type of the controlling expression in the _Generic construct (C11) must match a standard type.

Exceptions include integer constant expressions that have an essentially signed or essentially unsigned type of lower rank than int, and that are neither character nor boolean constants.

Note:

• An enumeration constant (enum) has the signed int type. It does not match any of the following types listed below (if it differs from int), nor the indistinguishable enumerated type.
• The same case with true and false defined in <stdbool.h>, which have theint type and will not match an association of the _Bool type.

The code written under MISRA guidelines must also comply with the Essential Type Model to reduce the number of defects in the code.

The essential type of the association selected by a generic selection must match the essential type of the controlling expression. If it does not, the code violates the MISRA type system and it may indicate potential errors.

The example:

void handle_us(unsigned short input) {}
void handle_si(signed int input) {}
void handle_ui(unsigned int input) {}
void handle_ch(char ch) {}

#define dispatcher(X) (_Generic((X)                \
                      , unsigned short : handle_us \
                      , unsigned int   : handle_ui \
                      , char           : handle_ch \
                      , default        : handle_si) (X))


static void CheckChar()
{
  dispatcher('c');
}

Here, it is expected that the handle_ch(char) function will be selected for the dispatcher('c') expression. However, the function from the default branch, handle_si(signed int), will be selected instead. This behavior occurs because the generic selection chooses an association based on the standard type of the controlling expression. According to the C language standard, the type of the 'c' expression—int, since it is a character literal. However, the essential type of this expression is essentially character.

The fixed code:

static void CheckChar()
{
  char c = 'c';
  dispatcher(c);
}

Since a variable of the char type is now explicitly passed to the generic selection, the correct association will be selected. The essential type of the controlling expression matches its standard type, char.

The enumerated type cannot be used as the controlling expression of the generic selection that contains a base type in the association list. The restriction applies to both enumerated type objects and enumeration constants.

The example with enum:

static void CheckEnum()
{
  enum Mark { A, B, C, D };
  enum Mark tmp = A;
  dispatcher(tmp);
  dispatcher(A);
}

Both expressions, dispatcher(tmp) and dispatcher(A), violate the rule described above.

As a result, the essential type for each expression is essentially enum, but standard types differ. For tmp, the standard type is unsigned int, since the enumeration range is known and non-negative. For the enumeration constant A, the standard type will be signed int, in accordance with the C standard.

This diagnostic is classified as:

Was this page helpful?

Message submitted.

Your message has been sent. We will email you at

If you do not see the email in your inbox, please check if it is filtered to one of the following folders:

• Promotion
• Updates
• Spam

If you can’t find an answer to your question, fill in the form below and our developers will contact you

By clicking this button you agree to our Privacy Policy statement