Handling errors in C with "check-log-return": why not use a macro?

Question

It's a good practice (I believe) in C to handle errors like this:

int status = tree_climb(tree, ...);
if (status != 0) {
    global_logger.message(2, "Cannot climb a tree %s", tree->name);
    return EPIPE;
}

or, alternatively

forest_errno = tree_climb(tree, ...);
if (forest_errno != 0) {
    goto exit;
}

exit:
if (tree) {
    tree_dispose(tree);
}
if (forest) {
    forest_dispose(forest);
}

return forest_errno;

The questions is:

What are the reasons not to use a preprocessor macro for this? I cannot remember seeing a lot of code like:

#define CHECK_OR_RETURN(contract, error_status, log_level, message_format, ...) \
if (!(contract)) { \
    global_logger.message(log_level, message_format, ##__VA_ARGS__); \
    return error_status; \
}

I see these reasons to use a macro:

• This will collapse 4 lines of code, 3 of which do nothing during normal flow of operation, into 1.
• Error handling, ideally, should not pollute the code for a normal flow.

I see these reasons not to use a macro:

• Macro will obtuse reading and debugging the code somewhat. Self-invented "magic" syntax can turn a familiar language into an incomprehensible one - sometimes, you just cannot parse a code without knowing a library specifics. Though, on a large scale, a code 3 times shorter is 9 times more readable.
• In C++, we could use exceptions. I would rather not use non-checked exceptions, but it's not in the scope of my question.
• Some people just don't care for the code length.

So why don't people do this all the time?

Answer 1

Your "alternative" shows that your C code might implement a stepwise acquisition of resources.

Take the following example, without any error processing, and indentation just used here to show the different steps:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
   Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
     Tree *tree = get_tree(forest, "SPAIN"...);   
     Element *element = malloc(sizeof(element));  // step 3: allocate new element
       element->value = MAGIC; 
       tree_add(tree, element);                 // suppose element is copied into the tree
     free (element);                          // end step 3 
     ...
   release_forest (forest);                 // end step 2 (forest takes care of its trees)
   ...
 fclose (fp);                             // end step 1

There can be an error caused by each single instruction here. Depending on the step in which your error, happens, you might have to release some or some more resources.

Alternative 1

Using your macro to log and process the different errors would just leak resources, by returning whle not all resources are released.

Alternative 2

Using some nested conditional statements:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
 if (fp) {                                    // go on for step 1
     Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
     if (forest) {                                // go on for step 2
        Tree *tree = get_tree(forest, "SPAIN"...);   
        ...
        release_forest (forest);                  // end step 2 (forest takes  
     } 
     else {
        errcode = logmyerror ("forest not properly loaded", ENOTFOUND);
     }
     fclose (fp);                             // end step 1
 }
 else {
     errcode = logmyerror ("file not found ", EOOPSAGAIN);
 }
 return errcode;   // final exit point 

Alternative 3

The ignomous goto (well it has some advantages as you'll see), where different labels correspond to exit points for the relevant steps:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
 if (fp==NULL) {
     errcode = logmyerror ("file not found ", EOOPSAGAIN);
     goto out0; 
 }
 Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
 if (forest==NULL) { 
     errcode = logmyerror ("forest not properly loaded", ENOTFOUND);
     goto out1; 
 }  
 Tree *tree = get_tree(forest, "SPAIN"...);   
 ... 
out2: 
 release_forest (forest);                 // end step 2 (forest takes care of its trees)
   ...
out1: 
 fclose (fp);                             // end step 1

out0: 
 return errcode; 

Conclusion

Of course if you don't have such multilevel resource allocation, you could perfectly use your macro. But I'm afraid that there are many real life situation where this will not be sufficient.

Note that in C++ you would not need this if you use RAII, the destructors would always clean the resources whenever you return.

Answer 2

People don't do for the reasons you listed. Additionally there is no common "good coding praxis", but in the best case you have some departmental rules. Also I find lots of code which is not coherent. That is, parts use the macros and parts don't. Depending likely on which programmer had hands on.

So which advise can I give? If you have lots of those simple error handling snippets feel free to use a macro. I think that dense code is better to read than scattered, especially with those repetitive snippets.

Of course, if you have more complex error handling, you might end up with unmanageable macros.

Answer 3

If you are missing exceptions in C, you may emulate them with "long jumps". This way, you can have one point for handling the exceptions, like with try/catch, and this point can even be on a higher stack level.

Here is an example implementation, but the basis (longjmp / setjmp) was part of C from the beginning, and there is no additional software necessary. http://www.di.unipi.it/~nids/docs/longjump_try_trow_catch.html