From 65a5ea404fdbd19f3996a11348c2e7e09e8f06a4 Mon Sep 17 00:00:00 2001
From: Stefan Zabka <zabkaste@hu-berlin.de>
Date: Tue, 16 Jun 2020 12:50:47 +0200
Subject: Added ppmlib to cmake and threapool.h

---
 04_exercise/CMakeLists.txt  |   7 +-
 04_exercise/ppmlib.h        | 592 --------------------------------------------
 04_exercise/ppmlib/ppmlib.h | 592 ++++++++++++++++++++++++++++++++++++++++++++
 04_exercise/threadpool.h    |   1 +
 4 files changed, 598 insertions(+), 594 deletions(-)
 delete mode 100644 04_exercise/ppmlib.h
 create mode 100644 04_exercise/ppmlib/ppmlib.h

(limited to '04_exercise')

diff --git a/04_exercise/CMakeLists.txt b/04_exercise/CMakeLists.txt
index 18f3fb7..642da4c 100644
--- a/04_exercise/CMakeLists.txt
+++ b/04_exercise/CMakeLists.txt
@@ -6,7 +6,7 @@ target_link_libraries(quicksort PRIVATE threadpool)
 
 add_library(threadpool threadpool.c)
 target_link_libraries(threadpool PRIVATE array Threads::Threads arena_list)
-target_link_libraries(threadpool INTERFACE warnings)
+target_link_libraries(threadpool INTERFACE warnings ppmlib)
 
 
 add_executable(fibonacci main.c)
@@ -23,4 +23,7 @@ target_link_libraries(arena_test PRIVATE arena_list)
 
 add_library(rwlock rwlock/rwlock.c)
 target_include_directories(rwlock PUBLIC rwlock)
