#include #include #include #include #include /* a small error management set of tools for C If you find any bug If you have any idea of improvement Please, let me know ! An example starts line 155 ;) */ //to be user definable, needs to be an unsigned integer type #ifndef ErrorCode # define ErrorCode unsigned short #endif #ifndef ERROR_LEVEL # define ERROR_LEVEL LEVEL_USER #endif #ifndef ERROR_TRACE_MAX_LENGTH # define ERROR_TRACE_MAX_LENGTH 2048 #endif #ifndef STRINGIFY # define STRINGIFY_impl(s) #s # define STRINGIFY(s) STRINGIFY_impl(s) #endif // to show debug log messages #define ERROR_DEBUG #ifdef ERROR_DEBUG # define LOG(...) printf(__VA_ARGS__) #else # define LOG(...) puts("deactivated") #endif // count is not an error level but the number of error levels, the default error level should be first typedef enum ErrorLevel{ LEVEL_USER, LEVEL_DEV, LEVEL_COUNT }ErrorLevel; typedef struct Error{ ErrorCode code; char * messages[LEVEL_COUNT]; char trace[ERROR_TRACE_MAX_LENGTH]; void * data; void (*freeData)(void *); }Error; Error * last_errors_[(ErrorCode)-1] = {NULL}; /** * @brief Create a new error * Create a new error with its code and either LEVEL_COUNT strings or less but a NULL at the end defining the error messages */ Error * newError(ErrorCode code, char * userMessage, ...); /** * Delete the error * @param error: error to be freed */ void freeError(Error * error); /** * Set the last error of its code as the specified error * @param error: error to be setted as last */ ErrorCode setLastError(Error * error); /** * Get the last error that occured with a specific code * @param code: code of the error to get * @return the last error raised with a specific code */ Error * getLastError(ErrorCode code); /** * @brief set the data of the error * Set the data of an error, if it has data before this call and has a free data behavior, the old data will be freed before setting the new data * @param error: error to set data to * @param data: data to be set to the error */ void setErrorData(Error * error, void * data); /** * Get the error data * @param error: error to get data from * @return the error data */ void * getErrorData(Error * error); /** * Set the error free data behavior * @param error: error to set the free data behavior to * @param freeData: behavior to set */ void setErrorFreeData(Error * error, void (*freeData)(void*)); /** * Get the error message of an error (using default error level) * @param error: error to get the message from * @return the error message */ const char * getErrorMessage(Error * error); /** * Get the error message of an error (using a specified error level) * @param error: error to get the message from * @param level: error level of the message to get * @return the error message */ const char * getErrorMessageLevel(Error * error, ErrorLevel level); /** * Get the trace of an error * @param error: error to get the trace from * @return the trace of the error */ const char * getErrorTrace(Error * error); /** * Set the trace of an error * @param error: error to get the trace from * @param trace: trace to be set */ void setErrorTrace(Error * error, const char * trace); /** * @brief Clear memory allocated of all last errors * This code does not compile on none GNU compilaters because of __attribute__. It allows to call clearAllErrors after the end of main call. Their are ways to do it on other systems (and I did it for this project: https://github.com/Klevh/LAssert ) but I was too lazy to do it here, om my phone ... sorry ^^ */ void clearAllErrors(void) __attribute__((destructor)); // ------------------------------------ // example of use typedef enum{ SUCCESS, NULL_PTR, WRONG_INPUT }User_Defined_Codes; ErrorCode factorial(short n, unsigned long long * result){ Error * error; short i; if(!result){ return setLastError(newError(NULL_PTR, "We could not compute factorial", "Output pointer is null")); } if(n < 0){ error = newError(WRONG_INPUT, NULL); setErrorTrace(error, "input lower than 0"); return setLastError(error); } *result = 1; for(i = 2; i <= n; ++i){ *result *= i; } return SUCCESS; } int main() { ErrorCode ec; Error * e; unsigned long long n; ec = factorial(1, NULL); assert(ec == NULL_PTR); e = getLastError(ec); assert(e); printf("\n%s\n%s\n\n", getErrorMessage(e), getErrorMessageLevel(e, LEVEL_DEV)); ec = factorial(-3, &n); assert(ec == WRONG_INPUT); e = getLastError(ec); assert(e); assert(!getErrorMessage(e)); assert(!getErrorMessageLevel(e, LEVEL_DEV)); printf("\n%s\n", getErrorTrace(e)); return 0; } // ------------------------------------ // ==================================== // error manager implementation void clearAllErrors(){ ErrorCode i; LOG("\nClearing all errors\n"); for(i = 0; i < (ErrorCode)-1; ++i){ freeError(last_errors_[i]); } freeError(last_errors_[(ErrorCode)-1]); } void setErrorTrace(Error * error, const char * trace){ if(error && trace){ LOG("Setting trace of error with code %u\n", error->code); strncpy(error->trace, trace, ERROR_TRACE_MAX_LENGTH); } } const char * getErrorTrace(Error * error){ if(error){ LOG("Getting trace of error with code %u\n", error->code); return (const char *)error->trace; } return NULL; } const char * getErrorMessageLevel(Error * error, ErrorLevel level){ if(error && level >= 0 && level < LEVEL_COUNT){ LOG("Getting message of level %d of error with code %u\n", level, error->code); return error->messages[level]; } return NULL; } const char * getErrorMessage(Error * error){ return getErrorMessageLevel(error, ERROR_LEVEL); } void setErrorFreeData(Error * error, void (*freeData)(void*)){ if(error){ LOG("Setting free data behavior of error with code %u\n", error->code); error->freeData = freeData; } } void * getErrorData(Error * error){ if(error){ LOG("Getting data of error with code %u\n", error->code); return error->data; } return NULL; } void setErrorData(Error * error, void * data){ if(error){ LOG("Setting data of error with code %u\n", error->code); if(error->data && error->freeData){ error->freeData(error->data); } error->data = data; } } Error * getLastError(ErrorCode code){ LOG("Getting last error with code %u\n", code); return last_errors_[code]; } ErrorCode setLastError(Error * error){ if(error){ LOG("Setting last error with code %u\n", error->code); freeError(last_errors_[error->code]); last_errors_[error->code] = error; return error->code; } return (ErrorCode)-1; } void freeError(Error * error){ size_t i = 0; if(error){ LOG("Freeing error with code %u\n", error->code); // removing it from global errors if(last_errors_[error->code] == error){ last_errors_[error->code] = NULL; } // deleting messages while(i < LEVEL_COUNT && error->messages[i]){ free(error->messages[i]); ++i; } // deleting data if(error->freeData && error->data){ error->freeData(error->data); } // deleting error free(error); } } Error * newError(ErrorCode code, char * userMessage, ...){ unsigned long i = 0; va_list vl; size_t size; _Bool failed = 0; Error * error = malloc(sizeof(*error)); if(error){ LOG("Creating error with code %u\n", code); // setting simple_data error->code = code; error->data = NULL; error->freeData = NULL; // setting messages if(userMessage){ va_start(vl, userMessage); do{ size = strlen(userMessage); error->messages[i] = malloc((size + 1) * sizeof(char)); if(error->messages[i]){ strcpy(error->messages[i], userMessage); }else{ failed = 1; } userMessage = va_arg(vl, char *); ++i; }while(i < LEVEL_COUNT && userMessage && !failed); va_end(vl); while(i < LEVEL_COUNT){ error->messages[i] = NULL; ++i; } // if allocation failed, deleting what was previously allocated if(failed){ LOG("Creation failed\n"); i = 0; while(error->messages[i]){ free(error->messages[i]); ++i; } free(error); error = NULL; } }else{ while(i < LEVEL_COUNT){ error->messages[i] = NULL; ++i; } } } return error; }

simple error manager