Generic function pointer + Clang block dispatch

Tue, 28 Jul 2026 00:00:00 +0000

Generic function pointers + Clang blocks

Function pointers and Clang blocks ^{ } are distinct types and don’t work together interchangeably. Which is annoying when you like the blocks syntax. But it isn’t standard, so putting it in a public open source library means either making two duplicate functions or two separate entry points.

So I wrote this:

#define UNWRAP(...) __VA_ARGS__

// --- FOR_EACH infrastructure (up to 8 params, can obvious be extended if needed) ---
#define PP_NARGS(...) PP_NARGS_(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define PP_NARGS_(a,b,c,d,e,f,g,h,n,...) n
#define PP_CONCAT(a, b) PP_CONCAT_(a, b)
#define PP_CONCAT_(a, b) a ## b

#define PP_FOREACH(m, ...) PP_CONCAT(PP_FOREACH_, PP_NARGS(__VA_ARGS__))(m, __VA_ARGS__)
#define PP_FOREACH_0(m)
#define PP_FOREACH_1(m, a) m(a)
#define PP_FOREACH_2(m,a,...) m(a), PP_FOREACH_1(m, __VA_ARGS__)
#define PP_FOREACH_3(m,a,...) m(a), PP_FOREACH_2(m, __VA_ARGS__)
#define PP_FOREACH_4(m,a,...) m(a), PP_FOREACH_3(m, __VA_ARGS__)
#define PP_FOREACH_5(m,a,...) m(a), PP_FOREACH_4(m, __VA_ARGS__)
#define PP_FOREACH_6(m,a,...) m(a), PP_FOREACH_5(m, __VA_ARGS__)
#define PP_FOREACH_7(m,a,...) m(a), PP_FOREACH_6(m, __VA_ARGS__)
#define PP_FOREACH_8(m,a,...) m(a), PP_FOREACH_7(m, __VA_ARGS__)

// --- Parameter pair extractors ---
#define PP_TYPE(pair) PP_TYPE_ pair
#define PP_TYPE_(t, n) t
#define PP_NAME(pair) PP_NAME_ pair
#define PP_NAME_(t, n) n
#define PP_DECL(pair) PP_DECL_ pair
#define PP_DECL_(t, n) t n

#define TYPES(...) PP_FOREACH(PP_TYPE, __VA_ARGS__)
#define NAMES(...) PP_FOREACH(PP_NAME, __VA_ARGS__)
#define DECLS(...) PP_FOREACH(PP_DECL, __VA_ARGS__)

/*
 * Main implementation macro.
 * GENERIC_CALLBACK_IMPL(name, ret, (type1, name1), (type2, name2), ...)
 */
#define GENERIC_CALLBACK_IMPL(name, ret, ...) \
 typedef struct { \
 ret (^block)(TYPES(__VA_ARGS__), void *user_data); \
 void *user_data; \
 } name##_block_wrapper_t; \
 \
 ret name##_impl(DECLS(__VA_ARGS__), void *user_data, ret (*callback)(TYPES(__VA_ARGS__), void *user_data)); \
 ret name##_block(DECLS(__VA_ARGS__), void *user_data, \
 ret (^callback)(TYPES(__VA_ARGS__), void *user_data)); \
 \
 static ret name##_block_callback(DECLS(__VA_ARGS__), void *wrapper_data) { \
 name##_block_wrapper_t *wrapper = (name##_block_wrapper_t *)wrapper_data; \
 return wrapper->block(NAMES(__VA_ARGS__), wrapper->user_data); \
 } \
 \
 ret name##_block(DECLS(__VA_ARGS__), void *user_data, ret (^callback)(TYPES(__VA_ARGS__), void *user_data)) { \
 name##_block_wrapper_t wrapper = { \
 .block = callback, \
 .user_data = user_data \
 }; \
 return name##_impl(NAMES(__VA_ARGS__), &wrapper, name##_block_callback); \
 } \
 \
 ret name##_impl(DECLS(__VA_ARGS__), void *user_data, \
 ret (*callback)(TYPES(__VA_ARGS__), void *user_data))

