Elegant mapping of C error defines to strings

Question

Let's say I have a bunch of error codes in my application header.h like:

#define SOMETHING_WENT_WRONG   -1
#define SOLAR_FLARE_DECTECTED  -2
#define ANTS_IN_YOUR_CPU       -3

I return these as int from various API functions. I'd like a clean way to offer a function that user can call to map these to more descriptive error messages, while keeping the header short.

That is, while I could always do something like:

const char *getErrorMessage(int errCode) {
  switch (errCode) {
  case SOMETHING_WENT_WRONG:
    return "Something bad happened, but I don't know more than that";
  case SOLAR_FLARE_DECTECTED:
    return "A solar flare, rather than programmer error, has caused a malfunction";
  case ANTS_IN_YOUR_CPU:
    return "Ants have nested in your CPU, causing all ALU functions to fail";
  default:
    return "I heard you like errors in your error handling. So ...";
  }
}

I really want to avoid the duplication of mentioning the error macro twice (DRY), and having the definition and error string in two different places (making it non-obvious that those adding an error code also need to update the error function).

So I'm looking for an approach that only uses 1 line(ish) per error code - the macro name, int error code and message all together.

Bonus points if I can leave the error string off and have the error string just be the stringified macro name (e.g., "SOMETHING_WENT_WRONG" for the first error).

I'm not too worried about lookup performance, so it's fine for example, to build an array and look through it in the lookup function.

Answer 1

I think there's a better way to do this using something called the X-macro. This technique allows you to define all of your codes and messages in one place and extract the relevant pieces from your table at compile-time. Attached below is a sample of (working) C code that does what you are expecting.

#include <stdio.h>

#define ERR_TABLE(V)                                                           \
  V(SOMETHING_WENT_WRONG,                                                      \
    "Something bad happened, but I don't know more than that")                 \
  V(SOLAR_FLARE_DECTECTED,                                                     \
    "A solar flare, rather than programmer error, has caused a malfunction")   \
  V(ANTS_IN_YOUR_CPU,                                                          \
    "Ants have nested in your CPU, causing all ALU functions to fail")

#define ERR_ID(id, text) id,
enum ErrId {
  ERR_TABLE(ERR_ID)
  kNumErrs,
};
#undef ERR_ID

const char* err_to_string(enum ErrId id) {
#define ERR_TEXT(id, text) text,
  static const char* table[] = {
    ERR_TABLE(ERR_TEXT)
  };
#undef ERR_TEXT
  if (id < 0 || id >= kNumErrs) {
    return "I heard you like errors in your error handling. So ...";
  }
  return table[id];
}

int main() {
  printf("%s\n", err_to_string(SOMETHING_WENT_WRONG));
  printf("%s\n", err_to_string(SOLAR_FLARE_DECTECTED));
  printf("%s\n", err_to_string(ANTS_IN_YOUR_CPU));
  printf("%s\n", err_to_string(100));
  printf("%s\n", err_to_string(-1));
  return 0;
}

And the output:

maple% gcc err.c -o err
maple% ./err 
Something bad happened, but I don't know more than that
A solar flare, rather than programmer error, has caused a malfunction
Ants have nested in your CPU, causing all ALU functions to fail
I heard you like errors in your error handling. So ...
I heard you like errors in your error handling. So ...
maple% 

If you want to leave the message off, just have the ERR_TEXT macro stringify the id (#id). If you want to define custom codes, you can add those as a separate field in the macro.

Answer 2

When I first came in this issue, I made it so that for every macro, I added a _STR macro next to it:

#define SOMETHING_WENT_WRONG     -1
#define SOMETHING_WENT_WRONG_STR "Something went wrong"

#define SOLAR_FLARE_DECTECTED  -2
#define SOLAR_FLARE_DECTECTED_STR "Solar flare detected"

#define ANTS_IN_YOUR_CPU       -3
#define ANTS_IN_YOUR_CPU_STR "Ants in your CPU"

const char *errorstr;
int errorno;
#define SET_ERROR(e) errorno = e; errorstr = e##_STR;

That way I could simply call SET_ERROR(ANTS_IN_YOUR_CPU) and the errorno and string would be taken care of.

Answer 3

enum errs {
    __ERR_NONE,
    SOMETHING_WENT_WRONG,
    SOLAR_FLARE_DECTECTED,
    ANTS_IN_YOUR_CPU,
    __ERR_MAX,
};
static const char * const errorstrings[__ERR_MAX] = {
    "__ERR_NONE",
    "Something bad happened, but I don't know more than that",
    "A solar flare, rather than programmer error, has caused a malfunction",
    "Ants have nested in your CPU, causing all ALU functions to fail",
};

//index the error strings by the error value
printf("%s\n", errorstrings[SOMETHING_WENT_WRONG]); // Something bad happened, but I don't know more than that

You can do some pretty clean conversion using the integers as indexes for the error strings.

Answer 4

Use a hash table where error codes as keys and string pointers as values. Bad news is that you need to fill it manually at runtime and good one is that you can use any error codes. Signed or even float numbers.