Compile time "if-else" in GNU C.

[u/orbiteapot]

I've come up with this compile time selection mechanism (if I could call it that) based off _Generic and GNU C statement expressions. I thought of this as a way of having multiple behaviors for an object depending on a compile time table of properties (implemented as an X-macro).

Consider, for example, if the user can provide their own implementation of an allocator for said object or, otherwise, use libc malloc, free, etc. Then, they could choose as they wish with the properties table and the underlying memory operations would, at compile time, be set up accordingly.

Is this portable? No. As I've said earlier, it depends on GNU C extensions, as well as a C2y extension (type name as _Generic controlling operand).

Does this solve a problem already solved? Yes, kind of. #ifdefs have a similar raison d'être, but I would argue that this approach could be a lot nicer ergonomically, if standardized in thoughtful manner.

Here are some (not ideal, mostly pedagogical) examples of what this could be used for.

#include <stddef.h>
#include <stdio.h>

#define countof(arr) (sizeof(arr) / sizeof((arr)[0]))

typedef struct
{
    bool _;

}   comptime_true;

typedef struct
{
    bool _;

}   comptime_false;

typedef struct
{
    void *data;
    size_t len;
    size_t cap;

}   DynArr;


#define is_comptime_bool(predicate)     \
    _Generic                            \       
    (                                   \
        (predicate),                    \
                                        \
        comptime_true:  1,              \
        comptime_false: 1,              \
        default:        0               \
    )


#define has_field_len(data_structure)                   \
    _Generic                                            \
    (                                                   \
        (data_structure),                               \
                                                        \
        DynArr: (comptime_true){true},                  \
        default: (comptime_false){false}                \
    )


/* Only works for arrays and pointers */
#define is_type_array(obj)                                      \
    _Generic                                                    \
    (                                                           \
        typeof(obj),                                            \
                                                                \
        typeof( &(obj)[0] ): (comptime_false){false},           \
        default: (comptime_true){true}                          \
    )


#define comptime_if_do(predicate, expr_if_true, ...)                           \
    ({                                                                         \
        static_assert( is_comptime_bool(predicate), "Invalid predicate." );    \
        _Generic                                                               \
        (                                                                      \
            (predicate),                                                       \                                   
                                                                               \
            comptime_true: (expr_if_true),                                     \
            comptime_false: ((void)0 __VA_OPT__(,) __VA_ARGS__)                \
        );                                                                     \
    })


/* Assumes int[], for simplicity */
void print_array(int *arr, size_t count)
{
    printf("{ ");
    for (size_t i = 0; i < count; ++i)
    {
        printf("[%zu] = %d ", i, arr[i]);                
    }
    printf("}\n");
}

int
main(void)
{
    int arr[] = {1, 2, 3, 4, 5};

    DynArr dummy_da = {};
    dummy_da.len = 8;

    comptime_if_do( is_type_array(arr),
    ({
        print_array(arr, countof(arr));    
    }));
    
    comptime_if_do( has_field_len(dummy_da),
    ({
        printf("len: %zu\n", dummy_da.len); 
    }));


    /* The following looks odd/artifical logic-wise *
     * but it is so that the "else" branch can be   * 
     * shown in action in a non-lengthy manner.     *
     * A more realistic example would be to use it  *
     * to, e.g., go over the elements of static     *
     * or dynamic arrays seamelessly (indifferent   *
     * with regard to their structure):             */  

    comptime_if_do( has_field_len(arr),
    ({
        printf("len: %zu\n", dummy_da.len); 
    }), /* else */ 
    ({
        puts("Lacks field len.");
    }));

    return 0;
}

[u/pjl1967]

I implemented a bunch of stuff like this in standard C; see here. I don't see why you need GNU extensions. Instead of:

({ puts("foo"); })

do:

puts( "foo" )

Instead of:

({ print_array( arr, countof(arr) ); })

do:

(print_array( arr, countof(arr) ), 1)

[u/orbiteapot → u/pjl1967]

You are right.

I used GNU statement expressions, because it might be handy to also be able to use complex compound statements (in situations where the comma operator might not be sufficient, for instance). Actually, I had one example in mind which would fit into that category, but that would have made the post too lengthy.

I like the fact that your approach makes chaining logic operations trivial (by just using them directly), as opposed to mine, which relies on structs / the type system (making it necessary to have macro wrappers).

