# V2584. MISRA. Expression used in condition should have essential Boolean type.

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

This rule only applies to programs written in C. Expressions used in 'if' / 'for' / 'while' conditions should have essential Boolean type.

The MISRA standard introduces the essential type model, where a variable might have one of the following types:

- Boolean, if it uses true/false values: '_Bool';
- signed, if it uses signed integer numbers, or is an unnamed enum: 'signed char', 'signed short', 'signed int', 'signed long', 'signed long long', 'enum { .... };';
- unsigned, if it uses unsigned integer numbers: 'unsigned char', 'unsigned short', 'unsigned int', 'unsigned long', 'unsigned long long';
- floating, if it uses floating point numbers: 'float', 'double', 'long double';
- character, if it uses only characters: 'char';
- Named enum, if it uses a named set of user-specific values: 'enum name { .... };'

Thus, the standard allows the following expressions:

- expression of type bool (from C99);
- expression containing a comparison with '==', '!=', '<', '>', '<=', '>=' operators;
- constants with value 0 or 1.

An example for which the analyzer will issue a warning:

    void some_func(int run_it)
    {
      if (run_it)
      {
        do_something();
      }

      // ....
    }

Here the variable should be explicitly checked against zero:

    void some_func(int run_it)
    {
      if (run_it != 0)
      {
        do_something();
      }

      // ....
    }

Another example:

    void func(void *p)
    {
      if (!p) return;
      // ....
    }

To eliminate the issue, the pointer should be explicitly compared with the null:

    void func(void *p)
    {
      if (p == NULL) return;
      // ....
    }

The analyzer will not issue a warning for such code:

    void fun(void)
    {
      while (1)
      {
        // ....
      }
    }

This diagnostic is classified as:

MISRA-C-2012-14.4 MISRA-C-2023-14.4