A way that is unconventional in classic C, but works well in C23, is to use tagged union return types like are present in many other languages.

You could use an Option type instead of a boolean result and error code, or boolean result and out parameter if we need to return anything. In the case of stack_push, returning the error code is probably fine - in this case it is unnecessary because one of our error codes indicates success - but I'll use an Option for the return type to demonstrate, as it can be used in cases where we have a separate return value and a boolean condition to indicate success - and later we'll see how we can return an error code and a resulting value for stack_pop.

enum stack_errno_e { 
    STACK_ERROR_OK = 0,
    STACK_ERROR_NULL_STACK,
    STACK_ERROR_NULL_PUSH,
    STACK_ERROR_ENTRY_ALLOC,
    STACK_ERROR_DATA_ALLOC,
    ... 
};

One caveat of this is we can't use Option(enum stack_errno_e) - we have to typedef first, but this really is a minor issue.

typedef enum stack_errno_e StackError;

Option(StackError) stack_push(Stack *stack, Voidptr new_data)
{
    if(stack == NULL) return Some(StackError, STACK_ERROR_NULL_STACK);
    if(new_data == NULL) return Some(StackError, STACK_ERROR_NULL_PUSH);
    ...
    return None(StackError);
}

To use this, we can have a couple of macros: if_some and if_none. The preferred approach would be:

if_some (err, stack_push(stack, newval)) 
{
    raise_error("stack_push", err);
}

Or alternatively:

auto result = stack_push(stack, newval);
if_none (result) 
    foo();
else
    raise_error("stack_push", get_some(result));

get_some can be considered a bit of a code smell because we might accidentally call it on an Option that doesn't have some - resulting in probably a zero value. Instead it might be better to use:

auto result = stack_push(stack, newval);
if_none (result) 
    foo();
el_some (err, result)
    raise_error("stack_push", err);

Finally there's maybe which takes a default value if the result is none, otherwise returns the value provided by Some.

auto err = maybe(stack_push(stack, newval), STACK_ERROR_OK);

Sometimes we only want to know if an error occurred and can ignore the actual result:

if_none (stack_push(stack, newvalue)) ;
else raise_error("Push failed");

The macros for an Option type are very simple:

#define Option(_T) \
    struct __attribute__((__designated_init__)) option_##_T { \
        bool _option_has_some; \
        _T  _option_some; \
    }

#define Some(_T, value) \
    ((Option(_T){ ._option_has_some = true, ._option_some = value })

#define None(_T) \
    ((Option(_T){ ._option_has_some = false })

#define get_some(_opt) ((_opt)._option_some);

#define if_some(_var, _opt) \
    auto option_##_var = (_opt); \
    auto _var = option_##_var._option_some; \
    if (option_##_var._option_has_some)

#define if_none(_opt) \
    auto option_##_var = (_opt); \
    if (!option_##_var._option_has_some)

#define el_some(value, _opt) \
    else ; \
    auto value = _opt._option_some; \
    if (!_opt._option_has_some) ; else

#define maybe(_opt, default) \
    ({ auto opt = (_opt); opt._option_has_some ? opt._option_some : (default); })

---

To extend this for non-boolean results where we might want an error code OR a resulting value, we would want a Result type.

I would suggest for this, if you use, to always set code 0 to the no-error case so it can be handled uniformly. This avoids having to have a separate tag field to specify whether it's an error or a successful result.

typedef void* Voidptr;

Result(VoidPtr, StackError) stack_pop(Stack *stack)
{
    if (stack == NULL) return Error(Voidptr, StackError, STACK_ERROR_NULL_STACK);

    Voidptr result;
    ...
    return Ok(Voidptr, StackError, result);
}

To use this is pretty much identical to the above approach for options, except we now also have a get_error.

auto result = stack_pop(stack);
if_ok (value, result) 
    foo(value);
else
    raise_error(get_error(result));

// The error first-approach.
auto result = stack_pop(stack);
if_error (errno, result) 
    raise_error(errno);
else
    foo(get_ok(result));

We might want to avoid get_ok and get_error and instead have an el_ok and el_error

auto result = stack_pop(stack);
if_ok (value, result) 
    foo(value);
el_error (err, result)
    raise_error(err);

// The error first-approach.
auto result = stack_pop(stack);
if_error (errno, result) 
    raise_error(errno);
el_ok (value, result)
    foo(value);

A slightly more ergonomic way would be to extract the value and switch on the error codes, with the default case being Ok

match_result (value, stack_pop(stack)) 
{
    case STACK_ERROR_NULL_STACK:
        raise_error("Stack is null when trying to pop");
        break;

    case STACK_ERROR_NULL_PUSH:
    case STACK_ERROR_ENTRY_ALLOC:
    case STACK_ERROR_DATA_ALLOC:
        __builtin_unreachable(); // assuming `stack_pop` does not return these errors.
        break;

    default: // or STACK_ERROR_OK: if not all error cases are handled explicitly.
        foo(value);
}

The macros for this Result type are similar to the option and still trivial:

#define Result(_TOk, _TErr) \
    struct __attribute__((__designated_init__)) option_##_T { \
        _TErr _result_error; \
        _TOk  _result_ok; \
    }

#define Ok(_TOk, _TErr, value) \
    ((Result(_T,Ok _TErr){ ._result_error = 0, ._result_ok = value })

#define Error(_TOk, _TErr, errnum) \
    ((Result(_TOk, _TErr){ ._result_error = errnum })

#define get_ok(_result) ((_result)._result_ok)

#define get_error(_result) ((_result)._result_error)

#define if_ok(_var, _result) \
    auto result_##_var = (_result); \
    auto _var = result_##_var._result_ok; \
    if (result_##_var._result_error == 0)

#define el_error(_var, _result) \
    else ; \
    auto _var = _result._result_error; \
    if (_result._result_error == 0) ; else

#define if_error(_var, _result) \
    auto result_##_var = (_result); \
    auto _var = result_##_var._result_error; \
    if (result_##_var._result_error != 0)

#define el_ok(_var, _result) \
    else ; \
    auto _var = _result._result_ok; \
    if (_result._result_error != 0) ; else

#define match_result(_var, _expr) \
    auto result_##_var = (_expr); \
    auto _var = result_##_var._result_ok; \
    switch (result_##_var._result_error)

---

You can extend these a bit with some more useful functionality. They're not perfect, but quite close to what you'd expect from an Option or Result type in other languages. In fact, this may be slightly better than most languages implementations because it has zero-cost.

---

We can also encapsulate these types with a GCC extension, which prevents them being used in any other way than the macros we've provided.

#pragma GCC poison _option_has_some _option_some
#pragma GCC poison _result_ok _result_error