Enforce a condition check before C code blocks - c

Question

Short story: I want to enforce a run-time condition check in certain conditionally-compiled code blocks, but not others.
Long story:
Our C code base relies heavily on profiling.
We have lots of different profiles, and almost each module has #ifdefs for at least 5-6 different profiles, wrapping large segments of code.
We have added a new requirement - for certain profiles (Let's say <A> and <B>), the conditionally-compiled code will only be run if a specific condition is met. For the other profiles (Let's say <C>) this is not required.
i.e., this is how the code looks now:
#ifdef <A>
/* Profiled code… */
#endif /* <A> */
#ifdef <B>
/* Profiled code… */
#endif /* <B> */
#ifdef <C>
/* Profiled code… */
#endif /* <C> */
This is how we need it to look:
#ifdef <A>
if (new_condition)
{
/* Profiled code… */
}
#endif /* <A> */
#ifdef <B>
if (new_condition)
{
/* Profiled code… */
}
#endif /* <B> */
#ifdef <C>
/* Profiled code… */
#endif /* <C> */
So far, so good.
However, with the above implementation the new requirement isn't really maintainable.
It doesn't stop anyone not familiar with the requirement to add a new profiled code block, without adding the check for new_condition.
So I want to force our engineers to check for this condition whenever adding new blocks that are profiled under <A> and <B>, but not for code profiled under <C>.
Theoretically, the best solution would probably be a way to fail the build process, if there exists an #ifdef <A> or #ifdef <B> that isn't directly followed by if (new_condition).
Thing is, I have no idea to do that. Do any of you have?

Answer 1

I'm reasonably sure it can't be done as described. It would seem that your engineers get to write all the code from the #ifdef to the #endif and the only 'hooks' you have are the conditional symbols and condition. That isn't enough. Some semi-random thoughts:
You could turn the 'condition' into a function call and count how often it gets called.
You could demand certain 'null behaviour' when all the conditions are set to false.
You could create some function your engineers have to call inside their block to get access to something, and check at runtime that it doesn't get called if the condition is false.
Ultimately I think you'd be better to use source code analysis tools to analyse the source code and report on coding style breaches. That would be CppCheck or one of these: http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis.

Answer 2

Bit hard to answer this, since everything is so fuzzy :) But I would suggest to use somekind of wrapper, which the person editing the code isn't allowed to change:
typedef void(*stuff_ptr)(void);
inline void do_stuff (stuff_ptr stuff)
{
#if defined(A) || defined(B)
if (!new_condition)
{
return ;
}
#endif
stuff();
}
#ifdef A
do_stuff(A_stuff);
#endif
#ifdef B
do_stuff(B_stuff);
#endif
#ifdef C
do_stuff(C_stuff);
#endif
This will not fail to build, but instead prevents incorrect builds from happening in the first place.
do_stuff() can be implemented as a function-like macro if needed, but avoid that if you can. The "new_condition" could be passed as another parameter, if needed.

Answer 3

One idea that maintains your current begin macro, end macro style blocks might be something like the following:
#include <stdio.h>
#define FOO 1
#define BAZ 1
int condition_a = 1;
int condition_b = 0;
#ifdef FOO
# define FOO_BEGIN if (condition_a) {
# define FOO_END }
#else
# define FOO_BEGIN if (0) {
# define FOO_END }
#endif
#ifdef BAR
# define BAR_BEGIN if (condition_b) {
# define BAR_END }
#else
# define BAR_BEGIN if (0) {
# define BAR_END }
#endif
#ifdef BAZ
# define BAZ_BEGIN if (1) {
# define BAZ_END }
#else
# define BAZ_BEGIN if (0) {
# define BAZ_END }
#endif
int main (int argc, char ** argv)
{
FOO_BEGIN
printf("in foo\n");
FOO_END
BAR_BEGIN
printf("in bar\n");
BAR_END
BAZ_BEGIN
printf("in baz\n");
BAZ_END
}
prints
in foo
in baz
You're going to have to either update the macros that define entering and exiting blocks or require something inside of those ifdefs.