How to efficiently display errors in C? - c

Question

I tried a new way of protecting my code through some binary flags.
I think binary flags are very handy in such situations because it is easy to check for conditions, for example the FAILURE flag below that tells if a failure occured or not is very easy to code.
Issue is it is easy to get tangled up with 1-digit difference flags.
# define EXIT_FLAG 0b10000000000000000000000000000000
# define FAILURE 0b00000000000000000001111111111111
# define FAILED_FORK 0b00000000000000000000000000000001
# define FAILED_WAITPID 0b00000000000000000000000000000010
# define FAILED_SEM_OPEN 0b00000000000000000000000000000100
# define FAILED_SEM_CLOSE 0b00000000000000000000000000001000
# define FAILED_SEM_POST 0b00000000000000000000000000010000
# define FAILED_SEM_WAIT 0b00000000000000000000000000100000
# define FAILED_SEM_UNLINK 0b00000000000000000000000001000000
# define FAILED_CREAT_TH 0b00000000000000000000000010000000
# define FAILED_JOIN_TH 0b00000000000000000000000100000000
# define FAILED_KILL 0b00000000000000000000001000000000
# define FAILED_GET_TIME 0b00000000000000000000010000000000
# define FAILED_USLEEP 0b00000000000000000000100000000000
# define FAILED_WRITE 0b00000000000000000001000000000000
# define USERGUIDE 0b00000000000000000010000000000000
# define USERGUIDE_MSG "usage:\n\t./philo {nb_philos} {die_tm} \
{eat_tm} {sleep_tm} (max_eat)\n \
\tinputs in ms is capped to 60,000 ms\n"
int ft_putstr_fd(char *s, int fd)
{
if (s)
{
while (*s)
{
if (write(fd, s++, 1) == -1)
{
write(fd, "Failed write\n", 13);
return (0);
}
}
}
return (1);
}
int ft_putstr_error(char *s)
{
return (ft_putstr_fd(s, STDERR_FILENO));
}
void *ft_puterror(int flag, void *args)
{
if (flag & FAILED_FORK)
ft_putstr_error("Failed fork: ");
else if (flag & FAILED_WAITPID)
ft_putstr_error("Failed waitpid: ");
else if (flag & FAILED_SEM_OPEN)
ft_putstr_error("Failed sem_open: ");
else if (flag & FAILED_SEM_CLOSE)
ft_putstr_error("Failed sem_close: ");
else if (flag & FAILED_SEM_POST)
ft_putstr_error("Failed sem_post: ");
else if (flag & FAILED_SEM_WAIT)
ft_putstr_error("Failed sem_wait: ");
else if (flag & FAILED_SEM_UNLINK)
ft_putstr_error("Failed sem_unlink: ");
else if (flag & FAILED_CREAT_TH)
ft_putstr_error("Failed create thread: ");
else if (flag & FAILED_JOIN_TH)
ft_putstr_error("Failed joining thread: ");
else if (flag & FAILED_KILL)
ft_putstr_error("Failed kill: ");
else if (flag & FAILED_GET_TIME)
ft_putstr_error("Failed get_time: ");
else if (flag & FAILED_USLEEP)
ft_putstr_error("Failed usleep: ");
else if (flag & FAILED_WRITE)
ft_putstr_error("Failed write: ");
if (flag & FAILURE)
{
ft_putstr_error((char *)args);
ft_putstr_error("\n");
}
if (flag & USERGUIDE)
ft_putstr_error(USERGUIDE_MSG);
return (NULL);
}
Would you recommend to use this method to handle such errors or is there a nicer way, like a best practice ?

Answer 1

It is much less error-prone if you use a sequence of numbers for the failure codes. Whenever you need a bitmask, simply shift one bit N times to the left, e.g.
//specify failure code type
typedef uint32_t failure_t;
//create a bitmask of the specified failure code
#define FAILURE_MASK(FCODE) (((failure_t) 1) << (FCODE))
//list of failure constants
#define NO_FAILURE ((failure_t) 0) //add a no failure flag
#define FAILED_FORK ((failure_t) 1)
#define FAILED_WAITPID ((failure_t) 2)
#define FAILED_SEM_OPEN ((failure_t) 3)
#define FAILED_SEM_CLOSE ((failure_t) 4)
#define FAILED_SEM_POST ((failure_t) 5)
#define FAILED_SEM_WAIT ((failure_t) 6)
#define FAILED_SEM_UNLINK ((failure_t) 7)
#define FAILED_CREAT_TH ((failure_t) 8)
#define FAILED_JOIN_TH ((failure_t) 9)
#define FAILED_KILL ((failure_t) 10)
#define FAILED_GET_TIME ((failure_t) 11)
#define FAILED_USLEEP ((failure_t) 12)
#define FAILED_WRITE ((failure_t) 13)
//... extend as you see fit
#define FAILURE_N (FAILED_WRITE + 1) //useful for iteration
//list of failure strings
static const char *failure_strings[FAILURE_N] = {
"No failure",
"Failed fork",
"...",
"Failed write"
};
//extern function to retrieve the failure string
const char* get_failure_string(failure_t failure)
{
return failure_strings[failure];
}
//test if the failure set contains the specified failure
#define is_failure_set(FSET, FCODE) FSET & FAILURE_MASK(FCODE)
//set the failure code in the failure set
#define set_failure(FSET, FCODE) FSET |= FAILURE_MASK(FCODE)
/**/
void *ft_puterror(failure_t failure_set, void *args)
{
if (failure_set == NO_FAILURE) //no failure set, nothing to do ...
return NULL; //unless no failure should be reported too
//for each failure that is set in failure_set
for (failure_t n=1; n < FAILURE_N; ++n, failure_set >>= 1) {
if (failure_set & 1) { //failure n is set, report it
ft_putstr_error(get_failure_string(n));
ft_putstr_error((char *)args);
ft_putstr_error("\n");
}
}
//...
return NULL;
}
Adding a new failure code requires only 3 steps:
add a new const, e.g. #define FAILED_NEW ((failure_t) 14)
set the constant FAILURE_N to the appropriate value, e.g. #define FAILURE_N (FAILED_NEW + 1)
add a new string to the failure_strings table, e.g. "Failed new"
Edit: based on the suggestions of 'chux - Reinstate Monica' (see comments below).