Error communication between functions in C using linked list

Question

There are functions in different files in my C program between which I want to communicate errors. For example: MEMOERY_ALLOCATION_FAILED, FILE_OPENING_FAILED or NAME_NOT_VALID.

I thought of creating an Error linked list like so:

typedef struct Error {
    char *message;
    struct Error *next;
};

And pass this linked list to every function so the functions can add errors if those occur, like so:

int foo(int x, Error *list);

But there is a problem with this one. When allocating space for a new Error, that could fail and the function that called that function could not receive that information.

What are some useful ideas to solve such a problem? Note that I cannot return error codes because:

1. A function can append more than one error
2. The functions needs to return other things

Answer 1

But there is a problem with this one. When allocating space for a new Error, that could fail and the function that called that function could not receive that information.

If you're worried about the dynamic allocation of memory for errors you could try pre-allocating arrays of error structures and pre-allocating a fixed size of memory for error messages.

However, as another user mentioned, why would the program continue after a large error has occurred? At that point it's usually better to simply have the function return an error value, rather than try to continue execution.

Answer 2

/******************************************************************************

                            Online C Compiler.
                Code, Compile, Run and Debug C program online.
Write your code in this editor and press "Run" button to compile and execute it.

*******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

// Define the Error structure
typedef struct Error {
    int errorCode;
    char errorMessage[100];
    struct Error *next;
} Error;

// Function to create a new Error node
Error* createError(int code, const char* message) {
    Error *newError = (Error*)malloc(sizeof(Error));
    if (newError == NULL) {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
    newError->errorCode = code;
    strncpy(newError->errorMessage, message, sizeof(newError->errorMessage));
    newError->next = NULL;
    return newError;
}

// Function to insert an Error node at the beginning of the list
void insertError(Error **head, int code, const char* message) {
    Error *newError = createError(code, message);
    newError->next = *head;
    *head = newError;
}

// Function to print all Errors in the linked list
void printErrors(Error *head) {
    Error *current = head;
    while (current != NULL) {
        printf("Error Code: %d, Message: %s\n", current->errorCode, current->errorMessage);
        current = current->next;
    }
}

// Function to free the entire linked list
void freeErrors(Error *head) {
    Error *current = head;
    while (current != NULL) {
        Error *temp = current;
        current = current->next;
        free(temp);
    }
}


// Define a struct to hold the result and error information
struct DoubleResult {
    double value;  // Result
    Error *error;  // Error 
};

struct DoubleResult divide(double a, double b, Error *head) {
    struct DoubleResult result;

    if (a >= INT_MAX) {
        // catch first error
        insertError(&head, 100, "Value a is overflow");
    }
    if (b == 0) {
        // catch second error
        insertError(&head, 101, "Division by zero");
    }
    if (a >= INT_MAX || b == 0) {
        // errors
        result.error = head;
        result.value = -1; // default if error
        return result;
    }

    // success
    result.error = NULL;  // default if success
    result.value = a/b;
    return result;
}


int main() {
    Error *head = NULL;

    // example 1
    printf("divide(INT_MAX, 0)\n");
    struct DoubleResult result1 = divide(INT_MAX, 0, head);
    if(result1.error == NULL) {
        // success
        printf("result %.f\n", result1.value);
    }
    else {
        // error
        printErrors(result1.error);
    }

    printf("\n");


    // example 2
    printf("divide(10, 2)\n");
    struct DoubleResult result2 = divide(10, 2, head);
    if(result2.error == NULL) {
        // success
        printf("result %.f\n", result2.value);
    }
    else {
        // error
        printErrors(result2.error);
    }

    
    // Free the allocated memory
    freeErrors(head);

    return 0;
}
    

Result:

divide(INT_MAX, 0)
Error Code: 101, Message: Division by zero
Error Code: 100, Message: Value a is overflow

divide(10, 2)
result 5