We can do it with a global variable.
static int reg;
int cmp(int a, int b) {
return a%reg - b%reg;
}
void qsortModX(int[] a, size_t len, int x) {
int tmp = reg;
reg = x;
qsort(a, len, sizeof(*a), cmp);
reg = tmp;
}
We could even wrap qsort so that you could pass something much closer to a closure to it :
static void* g_ctx;
static int(*g_cmp)(void*, const void*, const void*)
int compare(const void* a, const void* b) {
return g_cmp(g_ctx, a, b) ;
}
void qsort_cls(void*[] a, size_t len, size_t elem, int(*cmp)(void*, const void*, const void*), void* ctx) {
void* tmp = g_ctx;
g_ctx = ctx;
int(*tmp_f)(void*, const void*, const void*) = g_cmp;
g_cmp = cmp;
qsort(a, len, sizeof(*a), compare);
g_ctx = tmp;
g_cmp = tmp_f;
}
With this, you can define a `struct closure` that encapsulates a function and some data and use that to pass to qsort_cls. You can even make it thread safe by using thread local variables instead of globals.
Basically, if you want higher-order functions in C, you can do it, but you need to take a context pointer and a function which accepts a context pointer. The writers of qsort didn't think of that, so we had to resort to global variables to do it, but you could also re-write qsort to avoid the need for the global variable.
As I said, we're missing a lot of syntax sugar, but we can still work with functions as first class objects in pure C.