// Dispatch macro using _Generic
#define GENERIC_CALLBACK(name, ret, types, callback) \
 _Generic((callback), \
 ret (^)(UNWRAP types, void *): name##_block, \
 ret (*)(UNWRAP types, void *): name##_impl)

// Convenience call macro
#define GENERIC_CALL(name, ret, types, callback, ...) \
 GENERIC_CALLBACK(name, ret, types, callback)(__VA_ARGS__, callback)

// --- Examples ---

#define directory_walk(path, userdata, callback) \
 GENERIC_CALL(directory_walk, int, (const char *), callback, path, userdata)

GENERIC_CALLBACK_IMPL(directory_walk, int,
 (const char *, path))
{
 if (!path || !callback)
 return 0;

 printf("Walking directory: %s\n", path);
 int result = callback(path, user_data);
 return result;
}

#define process_file(path, flags, size, userdata, callback) \
 GENERIC_CALL(process_file, bool, (const char *, int, size_t *), callback, path, flags, size, userdata)

GENERIC_CALLBACK_IMPL(process_file, bool, (const char *, path), (int, flags), (size_t *, size)) {
 if (!path || !callback)
 return false;
 printf("Processing file: %s (flags=%d)\n", path, flags);
 bool result = callback(path, flags, size, user_data);
 if (size) {
 printf(" Size set to: %zu\n", *size);
 }
 return result;
}

int directory_walk_callback(const char *path, void *user_data) {
 printf(" [func ptr] callback: %s\n", path);
 return 1;
}

bool process_file_callback(const char *path, int flags, size_t *size, void *user_data) {
 printf(" [func ptr] callback: %s (flags=%d)\n", path, flags);
 if (size)
	 *size = 12345;
 return true;
}

int main(void) {
 directory_walk("/test/path1", NULL, directory_walk_callback);

 directory_walk("/test/path2", NULL, ^(const char *path, void *user_data) {
 printf(" [block] callback: %s\n", path);
 return 1;
 });

 size_t size1 = 0;
 process_file("/file1.txt", 42, &size1, NULL, process_file_callback);

 size_t size2 = 0;
 process_file("/file2.txt", 99, &size2, NULL, ^bool(const char *path, int flags, size_t *size, void *user_data) {
 printf(" [block] callback: %s (flags=%d)\n", path, flags);
 if (size) *size = 67890;
 return true;
 });

 return 0;
}

Walking directory: /test/path1
 [func ptr] callback: /test/path1
Walking directory: /test/path2
 [block] callback: /test/path2
Processing file: /file1.txt (flags=42)
 [func ptr] callback: /file1.txt (flags=42)
 Size set to: 12345
Processing file: /file2.txt (flags=99)
 [block] callback: /file2.txt (flags=99)
 Size set to: 67890

Write one function body, and the macro automatically creates the wrappers. It uses _Generic compile-time dispatch and both paths funnel back into a single implementation function. Everything else is hidden to keep things clean.

Swizzling vectors in C

Mon, 27 Jul 2026 00:00:00 +0000

Swizzling vectors in C

In GLSL it’s possible to access arbitrary vector accessors vec.xyz, vec.yw. I always thought this was neat, so I thought about trying to implement it in C.

First approach

For the first attempt I used a Ruby script to generate vector unions with each permutation of the vector type’s accessors.

#!/usr/bin/env ruby

$INC = 0

types = [:float, :int, :double]

origElements = [
 [
 [:x, :y],
 [:u, :v],
 [:s, :t]
 ],
 [
 [:x, :y, :z],
 [:r, :g, :b],
 [:s, :t, :p]
 ],
 [
 [:x, :y, :z, :w],
 [:r, :g, :b, :a],
 [:s, :t, :p, :q]
 ]
]

def swizzlePermutations3(e)
 [
 e,
 [[e[0], e[1]], nil],
 [nil, [e[1], e[2]]]
 ]
end

def swizzlePermutations4(e)
 [
 e,
 [[e[0], e[1]], [e[2], e[3]]],
 [[e[0], e[1], e[2]], nil],
 [nil, [e[1], e[2], e[3]]]
 ]
end

def swizzlePermutations(e)
 case e.length
 when 2
 e
 when 3
 swizzlePermutations3 e
 when 4
 swizzlePermutations4 e
 end
end

elements = origElements.map { |e| e.map { |ee| swizzlePermutations ee } }

def swizzlePrintBasic(e, t)
 puts "\tstruct {"
 e.each do |ee|
 puts "\t\t#{t} #{ee};"
 end
 puts "\t};"
 puts "\t#{t} #{e.join}[#{e.length}];"
end

def swizzlePrint(e, t)
 case e[0].class.to_s
 when 'Symbol'
 swizzlePrintBasic e, t
 when 'Array'
 e.each do |ee|
 u = ee.map { |eee| eee.class }.uniq
 if u.length == 1 && u[0] == Symbol
 swizzlePrintBasic ee, t
 else
 eee = ee.map do |eee|
 case eee.class.to_s
 when 'Array'
 eee.join.to_s
 when 'NilClass'
 $INC += 1
 '_' * $INC
 end
 end
 puts "\tstruct {"
 eee.each do |eeee|
 if eeee.include? '_'
 puts "\t\t#{t} #{eeee};"
 else
 puts "\t\tvec#{eeee.length}#{t.to_s[0]} #{eeee};"
 end
 end
 puts "\t};"
 end
 end
 end
end

types.each do |t|
 elements.each_with_index do |e, i|
 puts "typedef union {"
 e.each { |ee| swizzlePrint ee, t }
 puts "\t#{t} elements[#{e[0].length}];"
 puts "\vec#{i+2}#{t.to_s[0]} vec;" if t == :float
 puts "} vec#{i+2}#{t.to_s[0]};"
 puts
 $INC = 0
 end
end

sizes = [2, 3, 4]

types.each do |t|
 t_char = t.to_s[0]
 t_name = t.to_s

 sizes.each do |n|
 puts "typedef union {"

 # Raw elements
 puts "\t#{t_name} elements[#{n*n}];"

 # Column vectors (Column-Major Order)
 # Access as m.col[i]
 puts "\tvec#{n}#{t_char} col[#{n}];"

 # Named columns
 # Access as m.col0, m.col1, ...
 puts "\tstruct {"
 n.times do |i|
 puts "\t\tvec#{n}#{t_char} col#{i};"
 end
 puts "\t};"

 # Scalar members (Column-Major storage: m00, m10, m20... then m01, m11...)
 # Access as m.m00, m.m10, ...
 puts "\tstruct {"
 n.times do |j| # Col index
 n.times do |i| # Row index
 puts "\t\t#{t_name} m#{i}#{j};"
 end
 end
 puts "\t};"

 puts "} mat#{n}#{t_char};"
 puts
 end
end

This generates (for 2, 3, and 4 length vectors):

takeiteasy

Generic function pointer + Clang block dispatch

Generic function pointers + Clang blocks

Swizzling vectors in C

Swizzling vectors in C

First approach