-target_link_libraries(rwlock INTERFACE warnings)
\ No newline at end of file
+target_link_libraries(rwlock INTERFACE warnings)
+
+add_library(ppmlib INTERFACE)
+target_include_directories(ppmlib INTERFACE ppmlib)
\ No newline at end of file
diff --git a/04_exercise/ppmlib.h b/04_exercise/ppmlib.h
deleted file mode 100644
index 7a7f3db..0000000
--- a/04_exercise/ppmlib.h
+++ /dev/null
@@ -1,592 +0,0 @@
-/***************************************************************************//**
- * @file ppmlib.h
- * @author Dorian Weber
- * @brief Contains a small macro library used for preprocessor programming.
- * 
- * @details
- * Preprocessor metaprogramming is very valuable in larger C projects. It's
- * efficient and can manipulate code at a very basic level. This small library
- * is intended to facilitate macro programming by collecting commonly used
- * macro functions. It supports argument lists with a size of up to 32.
- ******************************************************************************/
-
-#ifndef PPMLIB_H_INCLUDED
-#define PPMLIB_H_INCLUDED
-
-#include <stddef.h>
-
-/**@brief Tests if the integer type of a variable is signed.
- * @attention Due to the integer promotion rules in C, this will only work for
- * variables of type \c int and upwards, not for char and short.
- * @note Credit goes to Jens Gustedt for this typeless type cast for integer.
- */
-#define IS_SIGNED(VAR) \
-	((1 ? -1 : VAR) < 0)
-
-/**@brief Number of bits in inttype_MAX, or in any (1<<k)-1 where 0 <= k < 2040.
- * @note Credit goes to Hallvard B. Furuseth for inventing this gem.
- * 
- * Use it like:
- * @code
- * 	printf("%u", PRECISION(-1u)); // prints 32 if `unsigned int` uses 32-bits
- * @endcode
- */
-#define PRECISION(MAX) \
-	((MAX)/((MAX)%255 + 1)/255%255*8 + 7 - 86/((MAX)%255 + 12))
-
-/**@brief Calculates the number of elements in a static array of arbitrary type.
- */
-#define ACOUNT(ARRAY) \
-	(sizeof(ARRAY)/sizeof(ARRAY[0]))
-
-/**@brief Analyses the number of arguments passed to a variadic macro.
- * 
- * This includes the possibility that the first and only argument is empty,
- * which returns 0.
- * 
- * @param ...  variadic list of arguments
- * @sa NUM_PARGS
- */
-#define NUM_ARGS(...)  \
-	IF_EMPTY(__VA_ARGS__)(0)(NUM_PARGS(__VA_ARGS__))
-
-/**@brief Analyses the number of arguments passed to a variadic macro.
- * 
- * The only difference between this macro and NUM_ARGS is the result if the
- * first and only argument is empty. This macro will return 1 in this case,
- * since the empty string is a valid preprocessor argument. If you can ensure
- * or don't care if the first argument is empty, this macro is faster to
- * compute than the NUM_ARGS equivalent.
- * 
- * @param ...  variadic list of arguments
- * @sa NUM_ARGS
- */
-#define NUM_PARGS(...) \
-	NUM_ARGS_(__VA_ARGS__,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17, \
-	          16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1,~)
-
-/**@brief Returns if the variadic list of arguments contains a comma. 
- * 
- * A variadic list contains a comma iff it contains at least two arguments.
- * 
- * @param ...  variadic list of arguments
- * @return 1 if the list contains a comma, \n
- *         0 otherwise
- */
-#define HAS_COMMA(...) \
-	NUM_ARGS_(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
-	           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,~)
-
-/**@brief Applies a macro transformation on each of the macro arguments.
- * @note Using this macro directly is kind of complicated. If you just want to
- * apply a simple macro to each of the arguments, using TRAFO is easier.
- * 
- * @param OUTER  unary macro function that is applied to each argument, except
- *               for the last one, and after the INNER macro has been applied
- * @param INNER  unary macro function that is applied to each argument,
- *               including the last one, and before the OUTER macro is applied
- * @param LIST   the macro arguments, wrapped into parenthesis
- * @sa MAP, FOREACHP
- */
-#define FOREACH(OUTER, INNER, LIST) \
-	FOREACH_(OUTER, NUM_ARGS LIST, INNER, LIST)
-
-/**@brief Applies a macro transformation on each of the macro arguments and
- * takes an additional static argument.
- * 
- * It works exactly like the FOREACH-macro but allows passing an addition data
- * argument.
- * @sa FOLD, FOREACH
- */
-#define FOREACHP(OUTER, INNER, PARAM, LIST) \
-	FOREACHP_(OUTER, NUM_ARGS LIST, INNER, PARAM, LIST)
-
-/**@brief Returns whether the variadic list of macro arguments only contains
- * the empty parameter or not.
- * 
- * @param ...  variadic argument list
- * @return 1 if there is only one argument and it is empty,\n
- *         0 otherwise
- */
-#define IS_EMPTY(...) _IS_EMPTY(                                        \
-	/* test if there is just one argument, possibly an empty one */     \
-	HAS_COMMA(__VA_ARGS__),                                             \
-	/* test if _IS_EMPTY_FN together with the argument adds a comma */  \
-	HAS_COMMA(_IS_EMPTY_FN __VA_ARGS__),                                \
-	/* test if the argument together with a parenthesis adds a comma */ \
-	HAS_COMMA(__VA_ARGS__ (/*empty*/)),                                 \
-	/* test if placing it between _IS_EMPTY_FN and the parenthesis      \
-	 * adds a comma */                                                  \
-	HAS_COMMA(_IS_EMPTY_FN __VA_ARGS__ (/*empty*/))                     \
-)
-
-/**@name Expansion specifier
- * Contains unary macros that perform common transformations on a macro
- * argument.
- * @{
- */
-
-/**@brief Simply expands the macro arguments.
- * 
- * Use it to unpack argument lists like:
- * @code
- * 	#define ARGS (1, 2, 3, 4, 5)
- * 	CALL_VAR_FN(EXPAND ARGS); // expands to CALL_VAR_FN(1, 2, 3, 4, 5)
- * @endcode
- */
-#define EXPAND(...) \
-	__VA_ARGS__
-
-/**@brief Prevents a function-like macro from expanding immediately.
- * 
- * Use it to prevent macros from expanding immediately:
- * @code
- * 	#define FOO() foo
- * 	DEFER(FOO)()         // DEFER(FOO)() -> FOO()
- * 	EXPAND(DEFER(FOO)()) // EXPAND(DEFER(FOO)()) -> EXPAND(FOO()) -> foo
- * @endcode
- */
-#define DEFER(...) \
-	__VA_ARGS__ FORGET()
-
-/**@brief Expands the macro arguments and adds a comma to them.
- */
-#define EXPAND_W_COMMA(...) \
-	__VA_ARGS__,
-
-/**@brief Expands two macro arguments as a pair.
- */
-#define EXPAND_AS_PAIR(E1, E2) \
-	(E1, E2)
-
-/**@brief Replaces the macro arguments with the empty argument.
- */
-#define FORGET(...)
-
-/**@brief Stringifies the arguments.
- */
-#define STR(...) \
-	STR_(__VA_ARGS__)
-
-/**@brief Generates a unique name using the current line in the code.
- * This is useful for variable names in macro-expansions.
- */
-#define UID(VAR) \
-	CONCAT(VAR, _, __LINE__)
-
-/**@}*/
-
-/**@brief Constructs a comma separated list that can be transformed using a 
- * unary macro.
- * 
- * @param M    the unary macro function that is applied for each argument
- * @param ...  variadic argument list
- */
-#define VECM(M,...) \
-	FOREACH(EXPAND_W_COMMA, M, (__VA_ARGS__))
-
-/**@brief Construct a comma separated list that can be transformed using a
- * unary macro and takes an additional static argument.
- * 
- * This macro behaves exactly like VECM but allows for an additional argument.
- */
-#define VECMP(M,P, ...) \
-	FOREACHP(EXPAND_W_COMMA, M, P, (__VA_ARGS__))
-
-/**@brief Applies the unary macro to each element of a variadic argument list.
- * 
- * This is the less powerful version of the FOREACH macro. It simply applies a
- * unary macro to each of its arguments.
- * 
- * @param M    the macro function to apply
- * @param ...  variadic argument list 
- * @sa FOLD, FOREACH
- */
-#define MAP(M, ...) \
-	FOREACH(EXPAND, M, (__VA_ARGS__))
-
-/**@brief Applies a binary macro for each element of a variadic argument list.
- * 
- * The macro receives both a static argument as well as the current element.
- * The static argument is given as the \p P parameter during invokation.
- * @sa MAP, FOREACHP
- */
-#define FOLD(M,P, ...) \
-	FOREACHP(EXPAND, M, P, (__VA_ARGS__))
-
-/**@brief Splices together two variadic sequences into a sequence of pairs.
- * 
- * The number of elements in the combined sequence is always equal to the
- * number of elements in the first sequence. If the first sequence contains
- * more elements, the final sequence's tail has empty second arguments.
- * @sa ZIP_MAP
-*/
-#define ZIP(SEQ_A, SEQ_B) \
-	ZIP_MAP(EXPAND_AS_PAIR, SEQ_A, SEQ_B)
-
-/**@brief Splices together two variadic sequences using a binary macro.
- * 
- * Like the ZIP-macro, the number of combined elements is always equal to the
- * number of elements in the first sequence. This operator is slightly more
- * generic since it allows arbitrary operations on every pair of elements
- * through the binary macro.
- * @sa ZIP
- */
-#define ZIP_MAP(M, SEQ_A, SEQ_B) \
-	CONCAT(ZIP_, NUM_ARGS SEQ_A)(M, SEQ_A, SEQ_B)
-
-/**@brief Selects an argument from a variadic list.
- * 
- * This macro function can be used to index into a variadic argument list. It
- * is possible to select a higher index than the list is long. In this case the
- * result is the empty argument.
- * 
- * @param N    index of the argument to select
- * @param ...  variadic argument list
- */
-#define ARG(N, ...) \
-	CONCAT_2(ARG_,N)(__VA_ARGS__,)
-
-/**@brief Selects and returns the first argument from a variadic list.
- */
-#define ARG_FIRST(...) \
-	ARG_1_(__VA_ARGS__,)
-
-/**@brief Selects and returns the last argument from a variadic list.
- */
-#define ARG_LAST(...) \
-	ARG(NUM_PARGS(__VA_ARGS__),__VA_ARGS__)
-
-/**@brief Selects the remainder of an argument list after removing the first.
- */
-#define ARG_REST(...) \
-	IF_COMMA(__VA_ARGS__)(ARG_REST_(__VA_ARGS__))()
-
-/**@brief Selects every argument except for the last of a variadic list.
- */
-#define ARG_CHOP(...) \
-	FOREACH_(EXPAND_W_COMMA, NUM_ARGS(ARG_REST(__VA_ARGS__)), EXPAND, (__VA_ARGS__))
-
-/**@brief Concatenates a variable number of arguments.
- * 
- * Since it is not specified by the C standard: concatenation occurs from left
- * to right with left associativity. To give an example `CONCAT(a,b,c)` would
- * be treated as `(a ## b) ## c`.
- * 
- * @param ...  variadic list of valid preprocessor tokens
- */
-#define CONCAT(...) \
-	CONCAT_(NUM_PARGS(__VA_ARGS__), __VA_ARGS__)
-
-/**@name Inline conditionals
- * Macros that support the conditional generation of text.
- * @{
- */
-
-/**@brief Tests if two numbers are equal and generates code according to the
- * result.
- * 
- * The numbers are expanded first. The syntax for this tool is like
- * @code
- * IF_EQ(a,b)(<true>)(<false>)
- * @endcode
- * The code in the first branch is generated if `a` equals `b`, the code in the
- * second branch otherwise.
- * 
- * @param A  first number
- * @param B  second number
- */
-#define IF_EQ(A, B) \
-	_IF_CLAUSE(CONCAT_4(_IS_,A,_EQ_,B)())
-
-/**@brief Tests if the number of arguments is equal to a number and generates
- * code according to the result.
- * 
- * The numbers are expanded first. The syntax for this tool is like
- * @code
- * IF_LEN(a,__VA_ARGS__)(<true>)(<false>)
- * @endcode
- * The code in the first branch is generated if `a` equals the length of
- * `__VA_ARGS__`, the code in the second branch otherwise.
- * 
- * @param A    first number
- * @param ...  argument list
- */
-#define IF_LEN(A, ...) \
-	_IF_CLAUSE(CONCAT_4(_IS_,A,_EQ_,NUM_ARGS(__VA_ARGS__)()))
-
-/**@brief Tests if the argument list passed is empty and generates code
- * according to the result.
- * 
- * The argument list is empty iff it only contains one argument that is the
- * empty token. Use this function like this:
- * @code
- * IF_EMPTY(<arglist>)(<empty>)(<not empty>)
- * @endcode
- * The branch labeled with `<empty>` gets generated if the passed `<arglist>`
- * is indeed empty, the other branch if it isn't.
- * 
- * @param ...  variadic argument list
- * @sa IS_EMPTY
- */
-#define IF_EMPTY(...) \
-	IF_EQ(1, IS_EMPTY(__VA_ARGS__))
-
-/**@brief Tests if the argument list contains a comma and generates code
- * according to the result.
- * 
- * If the argument list contains a comma, it must contain at least two
- * arguments. Use this tool like:
- * @code
- * IF_COMMA(<arglist>)(<comma>)(<no comma>)
- * @endcode
- * The result is the branch labeled with `<comma>` if the `<arglist>`
- * contains at least two arguments, otherwise the contents of the other branch
- * are produced.
- * 
- * @param ...  variadic argument list
- * @sa HAS_COMMA
- */
-#define IF_COMMA(...) \
-	IF_EQ(1, HAS_COMMA(__VA_ARGS__))
-
-/**@}*/
-
-/**@cond Internal */
-#define NUM_ARGS_(_20,_1F,_1E,_1D,_1C,_1B,_1A,_19,_18,_17,_16,_15,_14,_13,_12,_11, \
-                  _10, _F, _E, _D, _C, _B, _A, _9, _8, _7, _6, _5, _4, _3, _2, _1, N,...) N
-
-#define FOREACH_(E,N,M, LIST)     FOREACH__(E,N,M,LIST)
-#define FOREACH__(E,N,M, LIST)    FOREACH_N##N(E,M,LIST)
-
-#define FOREACHP_(E,N,M,P, LIST)  FOREACHP__(E,N,M,P,LIST)
-#define FOREACHP__(E,N,M,P, LIST) FOREACH_P##N(E,M,P,LIST)
-
-#define FOREACH_P0(E,M,P, LIST)  /* empty */
-#define FOREACH_P1(E,M,P, LIST)  M(P,ARG_1 LIST)
-#define FOREACH_P2(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P1(E,M,P, (ARG_REST LIST))
-#define FOREACH_P3(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P2(E,M,P, (ARG_REST LIST))
-#define FOREACH_P4(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P3(E,M,P, (ARG_REST LIST))
-#define FOREACH_P5(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P4(E,M,P, (ARG_REST LIST))
-#define FOREACH_P6(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P5(E,M,P, (ARG_REST LIST))
-#define FOREACH_P7(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P6(E,M,P, (ARG_REST LIST))
-#define FOREACH_P8(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P7(E,M,P, (ARG_REST LIST))
-#define FOREACH_P9(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P8(E,M,P, (ARG_REST LIST))
-#define FOREACH_P10(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P9(E,M,P, (ARG_REST LIST))
-#define FOREACH_P11(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P10(E,M,P, (ARG_REST LIST))
-#define FOREACH_P12(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P11(E,M,P, (ARG_REST LIST))
-#define FOREACH_P13(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P12(E,M,P, (ARG_REST LIST))
-#define FOREACH_P14(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P13(E,M,P, (ARG_REST LIST))
-#define FOREACH_P15(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P14(E,M,P, (ARG_REST LIST))
-#define FOREACH_P16(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P15(E,M,P, (ARG_REST LIST))
-#define FOREACH_P17(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P16(E,M,P, (ARG_REST LIST))
-#define FOREACH_P18(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P17(E,M,P, (ARG_REST LIST))
-#define FOREACH_P19(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P18(E,M,P, (ARG_REST LIST))
-#define FOREACH_P20(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P19(E,M,P, (ARG_REST LIST))
-#define FOREACH_P21(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P20(E,M,P, (ARG_REST LIST))
-#define FOREACH_P22(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P21(E,M,P, (ARG_REST LIST))
-#define FOREACH_P23(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P22(E,M,P, (ARG_REST LIST))
-#define FOREACH_P24(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P23(E,M,P, (ARG_REST LIST))
-#define FOREACH_P25(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P24(E,M,P, (ARG_REST LIST))
-#define FOREACH_P26(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P25(E,M,P, (ARG_REST LIST))
-#define FOREACH_P27(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P26(E,M,P, (ARG_REST LIST))
-#define FOREACH_P28(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P27(E,M,P, (ARG_REST LIST))
-#define FOREACH_P29(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P28(E,M,P, (ARG_REST LIST))
-#define FOREACH_P30(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P29(E,M,P, (ARG_REST LIST))
-#define FOREACH_P31(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P30(E,M,P, (ARG_REST LIST))
-#define FOREACH_P32(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P31(E,M,P, (ARG_REST LIST))
-
-#define FOREACH_N0(E,M, LIST)  /* empty */
-#define FOREACH_N1(E,M, LIST)  M(ARG_1 LIST)
-#define FOREACH_N2(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N1(E,M, (ARG_REST LIST))
-#define FOREACH_N3(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N2(E,M, (ARG_REST LIST))
-#define FOREACH_N4(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N3(E,M, (ARG_REST LIST))
-#define FOREACH_N5(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N4(E,M, (ARG_REST LIST))
-#define FOREACH_N6(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N5(E,M, (ARG_REST LIST))
-#define FOREACH_N7(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N6(E,M, (ARG_REST LIST))
-#define FOREACH_N8(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N7(E,M, (ARG_REST LIST))
-#define FOREACH_N9(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N8(E,M, (ARG_REST LIST))
-#define FOREACH_N10(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N9(E,M, (ARG_REST LIST))
-#define FOREACH_N11(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N10(E,M, (ARG_REST LIST))
-#define FOREACH_N12(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N11(E,M, (ARG_REST LIST))
-#define FOREACH_N13(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N12(E,M, (ARG_REST LIST))
-#define FOREACH_N14(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N13(E,M, (ARG_REST LIST))
-#define FOREACH_N15(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N14(E,M, (ARG_REST LIST))
-#define FOREACH_N16(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N15(E,M, (ARG_REST LIST))
-#define FOREACH_N17(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N16(E,M, (ARG_REST LIST))
-#define FOREACH_N18(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N17(E,M, (ARG_REST LIST))
-#define FOREACH_N19(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N18(E,M, (ARG_REST LIST))
-#define FOREACH_N20(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N19(E,M, (ARG_REST LIST))
-#define FOREACH_N21(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N20(E,M, (ARG_REST LIST))
-#define FOREACH_N22(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N21(E,M, (ARG_REST LIST))
-#define FOREACH_N23(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N22(E,M, (ARG_REST LIST))
-#define FOREACH_N24(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N23(E,M, (ARG_REST LIST))
-#define FOREACH_N25(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N24(E,M, (ARG_REST LIST))
-#define FOREACH_N26(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N25(E,M, (ARG_REST LIST))
-#define FOREACH_N27(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N26(E,M, (ARG_REST LIST))
-#define FOREACH_N28(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N27(E,M, (ARG_REST LIST))
-#define FOREACH_N29(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N28(E,M, (ARG_REST LIST))
-#define FOREACH_N30(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N29(E,M, (ARG_REST LIST))
-#define FOREACH_N31(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N30(E,M, (ARG_REST LIST))
-#define FOREACH_N32(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N31(E,M, (ARG_REST LIST))
-
-#define ZIP_0(M, SEQ_A, SEQ_B) /* empty */
-#define ZIP_1(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B)
-#define ZIP_2(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_1(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_3(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_2(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_4(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_3(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_5(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_4(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_6(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_5(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_7(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_6(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_8(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_7(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_9(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_8(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_10(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_9(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_11(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_10(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_12(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_11(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_13(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_12(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_14(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_13(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_15(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_14(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_16(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_15(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_17(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_16(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_18(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_17(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_19(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_18(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_20(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_19(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_21(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_20(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_22(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_21(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_23(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_22(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_24(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_23(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_25(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_24(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_26(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_25(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_27(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_26(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_28(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_27(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_29(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_28(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_30(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_29(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_31(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_30(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-#define ZIP_32(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_31(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
-
-#define CONCAT_(C, ...)   CONCAT__(C,__VA_ARGS__)
-#define CONCAT__(C, ...)  CONCAT_ ## C(__VA_ARGS__)
-
-#define CONCAT_1(_1)           _1
-#define CONCAT_2(_1,_2)        _1 ## _2
-#define CONCAT_3(_1,_2,...)    CONCAT_2(_1 ## _2, __VA_ARGS__)
-#define CONCAT_4(_1,_2,...)    CONCAT_3(_1 ## _2, __VA_ARGS__)
-#define CONCAT_5(_1,_2,...)    CONCAT_4(_1 ## _2, __VA_ARGS__)
-#define CONCAT_6(_1,_2,...)    CONCAT_5(_1 ## _2, __VA_ARGS__)
-#define CONCAT_7(_1,_2,...)    CONCAT_6(_1 ## _2, __VA_ARGS__)
-#define CONCAT_8(_1,_2,...)    CONCAT_7(_1 ## _2, __VA_ARGS__)
-#define CONCAT_9(_1,_2,...)    CONCAT_8(_1 ## _2, __VA_ARGS__)
-#define CONCAT_10(_1,_2,...)   CONCAT_9(_1 ## _2, __VA_ARGS__)
-#define CONCAT_11(_1,_2,...)   CONCAT_10(_1 ## _2, __VA_ARGS__)
-#define CONCAT_12(_1,_2,...)   CONCAT_11(_1 ## _2, __VA_ARGS__)
-#define CONCAT_13(_1,_2,...)   CONCAT_12(_1 ## _2, __VA_ARGS__)
-#define CONCAT_14(_1,_2,...)   CONCAT_13(_1 ## _2, __VA_ARGS__)
-#define CONCAT_15(_1,_2,...)   CONCAT_14(_1 ## _2, __VA_ARGS__)
-#define CONCAT_16(_1,_2,...)   CONCAT_15(_1 ## _2, __VA_ARGS__)
-#define CONCAT_17(_1,_2,...)   CONCAT_16(_1 ## _2, __VA_ARGS__)
-#define CONCAT_18(_1,_2,...)   CONCAT_17(_1 ## _2, __VA_ARGS__)
-#define CONCAT_19(_1,_2,...)   CONCAT_18(_1 ## _2, __VA_ARGS__)
-#define CONCAT_20(_1,_2,...)   CONCAT_19(_1 ## _2, __VA_ARGS__)
-#define CONCAT_21(_1,_2,...)   CONCAT_20(_1 ## _2, __VA_ARGS__)
-#define CONCAT_22(_1,_2,...)   CONCAT_21(_1 ## _2, __VA_ARGS__)
-#define CONCAT_23(_1,_2,...)   CONCAT_22(_1 ## _2, __VA_ARGS__)
-#define CONCAT_24(_1,_2,...)   CONCAT_23(_1 ## _2, __VA_ARGS__)
-#define CONCAT_25(_1,_2,...)   CONCAT_24(_1 ## _2, __VA_ARGS__)
-#define CONCAT_26(_1,_2,...)   CONCAT_25(_1 ## _2, __VA_ARGS__)
-#define CONCAT_27(_1,_2,...)   CONCAT_26(_1 ## _2, __VA_ARGS__)
-#define CONCAT_28(_1,_2,...)   CONCAT_27(_1 ## _2, __VA_ARGS__)
-#define CONCAT_29(_1,_2,...)   CONCAT_28(_1 ## _2, __VA_ARGS__)
-#define CONCAT_30(_1,_2,...)   CONCAT_29(_1 ## _2, __VA_ARGS__)
-#define CONCAT_31(_1,_2,...)   CONCAT_30(_1 ## _2, __VA_ARGS__)
-#define CONCAT_32(_1,_2,...)   CONCAT_31(_1 ## _2, __VA_ARGS__)
-
-#define ARG_REST_(_1, ...) \
-	__VA_ARGS__
-
-#define ARG_(...)            /* empty */
-#define ARG_0(...)           /* empty */
-#define ARG_1_(_1, ...)      _1
-#define ARG_1(...)           ARG_1_(__VA_ARGS__,)
-#define ARG_2(...)           ARG_1(ARG_REST_(__VA_ARGS__,))
-#define ARG_3(...)           ARG_2(ARG_REST_(__VA_ARGS__,))
-#define ARG_4(...)           ARG_3(ARG_REST_(__VA_ARGS__,))
-#define ARG_5(...)           ARG_4(ARG_REST_(__VA_ARGS__,))
-#define ARG_6(...)           ARG_5(ARG_REST_(__VA_ARGS__,))
-#define ARG_7(...)           ARG_6(ARG_REST_(__VA_ARGS__,))
-#define ARG_8(...)           ARG_7(ARG_REST_(__VA_ARGS__,))
-#define ARG_9(...)           ARG_8(ARG_REST_(__VA_ARGS__,))
-#define ARG_10(...)          ARG_9(ARG_REST_(__VA_ARGS__,))
-#define ARG_11(...)          ARG_10(ARG_REST_(__VA_ARGS__,))
-#define ARG_12(...)          ARG_11(ARG_REST_(__VA_ARGS__,))
-#define ARG_13(...)          ARG_12(ARG_REST_(__VA_ARGS__,))
-#define ARG_14(...)          ARG_13(ARG_REST_(__VA_ARGS__,))
-#define ARG_15(...)          ARG_14(ARG_REST_(__VA_ARGS__,))
-#define ARG_16(...)          ARG_15(ARG_REST_(__VA_ARGS__,))
-#define ARG_17(...)          ARG_16(ARG_REST_(__VA_ARGS__,))
-#define ARG_18(...)          ARG_17(ARG_REST_(__VA_ARGS__,))
-#define ARG_19(...)          ARG_18(ARG_REST_(__VA_ARGS__,))
-#define ARG_20(...)          ARG_19(ARG_REST_(__VA_ARGS__,))
-#define ARG_21(...)          ARG_20(ARG_REST_(__VA_ARGS__,))
-#define ARG_22(...)          ARG_21(ARG_REST_(__VA_ARGS__,))
-#define ARG_23(...)          ARG_22(ARG_REST_(__VA_ARGS__,))
-#define ARG_24(...)          ARG_23(ARG_REST_(__VA_ARGS__,))
-#define ARG_25(...)          ARG_24(ARG_REST_(__VA_ARGS__,))
-#define ARG_26(...)          ARG_25(ARG_REST_(__VA_ARGS__,))
-#define ARG_27(...)          ARG_26(ARG_REST_(__VA_ARGS__,))
-#define ARG_28(...)          ARG_27(ARG_REST_(__VA_ARGS__,))
-#define ARG_29(...)          ARG_28(ARG_REST_(__VA_ARGS__,))
-#define ARG_30(...)          ARG_29(ARG_REST_(__VA_ARGS__,))
-#define ARG_31(...)          ARG_30(ARG_REST_(__VA_ARGS__,))
-#define ARG_32(...)          ARG_31(ARG_REST_(__VA_ARGS__,))
-
-#define _CLAUSE1(...) __VA_ARGS__ FORGET
-#define _CLAUSE2(...) EXPAND
-
-#define __IF_CLAUSE(A,B,C,...) C
-#define _IF_CLAUSE(EXP) __IF_CLAUSE(EXP, _CLAUSE1, _CLAUSE2,)
-
-#define _IS_0_EQ_0    ,
-#define _IS_1_EQ_1    ,
-#define _IS_2_EQ_2    ,
-#define _IS_3_EQ_3    ,
-#define _IS_4_EQ_4    ,
-#define _IS_5_EQ_5    ,
-#define _IS_6_EQ_6    ,
-#define _IS_7_EQ_7    ,
-#define _IS_8_EQ_8    ,
-#define _IS_9_EQ_9    ,
-#define _IS_10_EQ_10  ,
-#define _IS_11_EQ_11  ,
-#define _IS_12_EQ_12  ,
-#define _IS_13_EQ_13  ,
-#define _IS_14_EQ_14  ,
-#define _IS_15_EQ_15  ,
-#define _IS_16_EQ_16  ,
-#define _IS_17_EQ_17  ,
-#define _IS_18_EQ_18  ,
-#define _IS_19_EQ_19  ,
-#define _IS_20_EQ_20  ,
-#define _IS_21_EQ_21  ,
-#define _IS_22_EQ_22  ,
-#define _IS_23_EQ_23  ,
-#define _IS_24_EQ_24  ,
-#define _IS_25_EQ_25  ,
-#define _IS_26_EQ_26  ,
-#define _IS_27_EQ_27  ,
-#define _IS_28_EQ_28  ,
-#define _IS_29_EQ_29  ,
-#define _IS_30_EQ_30  ,
-#define _IS_31_EQ_31  ,
-#define _IS_32_EQ_32  ,
-
-#define STR_(...)   #__VA_ARGS__
-
-/* detect empty arguments */
-#define _IS_EMPTY(_0, _1, _2, _3) \
-	HAS_COMMA(CONCAT_5(_IS_EMPTY_CASE_, _0, _1, _2, _3))
-#define _IS_EMPTY_CASE_0001 ,
-#define _IS_EMPTY_FN(...) ,
-
-/**@endcond*/
-
-#endif	/* PPMLIB_H_INCLUDED */
diff --git a/04_exercise/ppmlib/ppmlib.h b/04_exercise/ppmlib/ppmlib.h
new file mode 100644
index 0000000..7a7f3db
--- /dev/null
+++ b/04_exercise/ppmlib/ppmlib.h
@@ -0,0 +1,592 @@
+/***************************************************************************//**
+ * @file ppmlib.h
+ * @author Dorian Weber
+ * @brief Contains a small macro library used for preprocessor programming.
+ * 
+ * @details
+ * Preprocessor metaprogramming is very valuable in larger C projects. It's
+ * efficient and can manipulate code at a very basic level. This small library
+ * is intended to facilitate macro programming by collecting commonly used
+ * macro functions. It supports argument lists with a size of up to 32.
+ ******************************************************************************/
+
+#ifndef PPMLIB_H_INCLUDED
+#define PPMLIB_H_INCLUDED
+
+#include <stddef.h>
+
+/**@brief Tests if the integer type of a variable is signed.
+ * @attention Due to the integer promotion rules in C, this will only work for
+ * variables of type \c int and upwards, not for char and short.
+ * @note Credit goes to Jens Gustedt for this typeless type cast for integer.
+ */
+#define IS_SIGNED(VAR) \
+	((1 ? -1 : VAR) < 0)
+
+/**@brief Number of bits in inttype_MAX, or in any (1<<k)-1 where 0 <= k < 2040.
+ * @note Credit goes to Hallvard B. Furuseth for inventing this gem.
+ * 
+ * Use it like:
+ * @code
+ * 	printf("%u", PRECISION(-1u)); // prints 32 if `unsigned int` uses 32-bits
+ * @endcode
+ */
+#define PRECISION(MAX) \
+	((MAX)/((MAX)%255 + 1)/255%255*8 + 7 - 86/((MAX)%255 + 12))
+
+/**@brief Calculates the number of elements in a static array of arbitrary type.
+ */
+#define ACOUNT(ARRAY) \
+	(sizeof(ARRAY)/sizeof(ARRAY[0]))
+
+/**@brief Analyses the number of arguments passed to a variadic macro.
+ * 
+ * This includes the possibility that the first and only argument is empty,
+ * which returns 0.
+ * 
+ * @param ...  variadic list of arguments
+ * @sa NUM_PARGS
+ */
+#define NUM_ARGS(...)  \
+	IF_EMPTY(__VA_ARGS__)(0)(NUM_PARGS(__VA_ARGS__))
+
+/**@brief Analyses the number of arguments passed to a variadic macro.
+ * 
+ * The only difference between this macro and NUM_ARGS is the result if the
+ * first and only argument is empty. This macro will return 1 in this case,
+ * since the empty string is a valid preprocessor argument. If you can ensure
+ * or don't care if the first argument is empty, this macro is faster to
+ * compute than the NUM_ARGS equivalent.
+ * 
+ * @param ...  variadic list of arguments
+ * @sa NUM_ARGS
+ */
+#define NUM_PARGS(...) \
+	NUM_ARGS_(__VA_ARGS__,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17, \
+	          16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1,~)
+
+/**@brief Returns if the variadic list of arguments contains a comma. 
+ * 
+ * A variadic list contains a comma iff it contains at least two arguments.
+ * 
+ * @param ...  variadic list of arguments
+ * @return 1 if the list contains a comma, \n
+ *         0 otherwise
+ */
+#define HAS_COMMA(...) \
+	NUM_ARGS_(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+	           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,~)
+
+/**@brief Applies a macro transformation on each of the macro arguments.
+ * @note Using this macro directly is kind of complicated. If you just want to
+ * apply a simple macro to each of the arguments, using TRAFO is easier.
+ * 
+ * @param OUTER  unary macro function that is applied to each argument, except
+ *               for the last one, and after the INNER macro has been applied
+ * @param INNER  unary macro function that is applied to each argument,
+ *               including the last one, and before the OUTER macro is applied
+ * @param LIST   the macro arguments, wrapped into parenthesis
+ * @sa MAP, FOREACHP
+ */
+#define FOREACH(OUTER, INNER, LIST) \
+	FOREACH_(OUTER, NUM_ARGS LIST, INNER, LIST)
+
+/**@brief Applies a macro transformation on each of the macro arguments and
+ * takes an additional static argument.
+ * 
+ * It works exactly like the FOREACH-macro but allows passing an addition data
+ * argument.
+ * @sa FOLD, FOREACH
+ */
+#define FOREACHP(OUTER, INNER, PARAM, LIST) \
+	FOREACHP_(OUTER, NUM_ARGS LIST, INNER, PARAM, LIST)
+
+/**@brief Returns whether the variadic list of macro arguments only contains
+ * the empty parameter or not.
+ * 
+ * @param ...  variadic argument list
+ * @return 1 if there is only one argument and it is empty,\n
+ *         0 otherwise
+ */
+#define IS_EMPTY(...) _IS_EMPTY(                                        \
+	/* test if there is just one argument, possibly an empty one */     \
+	HAS_COMMA(__VA_ARGS__),                                             \
+	/* test if _IS_EMPTY_FN together with the argument adds a comma */  \
+	HAS_COMMA(_IS_EMPTY_FN __VA_ARGS__),                                \
+	/* test if the argument together with a parenthesis adds a comma */ \
+	HAS_COMMA(__VA_ARGS__ (/*empty*/)),                                 \
+	/* test if placing it between _IS_EMPTY_FN and the parenthesis      \
+	 * adds a comma */                                                  \
+	HAS_COMMA(_IS_EMPTY_FN __VA_ARGS__ (/*empty*/))                     \
+)
+
+/**@name Expansion specifier
+ * Contains unary macros that perform common transformations on a macro
+ * argument.
+ * @{
+ */
+
+/**@brief Simply expands the macro arguments.
+ * 
+ * Use it to unpack argument lists like:
+ * @code
+ * 	#define ARGS (1, 2, 3, 4, 5)
+ * 	CALL_VAR_FN(EXPAND ARGS); // expands to CALL_VAR_FN(1, 2, 3, 4, 5)
+ * @endcode
+ */
+#define EXPAND(...) \
+	__VA_ARGS__
+
+/**@brief Prevents a function-like macro from expanding immediately.
+ * 
+ * Use it to prevent macros from expanding immediately:
+ * @code
+ * 	#define FOO() foo
+ * 	DEFER(FOO)()         // DEFER(FOO)() -> FOO()
+ * 	EXPAND(DEFER(FOO)()) // EXPAND(DEFER(FOO)()) -> EXPAND(FOO()) -> foo
+ * @endcode
+ */
+#define DEFER(...) \
+	__VA_ARGS__ FORGET()
+
+/**@brief Expands the macro arguments and adds a comma to them.
+ */
+#define EXPAND_W_COMMA(...) \
+	__VA_ARGS__,
+
+/**@brief Expands two macro arguments as a pair.
+ */
+#define EXPAND_AS_PAIR(E1, E2) \
+	(E1, E2)
+
+/**@brief Replaces the macro arguments with the empty argument.
+ */
+#define FORGET(...)
+
+/**@brief Stringifies the arguments.
+ */
+#define STR(...) \
+	STR_(__VA_ARGS__)
+
+/**@brief Generates a unique name using the current line in the code.
+ * This is useful for variable names in macro-expansions.
+ */
+#define UID(VAR) \
+	CONCAT(VAR, _, __LINE__)
+
+/**@}*/
+
+/**@brief Constructs a comma separated list that can be transformed using a 
+ * unary macro.
+ * 
+ * @param M    the unary macro function that is applied for each argument
+ * @param ...  variadic argument list
+ */
+#define VECM(M,...) \
+	FOREACH(EXPAND_W_COMMA, M, (__VA_ARGS__))
+
+/**@brief Construct a comma separated list that can be transformed using a
+ * unary macro and takes an additional static argument.
+ * 
+ * This macro behaves exactly like VECM but allows for an additional argument.
+ */
+#define VECMP(M,P, ...) \
+	FOREACHP(EXPAND_W_COMMA, M, P, (__VA_ARGS__))
+
+/**@brief Applies the unary macro to each element of a variadic argument list.
+ * 
+ * This is the less powerful version of the FOREACH macro. It simply applies a
+ * unary macro to each of its arguments.
+ * 
+ * @param M    the macro function to apply
+ * @param ...  variadic argument list 
+ * @sa FOLD, FOREACH
+ */
+#define MAP(M, ...) \
+	FOREACH(EXPAND, M, (__VA_ARGS__))
+
+/**@brief Applies a binary macro for each element of a variadic argument list.
+ * 
+ * The macro receives both a static argument as well as the current element.
+ * The static argument is given as the \p P parameter during invokation.
+ * @sa MAP, FOREACHP
+ */
+#define FOLD(M,P, ...) \
+	FOREACHP(EXPAND, M, P, (__VA_ARGS__))
+
+/**@brief Splices together two variadic sequences into a sequence of pairs.
+ * 
+ * The number of elements in the combined sequence is always equal to the
+ * number of elements in the first sequence. If the first sequence contains
+ * more elements, the final sequence's tail has empty second arguments.
+ * @sa ZIP_MAP
+*/
+#define ZIP(SEQ_A, SEQ_B) \
+	ZIP_MAP(EXPAND_AS_PAIR, SEQ_A, SEQ_B)
+
+/**@brief Splices together two variadic sequences using a binary macro.
+ * 
+ * Like the ZIP-macro, the number of combined elements is always equal to the
+ * number of elements in the first sequence. This operator is slightly more
+ * generic since it allows arbitrary operations on every pair of elements
+ * through the binary macro.
+ * @sa ZIP
+ */
+#define ZIP_MAP(M, SEQ_A, SEQ_B) \
+	CONCAT(ZIP_, NUM_ARGS SEQ_A)(M, SEQ_A, SEQ_B)
+
+/**@brief Selects an argument from a variadic list.
+ * 
+ * This macro function can be used to index into a variadic argument list. It
+ * is possible to select a higher index than the list is long. In this case the
+ * result is the empty argument.
+ * 
+ * @param N    index of the argument to select
+ * @param ...  variadic argument list
+ */
+#define ARG(N, ...) \
+	CONCAT_2(ARG_,N)(__VA_ARGS__,)
+
+/**@brief Selects and returns the first argument from a variadic list.
+ */
+#define ARG_FIRST(...) \
+	ARG_1_(__VA_ARGS__,)
+
+/**@brief Selects and returns the last argument from a variadic list.
+ */
+#define ARG_LAST(...) \
+	ARG(NUM_PARGS(__VA_ARGS__),__VA_ARGS__)
+
+/**@brief Selects the remainder of an argument list after removing the first.
+ */
+#define ARG_REST(...) \
+	IF_COMMA(__VA_ARGS__)(ARG_REST_(__VA_ARGS__))()
+
+/**@brief Selects every argument except for the last of a variadic list.
+ */
+#define ARG_CHOP(...) \
+	FOREACH_(EXPAND_W_COMMA, NUM_ARGS(ARG_REST(__VA_ARGS__)), EXPAND, (__VA_ARGS__))
+
+/**@brief Concatenates a variable number of arguments.
+ * 
+ * Since it is not specified by the C standard: concatenation occurs from left
+ * to right with left associativity. To give an example `CONCAT(a,b,c)` would
+ * be treated as `(a ## b) ## c`.
+ * 
+ * @param ...  variadic list of valid preprocessor tokens
+ */
+#define CONCAT(...) \
+	CONCAT_(NUM_PARGS(__VA_ARGS__), __VA_ARGS__)
+
+/**@name Inline conditionals
+ * Macros that support the conditional generation of text.
+ * @{
+ */
+
+/**@brief Tests if two numbers are equal and generates code according to the
+ * result.
+ * 
+ * The numbers are expanded first. The syntax for this tool is like
+ * @code
+ * IF_EQ(a,b)(<true>)(<false>)
+ * @endcode
+ * The code in the first branch is generated if `a` equals `b`, the code in the
+ * second branch otherwise.
+ * 
+ * @param A  first number
+ * @param B  second number
+ */
+#define IF_EQ(A, B) \
+	_IF_CLAUSE(CONCAT_4(_IS_,A,_EQ_,B)())
+
+/**@brief Tests if the number of arguments is equal to a number and generates
+ * code according to the result.
+ * 
+ * The numbers are expanded first. The syntax for this tool is like
+ * @code
+ * IF_LEN(a,__VA_ARGS__)(<true>)(<false>)
+ * @endcode
+ * The code in the first branch is generated if `a` equals the length of
+ * `__VA_ARGS__`, the code in the second branch otherwise.
+ * 
+ * @param A    first number
+ * @param ...  argument list
+ */
+#define IF_LEN(A, ...) \
+	_IF_CLAUSE(CONCAT_4(_IS_,A,_EQ_,NUM_ARGS(__VA_ARGS__)()))
+
+/**@brief Tests if the argument list passed is empty and generates code
+ * according to the result.
+ * 
+ * The argument list is empty iff it only contains one argument that is the
+ * empty token. Use this function like this:
+ * @code
+ * IF_EMPTY(<arglist>)(<empty>)(<not empty>)
+ * @endcode
+ * The branch labeled with `<empty>` gets generated if the passed `<arglist>`
+ * is indeed empty, the other branch if it isn't.
+ * 
+ * @param ...  variadic argument list
+ * @sa IS_EMPTY
+ */
+#define IF_EMPTY(...) \
+	IF_EQ(1, IS_EMPTY(__VA_ARGS__))
+
+/**@brief Tests if the argument list contains a comma and generates code
+ * according to the result.
+ * 
+ * If the argument list contains a comma, it must contain at least two
+ * arguments. Use this tool like:
+ * @code
+ * IF_COMMA(<arglist>)(<comma>)(<no comma>)
+ * @endcode
+ * The result is the branch labeled with `<comma>` if the `<arglist>`
+ * contains at least two arguments, otherwise the contents of the other branch
+ * are produced.
+ * 
+ * @param ...  variadic argument list
+ * @sa HAS_COMMA
+ */
+#define IF_COMMA(...) \
+	IF_EQ(1, HAS_COMMA(__VA_ARGS__))
+
+/**@}*/
+
+/**@cond Internal */
+#define NUM_ARGS_(_20,_1F,_1E,_1D,_1C,_1B,_1A,_19,_18,_17,_16,_15,_14,_13,_12,_11, \
+                  _10, _F, _E, _D, _C, _B, _A, _9, _8, _7, _6, _5, _4, _3, _2, _1, N,...) N
+
+#define FOREACH_(E,N,M, LIST)     FOREACH__(E,N,M,LIST)
+#define FOREACH__(E,N,M, LIST)    FOREACH_N##N(E,M,LIST)
+
+#define FOREACHP_(E,N,M,P, LIST)  FOREACHP__(E,N,M,P,LIST)
+#define FOREACHP__(E,N,M,P, LIST) FOREACH_P##N(E,M,P,LIST)
+
+#define FOREACH_P0(E,M,P, LIST)  /* empty */
+#define FOREACH_P1(E,M,P, LIST)  M(P,ARG_1 LIST)
+#define FOREACH_P2(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P1(E,M,P, (ARG_REST LIST))
+#define FOREACH_P3(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P2(E,M,P, (ARG_REST LIST))
+#define FOREACH_P4(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P3(E,M,P, (ARG_REST LIST))
+#define FOREACH_P5(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P4(E,M,P, (ARG_REST LIST))
+#define FOREACH_P6(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P5(E,M,P, (ARG_REST LIST))
+#define FOREACH_P7(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P6(E,M,P, (ARG_REST LIST))
+#define FOREACH_P8(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P7(E,M,P, (ARG_REST LIST))
+#define FOREACH_P9(E,M,P, LIST)  E(M(P,ARG_1 LIST)) FOREACH_P8(E,M,P, (ARG_REST LIST))
+#define FOREACH_P10(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P9(E,M,P, (ARG_REST LIST))
+#define FOREACH_P11(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P10(E,M,P, (ARG_REST LIST))
+#define FOREACH_P12(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P11(E,M,P, (ARG_REST LIST))
+#define FOREACH_P13(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P12(E,M,P, (ARG_REST LIST))
+#define FOREACH_P14(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P13(E,M,P, (ARG_REST LIST))
+#define FOREACH_P15(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P14(E,M,P, (ARG_REST LIST))
+#define FOREACH_P16(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P15(E,M,P, (ARG_REST LIST))
+#define FOREACH_P17(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P16(E,M,P, (ARG_REST LIST))
+#define FOREACH_P18(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P17(E,M,P, (ARG_REST LIST))
+#define FOREACH_P19(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P18(E,M,P, (ARG_REST LIST))
+#define FOREACH_P20(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P19(E,M,P, (ARG_REST LIST))
+#define FOREACH_P21(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P20(E,M,P, (ARG_REST LIST))
+#define FOREACH_P22(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P21(E,M,P, (ARG_REST LIST))
+#define FOREACH_P23(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P22(E,M,P, (ARG_REST LIST))
+#define FOREACH_P24(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P23(E,M,P, (ARG_REST LIST))
+#define FOREACH_P25(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P24(E,M,P, (ARG_REST LIST))
+#define FOREACH_P26(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P25(E,M,P, (ARG_REST LIST))
+#define FOREACH_P27(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P26(E,M,P, (ARG_REST LIST))
+#define FOREACH_P28(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P27(E,M,P, (ARG_REST LIST))
+#define FOREACH_P29(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P28(E,M,P, (ARG_REST LIST))
+#define FOREACH_P30(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P29(E,M,P, (ARG_REST LIST))
+#define FOREACH_P31(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P30(E,M,P, (ARG_REST LIST))
+#define FOREACH_P32(E,M,P, LIST) E(M(P,ARG_1 LIST)) FOREACH_P31(E,M,P, (ARG_REST LIST))
+
+#define FOREACH_N0(E,M, LIST)  /* empty */
+#define FOREACH_N1(E,M, LIST)  M(ARG_1 LIST)
+#define FOREACH_N2(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N1(E,M, (ARG_REST LIST))
+#define FOREACH_N3(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N2(E,M, (ARG_REST LIST))
+#define FOREACH_N4(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N3(E,M, (ARG_REST LIST))
+#define FOREACH_N5(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N4(E,M, (ARG_REST LIST))
+#define FOREACH_N6(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N5(E,M, (ARG_REST LIST))
+#define FOREACH_N7(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N6(E,M, (ARG_REST LIST))
+#define FOREACH_N8(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N7(E,M, (ARG_REST LIST))
+#define FOREACH_N9(E,M, LIST)  E(M(ARG_1 LIST)) FOREACH_N8(E,M, (ARG_REST LIST))
+#define FOREACH_N10(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N9(E,M, (ARG_REST LIST))
+#define FOREACH_N11(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N10(E,M, (ARG_REST LIST))
+#define FOREACH_N12(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N11(E,M, (ARG_REST LIST))
+#define FOREACH_N13(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N12(E,M, (ARG_REST LIST))
+#define FOREACH_N14(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N13(E,M, (ARG_REST LIST))
+#define FOREACH_N15(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N14(E,M, (ARG_REST LIST))
+#define FOREACH_N16(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N15(E,M, (ARG_REST LIST))
+#define FOREACH_N17(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N16(E,M, (ARG_REST LIST))
+#define FOREACH_N18(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N17(E,M, (ARG_REST LIST))
+#define FOREACH_N19(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N18(E,M, (ARG_REST LIST))
+#define FOREACH_N20(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N19(E,M, (ARG_REST LIST))
+#define FOREACH_N21(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N20(E,M, (ARG_REST LIST))
+#define FOREACH_N22(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N21(E,M, (ARG_REST LIST))
+#define FOREACH_N23(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N22(E,M, (ARG_REST LIST))
+#define FOREACH_N24(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N23(E,M, (ARG_REST LIST))
+#define FOREACH_N25(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N24(E,M, (ARG_REST LIST))
+#define FOREACH_N26(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N25(E,M, (ARG_REST LIST))
+#define FOREACH_N27(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N26(E,M, (ARG_REST LIST))
+#define FOREACH_N28(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N27(E,M, (ARG_REST LIST))
+#define FOREACH_N29(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N28(E,M, (ARG_REST LIST))
+#define FOREACH_N30(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N29(E,M, (ARG_REST LIST))
+#define FOREACH_N31(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N30(E,M, (ARG_REST LIST))
+#define FOREACH_N32(E,M, LIST) E(M(ARG_1 LIST)) FOREACH_N31(E,M, (ARG_REST LIST))
+
+#define ZIP_0(M, SEQ_A, SEQ_B) /* empty */
+#define ZIP_1(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B)
+#define ZIP_2(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_1(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_3(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_2(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_4(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_3(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_5(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_4(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_6(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_5(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_7(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_6(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_8(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_7(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_9(M, SEQ_A, SEQ_B)  M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_8(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_10(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_9(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_11(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_10(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_12(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_11(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_13(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_12(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_14(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_13(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_15(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_14(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_16(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_15(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_17(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_16(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_18(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_17(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_19(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_18(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_20(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_19(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_21(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_20(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_22(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_21(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_23(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_22(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_24(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_23(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_25(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_24(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_26(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_25(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_27(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_26(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_28(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_27(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_29(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_28(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_30(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_29(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_31(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_30(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+#define ZIP_32(M, SEQ_A, SEQ_B) M(ARG_1 SEQ_A, ARG_1 SEQ_B), ZIP_31(M, (ARG_REST SEQ_A), (ARG_REST SEQ_B))
+
+#define CONCAT_(C, ...)   CONCAT__(C,__VA_ARGS__)
+#define CONCAT__(C, ...)  CONCAT_ ## C(__VA_ARGS__)
+
+#define CONCAT_1(_1)           _1
+#define CONCAT_2(_1,_2)        _1 ## _2
+#define CONCAT_3(_1,_2,...)    CONCAT_2(_1 ## _2, __VA_ARGS__)
+#define CONCAT_4(_1,_2,...)    CONCAT_3(_1 ## _2, __VA_ARGS__)
+#define CONCAT_5(_1,_2,...)    CONCAT_4(_1 ## _2, __VA_ARGS__)
+#define CONCAT_6(_1,_2,...)    CONCAT_5(_1 ## _2, __VA_ARGS__)
+#define CONCAT_7(_1,_2,...)    CONCAT_6(_1 ## _2, __VA_ARGS__)
+#define CONCAT_8(_1,_2,...)    CONCAT_7(_1 ## _2, __VA_ARGS__)
+#define CONCAT_9(_1,_2,...)    CONCAT_8(_1 ## _2, __VA_ARGS__)
+#define CONCAT_10(_1,_2,...)   CONCAT_9(_1 ## _2, __VA_ARGS__)
+#define CONCAT_11(_1,_2,...)   CONCAT_10(_1 ## _2, __VA_ARGS__)
+#define CONCAT_12(_1,_2,...)   CONCAT_11(_1 ## _2, __VA_ARGS__)
+#define CONCAT_13(_1,_2,...)   CONCAT_12(_1 ## _2, __VA_ARGS__)
+#define CONCAT_14(_1,_2,...)   CONCAT_13(_1 ## _2, __VA_ARGS__)
+#define CONCAT_15(_1,_2,...)   CONCAT_14(_1 ## _2, __VA_ARGS__)
+#define CONCAT_16(_1,_2,...)   CONCAT_15(_1 ## _2, __VA_ARGS__)
+#define CONCAT_17(_1,_2,...)   CONCAT_16(_1 ## _2, __VA_ARGS__)
+#define CONCAT_18(_1,_2,...)   CONCAT_17(_1 ## _2, __VA_ARGS__)
+#define CONCAT_19(_1,_2,...)   CONCAT_18(_1 ## _2, __VA_ARGS__)
+#define CONCAT_20(_1,_2,...)   CONCAT_19(_1 ## _2, __VA_ARGS__)
+#define CONCAT_21(_1,_2,...)   CONCAT_20(_1 ## _2, __VA_ARGS__)
+#define CONCAT_22(_1,_2,...)   CONCAT_21(_1 ## _2, __VA_ARGS__)
+#define CONCAT_23(_1,_2,...)   CONCAT_22(_1 ## _2, __VA_ARGS__)
+#define CONCAT_24(_1,_2,...)   CONCAT_23(_1 ## _2, __VA_ARGS__)
+#define CONCAT_25(_1,_2,...)   CONCAT_24(_1 ## _2, __VA_ARGS__)
+#define CONCAT_26(_1,_2,...)   CONCAT_25(_1 ## _2, __VA_ARGS__)
+#define CONCAT_27(_1,_2,...)   CONCAT_26(_1 ## _2, __VA_ARGS__)
+#define CONCAT_28(_1,_2,...)   CONCAT_27(_1 ## _2, __VA_ARGS__)
+#define CONCAT_29(_1,_2,...)   CONCAT_28(_1 ## _2, __VA_ARGS__)
+#define CONCAT_30(_1,_2,...)   CONCAT_29(_1 ## _2, __VA_ARGS__)
+#define CONCAT_31(_1,_2,...)   CONCAT_30(_1 ## _2, __VA_ARGS__)
+#define CONCAT_32(_1,_2,...)   CONCAT_31(_1 ## _2, __VA_ARGS__)
+
+#define ARG_REST_(_1, ...) \
+	__VA_ARGS__
+
+#define ARG_(...)            /* empty */
+#define ARG_0(...)           /* empty */
+#define ARG_1_(_1, ...)      _1
+#define ARG_1(...)           ARG_1_(__VA_ARGS__,)
+#define ARG_2(...)           ARG_1(ARG_REST_(__VA_ARGS__,))
+#define ARG_3(...)           ARG_2(ARG_REST_(__VA_ARGS__,))
+#define ARG_4(...)           ARG_3(ARG_REST_(__VA_ARGS__,))
+#define ARG_5(...)           ARG_4(ARG_REST_(__VA_ARGS__,))
+#define ARG_6(...)           ARG_5(ARG_REST_(__VA_ARGS__,))
+#define ARG_7(...)           ARG_6(ARG_REST_(__VA_ARGS__,))
+#define ARG_8(...)           ARG_7(ARG_REST_(__VA_ARGS__,))
+#define ARG_9(...)           ARG_8(ARG_REST_(__VA_ARGS__,))
+#define ARG_10(...)          ARG_9(ARG_REST_(__VA_ARGS__,))
+#define ARG_11(...)          ARG_10(ARG_REST_(__VA_ARGS__,))
+#define ARG_12(...)          ARG_11(ARG_REST_(__VA_ARGS__,))
+#define ARG_13(...)          ARG_12(ARG_REST_(__VA_ARGS__,))
+#define ARG_14(...)          ARG_13(ARG_REST_(__VA_ARGS__,))
+#define ARG_15(...)          ARG_14(ARG_REST_(__VA_ARGS__,))
+#define ARG_16(...)          ARG_15(ARG_REST_(__VA_ARGS__,))
+#define ARG_17(...)          ARG_16(ARG_REST_(__VA_ARGS__,))
+#define ARG_18(...)          ARG_17(ARG_REST_(__VA_ARGS__,))
+#define ARG_19(...)          ARG_18(ARG_REST_(__VA_ARGS__,))
+#define ARG_20(...)          ARG_19(ARG_REST_(__VA_ARGS__,))
+#define ARG_21(...)          ARG_20(ARG_REST_(__VA_ARGS__,))
+#define ARG_22(...)          ARG_21(ARG_REST_(__VA_ARGS__,))
+#define ARG_23(...)          ARG_22(ARG_REST_(__VA_ARGS__,))
+#define ARG_24(...)          ARG_23(ARG_REST_(__VA_ARGS__,))
+#define ARG_25(...)          ARG_24(ARG_REST_(__VA_ARGS__,))
+#define ARG_26(...)          ARG_25(ARG_REST_(__VA_ARGS__,))
+#define ARG_27(...)          ARG_26(ARG_REST_(__VA_ARGS__,))
+#define ARG_28(...)          ARG_27(ARG_REST_(__VA_ARGS__,))
+#define ARG_29(...)          ARG_28(ARG_REST_(__VA_ARGS__,))
+#define ARG_30(...)          ARG_29(ARG_REST_(__VA_ARGS__,))
+#define ARG_31(...)          ARG_30(ARG_REST_(__VA_ARGS__,))
+#define ARG_32(...)          ARG_31(ARG_REST_(__VA_ARGS__,))
+
+#define _CLAUSE1(...) __VA_ARGS__ FORGET
+#define _CLAUSE2(...) EXPAND
+
+#define __IF_CLAUSE(A,B,C,...) C
+#define _IF_CLAUSE(EXP) __IF_CLAUSE(EXP, _CLAUSE1, _CLAUSE2,)
+
+#define _IS_0_EQ_0    ,
+#define _IS_1_EQ_1    ,
+#define _IS_2_EQ_2    ,
+#define _IS_3_EQ_3    ,
+#define _IS_4_EQ_4    ,
+#define _IS_5_EQ_5    ,
+#define _IS_6_EQ_6    ,
+#define _IS_7_EQ_7    ,
+#define _IS_8_EQ_8    ,
+#define _IS_9_EQ_9    ,
+#define _IS_10_EQ_10  ,
+#define _IS_11_EQ_11  ,
+#define _IS_12_EQ_12  ,
+#define _IS_13_EQ_13  ,
+#define _IS_14_EQ_14  ,
+#define _IS_15_EQ_15  ,
+#define _IS_16_EQ_16  ,
+#define _IS_17_EQ_17  ,
+#define _IS_18_EQ_18  ,
+#define _IS_19_EQ_19  ,
+#define _IS_20_EQ_20  ,
+#define _IS_21_EQ_21  ,
+#define _IS_22_EQ_22  ,
+#define _IS_23_EQ_23  ,
+#define _IS_24_EQ_24  ,
+#define _IS_25_EQ_25  ,
+#define _IS_26_EQ_26  ,
+#define _IS_27_EQ_27  ,
+#define _IS_28_EQ_28  ,
+#define _IS_29_EQ_29  ,
+#define _IS_30_EQ_30  ,
+#define _IS_31_EQ_31  ,
+#define _IS_32_EQ_32  ,
+
+#define STR_(...)   #__VA_ARGS__
+
+/* detect empty arguments */
+#define _IS_EMPTY(_0, _1, _2, _3) \
+	HAS_COMMA(CONCAT_5(_IS_EMPTY_CASE_, _0, _1, _2, _3))
+#define _IS_EMPTY_CASE_0001 ,
+#define _IS_EMPTY_FN(...) ,
+
+/**@endcond*/
+
+#endif	/* PPMLIB_H_INCLUDED */
diff --git a/04_exercise/threadpool.h b/04_exercise/threadpool.h
index f73e36c..745c4dd 100644
--- a/04_exercise/threadpool.h
+++ b/04_exercise/threadpool.h
@@ -3,6 +3,7 @@
 
 #include <stdatomic.h>
 #include <stddef.h>
+#include <ppmlib.h>
 
 /**@brief Funktionszeiger auf eine asynchron auszuführende Funktion.
  *
-- 
cgit v1.2.3-54-g00ecf