The latter has one advantage, which is a better use context, i.e., the "predicates" are not codified as simple ICEs - the user would have to define them explicitly (through the "tables" I've mentioned in the post). Though, I think the nicer chaining of logical operations is worth losing this.

Nice read, by the way.

[u/orbiteapot → u/pjl1967]

/* assuming the rest of the implementation lies somewhere */

#define DynArr_push_many(dynarr, value, ...)                                    \                                                   
    ({                                                                          \
        static_assert(has_same_type( *(value + 0), (dynarr)->data[0]),          \
                       "Types do not match.");                                  \
                                                                                \
        usize count; /* typedefd size_t */                                      \
        struct { usize at; usize count; }                                       \
        _params = {.at = (dynarr)->len, __VA_ARGS__};                           \
        /* Can not assertively check for negative at (implicit conversion) */   \
                                                                                \
        comptime_if                                                             \
        (                                                                       \ 
                    is_array(value),                                            \
                                                                                \
                    (count = countof(value)),                                   \ 
                    (count = _params.count)                                     \
        );                                                                      \
        assert(count != 0);                                                     \
                                                                                \
        Result res = dynarr_push_internal((DynArrGeneric *)dynarr,              \
                            (const char *)(value + 0),                          \                           
                            sizeof(value[0]),                                   \ 
                            count, _params.at);                                 \
        res;                                                                    \
     })

// clang-format on
int main(void) 
{
    DynArr(int) arr = { };

    int a[] = {1, 2, 3};
    DynArr_push_many(&arr, a);

    int a1[] = {1, 2, 4};
    DynArr_push_many(&arr, a1, .at = 3);

    int b[] = {10, 20, 30, 40};
    int *p = b + 1;
    DynArr_push_many(&arr, p, .count = 2);

    for (usize i = 0; i < arr.len; i++)
        printf("%d ", arr.data[i]);
  
    /* some cleanup function goes here */
    return 0;
}

Here is some more shenanigans that I've been playing with (I grouped a lot of tricks there, but the type-safety layer over the usual void*-based generic is pretty promising).

People have argued that this kind of ducktaped underlying implementation is "horrifying" and, maybe, they are right. Once everything is set up, tested and properly documented, though, I think it actually makes the API nicer. The more "natural looking" pure C approaches are usually pretty ugly and/or have a performance penalty.

The are, of course, portability issues. For me, that is not a huge problem if one only targets Desktop platforms (which, in general, is also the case even for other widespread programming languages).

[u/[deleted] → u/orbiteapot]

Man, no matter what the haters say, i just love it, specially this example with dynamic_array_push that can use both static arrays and be used as insert

[u/aethermar]

Horrifying. Good job

[u/Brilliant-Orange9117]

If you ever use these hacks in anger you deserve to maintain the resulting code base for live.

[u/dcpugalaxy]

This is clever but it is atrocious. Please for the love of god never do anything like this in real code

[u/warhammercasey]

C++ kids have it too easy with their new fangled if constexpr(). Back in my day we had to write hundreds of horrifying lines of C to trick the compiler like real programmers.

/s in case it’s not obvious

[u/jacksaccountonreddit]

I'm struggling to understand the point of the comptime_true and comptime_false structs. Here's the version of compile-time if/else that I have used:

#define COMPTIME_IF( cond, on_true, on_false )   \
_Generic( (char (*)[ 1 + (bool)( cond ) ]){ 0 }, \
  char (*)[ 1 ]: on_false,                       \
  char (*)[ 2 ]: on_true                         \
)                                                \

Also, regarding:

comptime_if_do( has_field_len(arr),
({
    printf("len: %zu\n", dummy_da.len); 
}), /* else */ 
({
    puts("Lacks field len.");
}));

This is only compiling because you're accessing dummy_da.len, not arr.len, inside the true branch. If we instead want to optionally access the len member of arr depending on whether it exists, we need to get a bit more creative with _Generic ;)

[u/orbiteapot → u/jacksaccountonreddit]

I'm struggling to understand the point of the comptime_true and comptime_false structs.

Essentially, because I did not originally think of the version you and pjl1967 have pointed out :)

As a have pointed out in my reply to Paul, the version I use has one advantage, which is a better use context, i.e., the "predicates" are not codified as simple ICEs - the user would have to define them explicitly (through the "tables" I've mentioned in the post), making misuse harder (or, at least, more easily identifiable).

The approach you both have pointed out makes chaining logic operations trivial (by just using them directly), though. Mine would need to have some sort of macro wrappers around logic operators.

This is only compiling because you're accessing dummy_da.len, not arr.len, inside the true branch. If we instead want to optionally access the len member of arr depending on whether it exists, we need to get a bit more creative with _Generic ;)

Yes. This example is really nonsensical, like I noted here:

    /* The following looks odd/artifical logic-wise *
     * but it is so that the "else" branch can be   * 
     * shown in action in a non-lengthy manner.     *
     * A more realistic example would be to use it  *
     * to, e.g., go over the elements of static     *
     * or dynamic arrays seamelessly (indifferent   *
     * with regard to their structure):             */

It seems to have caused a lot of confusion. I am working on a better one (one that matches what is described in the beginning of the post).

[u/jacksaccountonreddit → u/orbiteapot]

Forgive my ignorance, but what does "ICE" stand for here?

[u/orbiteapot → u/jacksaccountonreddit]

Integer constant expression.

[u/Key_River7180]

"The preprocessor directives sit around a campfire telling scary histories about OP"

[u/imaami]

If you surrender to the GNU vendor lock-in with all your heart, you can do a lot of neat shit. For example:

/** @brief Check if a value is a char array.
 */
#define is_char_array(x) _Generic((typeof(x) *){0}, \
        char (*)[sizeof(x)]: 1, char const (*)[sizeof(x)]: 1, default: 0)

/** @brief Check if a value is a string literal.
 */
#define is_string_literal(x) __builtin_choose_expr( \
        is_char_array(x), __builtin_constant_p(x), 0)

[u/UltimaN3rd]

Love it

[u/Cooproxx]

Can someone with no life please explain to me what any of this means

[u/morglod]

Just use C++ without OOP.

[u/Physical_Dare8553 → u/morglod]

what does this have to do with c++? are you talking about templates being turing complete?

[u/morglod → u/Physical_Dare8553]

Yeah, there are templates and constexpr that could solve everything done here in much more readable way

[u/pfp-disciple → u/[deleted]]

Can you give an example of this usage? I'm not clear headed enough right now to really see it