Understanding CMake's CMP0055: Enforcing Best Practices for `break()`

CMP0055 - Strict Checking for break() Command

This policy addresses the behavior of the break() command in CMake. In CMake versions 3.1 and earlier, break() could be used outside of loop contexts, and any arguments provided to it were ignored. This resulted in undefined behavior, meaning the outcome was unpredictable and could potentially lead to errors.

Policy Introduction and Behavior

• Default behavior (if not explicitly set):
  • CMake issues a warning.
  • It uses the OLD behavior (allowing break() outside loops and ignoring arguments).
• Configured using cmake_policy() or cmake_minimum_required().
• Introduced in CMake version 3.2.

Policy Options

• NEW
  This is the recommended behavior. It enforces strict checking:
  • break() can only be used within loops.
  • Any arguments provided to break() will cause an error.
• OLD
  This is the deprecated behavior, allowing break() outside loops and ignoring arguments. It's recommended to avoid this option for future-proof code.

Why Use the NEW Behavior?

• Future-Proofing
  Ensures code compatibility with future CMake versions that might remove the OLD behavior entirely.
• Error Prevention
  Prevents potential errors caused by unintended break() usage outside loops.
• Clarity and Consistency
  Enforces the intended use of break() within loops, improving code readability and maintainability.

How to Set the Policy

There are two main ways to set the CMP0055 policy:

1. cmake_policy(CMP0055 NEW)  # Enforce strict checking for break()
   

2. Using cmake_minimum_required()
   

   cmake_minimum_required(VERSION 3.2)  # Requires CMake 3.2 or later (implicitly sets NEW behavior)
   

---

Example 1: OLD Behavior (Undefined)

# This code exhibits undefined behavior and might cause issues

if (SOME_CONDITION)
  break()  // Allowed outside loop in OLD behavior (warning issued in NEW)
endif()

for (int i = 0; i < 5; ++i) {
  if (i == 2) {
    break(VALUE);  // Argument ignored in OLD behavior (error in NEW)
  }
}

In this example:

• The second break() with an argument inside the loop is ignored in OLD behavior (but would cause an error in NEW).
• The first break() outside the loop is allowed in OLD behavior (but might cause a warning in NEW).

# This code adheres to stricter checking for break()

cmake_policy(CMP0055 NEW)  # Enforce strict checking

if (SOME_CONDITION) {
  # Error: break() cannot be used outside a loop (in NEW behavior)
}

for (int i = 0; i < 5; ++i) {
  if (i == 2) {
    break();  // Correct usage within loop (no argument allowed in NEW)
  }
}

• The second break() inside the loop is used correctly without an argument.
• The first break() outside the loop would cause an error because it's only allowed within loops in NEW behavior.

---

Using continue

The continue command allows you to skip the remaining iterations of the current loop and proceed to the next iteration. This can be a valid approach if you simply want to exit the current iteration based on a specific condition.

for (int i = 0; i < 5; ++i) {
  if (i == 2) {
    continue;  // Skip to the next iteration if i is 2
  }
  # Process the current iteration (i != 2)
}

Nested Loops

In some cases, using nested loops might be a more structured way to achieve the desired behavior. You can have an outer loop that runs for a specific number of times, and an inner loop that can be exited early using break within the inner loop's logic.

for (int j = 0; j < 3; ++j) {
  for (int i = 0; i < 10; ++i) {
    if (some_condition(i)) {
      break;  // Exit the inner loop if condition met
    }
    # Process elements within the inner loop
  }
}

Early Exiting Logic

Instead of relying solely on break within loops, you can structure your code to check for conditions that would warrant early termination and exit the entire loop structure before iterating through all elements.

int i = 0;
while (i < 5 && !some_condition(i)) {
  # Process the current iteration
  ++i;
}