Is There a Better Way to Stringify Error Codes?

For the sake of seeing an alternative, here is a variation on @Lundin's very good answer.
This inverts the use of macros to achieve an analogous result.

// errors.tbl - NB: no header guards!

#ifdef ERR_AS_STR
const char *errStrs[];
static const char *errToStr( int code ) { return errStrs[code]; }
static const char *errStrs[] = {
#   define X(e,s) s
#else
enum {
#   define X(e,s) e
#endif

    X( ERR_NONE,            "No error" ),
    X( ERR_SERVERS_ON_FIRE, "The servers are on fire" ),
    X( ERR_LIVE_BEAVERS,    "Live beavers in the server room" ),
    X( ERR_N, NULL )
#   undef X
};

and

// main.c

#include <stdio.h>

#include "errors.tbl" // once as enums
#define ERR_AS_STR
#include "errors.tbl" // and now as array of strings (and getter)
#undef ERR_AS_STR

int main( void ) {
    for( int i = ERR_NONE; i < ERR_N; i++ ) puts( errToStr( i ) );
    return 0;
}

This is merely a minimal working prototype, to be adapted to suit requirements with regard to the visibility of the enum, the array and the "getter" function.

On some project, I decided I want to fix a similar problem. I decided that defining error code and error text in multiple places is not for me, I want to have all in one place. Instead, I decided that I will define error code and description in one place and preprocess the project files to extract the text and generate error codes to text table. Consider the following source code file:

#include <errorgen.h>
int some_library_function() {
     return ERROR_GEN(ERROR_SOME_ERROR, "This is error description")
}

Before compilation, a CMake or python script went through all the files. For each file containing ERROR_GEN, two files were generated - errorgen_list.h and errorgen_str.h. errorgen_list.h contained all the enums collected from ERROR_GEN functions. errorgen_str.h contained a "This is error description", a table to transform error code to a string. The script looks something along:

def get_all_errors_from_sources():
    rereplace = re.compile(
        r'ERROR_GEN\s*\(\s*(.*)\s*,\s*(".*")\s*\)\s*;',
        flags=re.MULTILINE,
    )
    dir = os.path.dirname(__file__)
    errors: List[Err] = []
    for path in Path(dir).glob("**/*.c"):
        for line in open(path).read():
            res = rereplace.findall(line)
            if res:
                errors += [Err(*res)]
    return errors

def prepare_sources(errors):
    enumout = "/* @file */\n"
    for k, v in errors:
        enumout += "\t" + k + ",  /// " + v + "\n"
    msgout = "/* @file */\n"
    for k, v in errors:
        msgout += "\t" + v + ",  // " + k + "\n"
    return (enumout, msgout)

errors = get_all_errors_from_sources()
enumout, msgout = prepare_sources(errors)
with Path("errorgen_list.h", "w") as f:
    f.write(enumout)
with Path("errorgen_str.h", "w") as f:
    f.write(msgout )

Then with the following errorgen.h:

 enum errorgen_errors_e {
    ERRORGEN_OK = 0,
    ERRORGEN_START = -1000,
 #include "errorgen_list.h"
    ERRORGEN_STOP,
 };

 #define ERROR_GEN(a, b)  a

 const char *error_to_str(int);

And the following errorgen.c:

 static const char *const errorsgen_str[] = {
 #include "errorgen_str.h"
 };

 const char *error_to_str(int err) {
     // error handling...
    return errorsgen_str[err - ERRORGEN_START - 1];
 }
  

I could easily keep error code with error string together in the source code. This resulted in multitude of error codes and easier to track them and more readable error codes. The proper dependency has to modelled in the build system, so that the build system knows to generate errorgen_* before compiling the files.