cc -std=c99 -E test-file.c |grep -v '^#' > test-file.i
perl -i -e 's/;/;\n/g' test-file.i
cc -std=c99 -c -Wall test-file.i

If there is a warning reported by the compiler in the generated code, then there is definitely an error you should fix (except if it reports shadowed variables), in particular cast evolving pointers.

You should also turn off the macro expansion of the errors reported by your compiler. There are often completely useless and misleading:

• For GCC, uses -ftrack-macro-expansion=0
• For CLANG, uses -fmacro-backtrace-limit=1

Due to the unfortunate weak nature of the C language for pointers, you should turn incompatible pointer type warning into an error in your compiler. For GCC / CLANG, uses -Werror=incompatible-pointer-types

For MS Visual C++ compiler , you need the following options:

/Zc:__cplusplus /Zc:preprocessor /D__STDC_WANT_LIB_EXT1__ /EHsc

Many other implementation of generic container libraries in C exist. For example, a non exhaustive list is:

• BKTHOMPS/CONTAINERS
• BSD tree.h
• CC
• CDSA
• CELLO
• C-Macro-Collections
• COLLECTIONS-C
• CONCURRENCY KIT
• CTL by glouw or by rurban
• GDB internal library
• GLIB
• KLIB
• LIBCHASTE
• LIBCOLLECTION
• LIBDICT
• LIBDYNAMIC
• LIBLFDS
• LIBSRT: Safe Real-Time library for the C programming language
• NEDTRIES
• POTTERY
• QLIBC
• SC
• SGLIB
• Smart pointer for GNUC
• STB stretchy_buffer
• STC - Smart Template Container for C
• TommyDS
• UTHASH

Each can be classified into one of the following concept:

• Each object is handled through a pointer to void (with potential registered callbacks to handle the contained objects for the specialized methods). From a user point of view, this makes the code harder to use (as you don't have any help from the compiler) and type unsafe with a lot of cast (so no formal proof of the code is possible). This also generally generate slower code (even if using link time optimization, this penalty can be reduced). Properly used, it can yet be the most space efficient for the code, but can consume a lot more for the data due to the obligation of using pointers. This is however the easiest to design & code.
• Macros are used to access structures in a generic way (using known fields of a structure — typically size, number, etc.). From a user point of view, this can create subtitle bug in the use of the library (as everything is done through macro expansion in the user defined code) or hard to understand warnings. This can generates fully efficient code. From a library developer point of view, this can be quite limiting in what you can offer.
• Macros detect the type of the argument passed as parameter using _Generics, and calls the associated methods of the switch. The difficulty is how to add pure user types in this generic switch.
• A known structure is put in an intrusive way in the type of all the objects you wan to handle. From a user point of view, he needs to modify its structure and has to perform all the allocation & deallocation code itself (which is good or bad depending on the context). This can generate efficient code (both in speed and size). From a library developer point of view, this is easy to design & code. You need internally a cast to go from a pointer to the known structure to the pointed object (a reverse of offsetof) that is generally type unsafe (except if mixed with the macro generating concept). This is quite limitation in what you can do: you can't move your objects so any container that has to move some objects is out-of-question (which means that you cannot use the most efficient container).
• Header files are included multiple times with different contexts (some different values given to defined macros) in order to generate different code for each type. From a user point of view, this creates a new step before using the container: an instantiating stage that has to be done once per type and per compilation unit (The user is responsible to create only one instance of the container, which can be troublesome if the library doesn't handle proper prefix for its naming convention). The debug of the library is generally easy and can generate fully specialized & efficient code. Incorrectly used, this can generate a lot of code bloat. Properly used, this can even create smaller code than the void pointer variant. The interface used to configure the library can be quite tiresome in case of a lot of specialized methods to configure: it doesn't enable to chain the configuration from a container to another one easily. It also cannot have heavy customization of the code.
• Macros are used to generate context-dependent C code enabling to generate code for different type. This is pretty much like the headers solution but with added flexibility. From a user point of view, this creates a new step before using the container: an instantiating stage that has to be done once per type and per compilation unit (The user is responsible to create only one instance of the container, which can be troublesome if the library doesn't handle proper prefix for its naming convention). This can generate fully specialized & efficient code. Incorrectly used, this can generate a lot of code bloat. Properly used, this can even create smaller code than the void pointer variant. From a library developer point of view, the library is harder to design and to debug: everything being expanded in one line, you can't step in the library (there is however a solution to overcome this limitation by adding another stage to the compilation process). You can however see the generated code by looking at the preprocessed file. You can perform heavy context-dependent customization of the code (transforming the macro preprocessing step into its own language). Properly done, you can also chain the methods from a container to another one easily, enabling expansion of the library. Errors within the macro expansion are generally hard to decipher, but errors in code using containers are easy to read and natural.

M*LIB category is mainly the last one. Some macros are also defined to access structure in a generic way, but they are optional. There are also intrusive containers.

M*LIB main added value compared to other libraries is its oplist feature enabling it to chain the containers and/or use complex types in containers: list of array of dictionary of C++ objects are perfectly supported by M*LIB.

For the macro-preprocessing part, other libraries and reference also exist. For example:

• Boost preprocessor
• C99 Lambda
• C Preprocessor Tricks, Tips and Idioms
• CPP MAGIC
• MAP MACRO
• metalang99
• OrderPP
• P99
• Zlang

You can also consult awesome-c-preprocessor for a more comprehensive list of libraries.

For the string part, there is the following libraries for example:

• POTTERY STRING
• SDS
• STC - C99 Standard Container library
• STR -yet another string library for C language
• The Better String Library with a page that lists a lot of other string libraries.
• VSTR with a page that lists a lot of other string libraries.

The M*LIB reference card is available here.

The generated containers tries to generate and provide a consistent interface: their methods would behave the same for all generated containers. This chapter will explain the generic interface. In case of difference, it will be explained in the specific container.

In the following description:

• name is the prefix used for the container generation,
• name_t refers to the type of the container,
• name_it_t refers to the iterator type of the container,
• type_t refers to the type of the object stored in the container,
• key_type_t refers to the type of the key object used to associate an element to,
• value_type_t refers to the type of the value object used to associate an element to.
• name_itref_t refers to a pair of key and value for associative arrays.

An object shall be initialized (aka constructor) before being used by other methods. It shall be cleared (aka destructor) after being used and before program termination. An iterator has not destructor but shall be set before being used.

A container takes as input the

• name — it is a mandatory argument that is the prefix used to generate all functions and types,
• type — it is a mandatory argument that the basic element of the container,
• oplist — it is an optional argument that defines the methods associated to the type. The provided oplist (if provided) shall be the one that is associated to the type, otherwise it won't generate compilable code. If there is no oplist parameter provided, a globally registered oplist associated to the type is used if possible, or the basic oplist for basic C types is used. This oplist will be used to handle internally the objects of the container.

The type given to any templating macro can be either an integer, a float, a boolean, an enum, a named structure, a named union, a pointer to such types, or a typedef alias of any C type: in fact, the only constraint is that the preprocessing concatenation between type and variable into 'type variable' shall be a valid C expression. Therefore the type cannot be a C array or a function pointer and you shall use a typedef as an intermediary named type for such types.

The output parameters are listed fist, then the input/output parameters and finally the input parameters.

This generic interface is specified as follow:

Initialize the container container (aka constructor) to an empty container. Also called the default constructor of the container.

Initialize the container container (aka constructor) and set it to a copy of ref. This method is only created if the INIT_SET & SET methods are provided. Also called the copy constructor of the container.

Set the container container to the copy of ref. This method is only created if the INIT_SET and SET methods are provided.

Initialize the container container (aka constructor) by stealing as many resources from ref as possible. After-wise ref is cleared and can no longer be used (aka destructor).

Set the container container (aka constructor) by stealing as many resources from ref as possible. After-wise ref is cleared and can no longer be used (aka destructor).

Clear the container container (aka destructor), calling the CLEAR method of all the objects of the container and freeing memory. The object can't be used anymore, except to be reinitialized with a constructor.

Reset the container clearing and freeing all objects stored in it. The container becomes empty but remains initialized.

Return a pointer to the data stored in the back of the container. This pointer should not be stored in a global variable.

Return a pointer to the data stored in the front of the container. This pointer should not be stored in a global variable.

Push a new element in the container container as a copy of the object value. This method is created only if the INIT_SET operator is provided.

The _back suffixed method will push it in the back of the container. The _front suffixed method will push it in the front of the container.

Push a new element in the container container without initializing it and returns a pointer to the non-initialized data. The first thing to do after calling this function shall be to initialize the data using the proper constructor of the object of type type_t. This enables using more specialized constructor than the generic copy one. The user should use other _push function if possible rather than this one as it is low level and error prone. This pointer should not be stored in a global variable.

The _back suffixed method will push it in the back of the container. The _front suffixed method will push it in the front of the container.

Push a new element in the container container and initialize it with the default constructor associated to the type type_t. Return a pointer to the initialized object. This pointer should not be stored in a global variable. This method is only created if the INIT method is provided.

The _back suffixed method will push it in the back of the container. The _front suffixed method will push it in the front of the container.

Push a new element in the container container as a move from the object *value: it will therefore steal as much resources from *value as possible. Afterward *value is cleared and cannot longer be used (aka. destructor).

The _back suffixed method will push it in the back of the container. The _front suffixed method will push it in the front of the container.

Push a new element in the container container by initializing it with the provided arguments. The provided arguments shall therefore match one of the constructor provided by the EMPLACE_TYPE operator. There is one generated method per suffix defined in the EMPLACE_TYPE operator, and the suffix in the generated method name corresponds to the suffix defined in the EMPLACE_TYPE operator (it can be empty). This method is created only if the EMPLACE_TYPE operator is provided. See emplace chapter for more details.

The _back suffixed method will push it in the back of the container. The _front suffixed method will push it in the front of the container.

Pop a element from the container container; and set *data to this value if data is not the NULL pointer, otherwise it only pops the data. This method is created if the SET or INIT_MOVE operator is provided.

The _back suffixed method will pop it from the back of the container. The _front suffixed method will pop it from the front of the container.

Pop a element from the container container and initialize and set *data to this value (aka. constructor) by stealing as much resources from the container as possible. data shall not be a NULL pointer.

The _back suffixed method will pop it from the back of the container. The _front suffixed method will pop it from the front of the container.

Return true if the container is empty, false otherwise.

Swap the container container1 and container2.

Set the element associated to key of the container container to value.

If the container is sequence-like (like array), the key is an integer. The selected element is the key-th element of the container, The index key shall be within the size of the container. This method is created if the INIT_SET operator is provided.

If the container is associative-array like, the selected element is the value object associated to the key object in the container. It is created if it doesn't exist, overwritten otherwise.

Set the element associated to key of the container container to value. key (resp. value) is constructed from the provided args keyargs (resp. valargs) if not provided.

keyargs (resp. valargs) shall therefore match one of the constructor provided by the EMPLACE_TYPE operator of the key (resp. the value).

There is:

• one generated method per suffix defined in the EMPLACE_TYPE operator of the key,
• one generated method per suffix defined in the EMPLACE_TYPE operator of the value,
• one generated method per pair of suffix defined in the EMPLACE_TYPE operators of the key and value,

The suffix in the generated method name corresponds to the suffix defined in in the EMPLACE_TYPE operator (it can be empty). This method is created only if one EMPLACE_TYPE operator is provided. See emplace chapter for more details.

Return a modifiable (resp. constant) pointer to the element associated to key in the container.

If the container is sequence-like, the key is an integer. The selected element is the key-th element of the container, the front being at the index 0, the last at the index (size-1). The index key shall be within the size of the container. Therefore, it will never return NULL in this case.

If the container is associative array like, the selected element is the value object associated to the key object in the container. If the key is not found, it returns NULL.

If the container is set-like, the selected element is the value object which is equal to the key object in the container. If the key is not found, it returns NULL.

This pointer remains valid until the container is modified by another method. This pointer should not be stored in a global variable.

Return a modifiable (resp. constant) pointer to the element associated to the key constructed from args in the container. The selected element is the value object associated to the key object in the container for an associative array, or the element itself for a set. If the key is not found, it returns NULL.

This pointer remains valid until the container is modified by another method. This pointer should not be stored in a global variable.

Return a modifiable pointer to the element associated to key in the container, creating a new element if it doesn't exist (ensuring therefore a safe get operation).

If the container is sequence-like, key_type_t is an alias for size_t and key an integer, the selected element is the key-th element of the container. If the element doesn't exist, the container size will be increased if needed (creating new elements with the INIT operator), which might increase the container to much in some cases.

The returned pointer cannot be NULL. This method is only created if the INIT method is provided. This pointer remains valid until the array is modified by another method. This pointer should not be stored in a global variable.

Remove the element referenced by the key key in the container container. Do nothing if key is no present in the container. Return true if the key was present and erased, false otherwise.

Return the number elements of the container (its size). Return 0 if there is no element.

Return the capacity of the container, i.e. the maximum number of elements supported by the container before a reserve operation is needed to accommodate new elements.

Resize the container container to the size size, increasing or decreasing the size of the container by initializing new elements or clearing existing ones. This method is only created if the INIT method is provided.

Extend or reduce the capacity of the container to a rounded value based on capacity. If the given capacity is below the current size of the container, the capacity is set to a rounded value based on the size of the container. Therefore a capacity of 0 is used to perform a shrink-to-fit operation on the container, i.e. reducing the container usage to the minimum possible allocation.

Set the iterator it to the first element of the container container. There is no destructor associated to this initialization.

Set the iterator it to the iterator ref. There is no destructor associated to this initialization.

Set the iterator it to a non valid element of the container. There is no destructor associated to this initialization.

Return true if the iterator doesn't reference a valid element anymore.

Return true if the iterator references the last element of the container or if the iterator doesn't reference a valid element anymore.

Return true if the iterator it1 references the same element than the iterator it2.

Move the iterator to the next element of the container.

Move the iterator it to the previous element of the container.

Return a modifiable (resp. constant) pointer to the element pointed by the iterator. For associative-array like container, this element is the pair composed of the key (key field) and the associated value (value field); otherwise this element is simply the basic type of the container (type_t).

This pointer should not be stored in a global variable. This pointer remains valid until the container is modified by another method.

Insert the object x after the position referenced by the iterator it in the container container or if the iterator it doesn't reference anymore to a valid element of the container, it is added as the first element of the container. it shall be an iterator of the container container.

Remove the element referenced by the iterator it from the container container. it shall be an iterator of the container container. Afterwards, it references the next element of the container if it exists, or not a valid element otherwise.

Return true if both containers container1 and container2 are considered equal. This method is only created if the EQUAL method is provided.

Return a fast hash value of the container container, suitable to be used by a dictionary. This method is only created if the HASH method is provided.

Set str to the formatted string representation of the container container if append is false or append str with this representation if append is true. This method is only created if the GET_STR method is provided.

Parse the formatted string str, that is assumed to be a string representation of a container, and set container to this representation. It returns true if success, false otherwise. If endp is not NULL, it sets *endp to the pointer of the first character not decoded by the function (or where the parsing fails). This method is only created if the PARSE_STR & INIT methods are provided.

It is ensured that the container gets from parsing a formatted string representation gets from name_get_str and the original container are equal.

Generate a formatted string representation of the container container and outputs it into the file FILE*. The file FILE* shall be opened in write text mode and without error. This method is only created if the OUT_STR methods is provided.

Read from the file FILE* a formatted string representation of a container and set container to this representation. It returns true if success, false otherwise. This method is only created if the IN_STR & INIT methods are provided.

It is ensured that the container gets from parsing a formatted string representation gets from name_out_str and the original container are equal.

Output the container container into the serializing object serial. How and where it is output depends on the serializing object. It returns M_SERIAL_OK_DONE in case of success, or M_SERIAL_FAILURE in case of failure. In case of failure, the serializing object is in an unspecified but valid state. This method is only created if the OUT_SERIAL methods is provided.

Read from the serializing object serial a representation of a container and set container to this representation. It returns M_SERIAL_OK_DONE in case of success, or M_SERIAL_FAILURE in case of failure. In case of failure, the serializing object is in an unspecified but valid state. This method is only created if the IN_SERIAL & INIT methods are provided.

It is ensured that the container gets from parsing a representation gets from name_out_serial and the original container are equal (using the same type of serialization object).

This header is for creating singly linked list.

A linked list is a linear collection of elements, in which each element points to the next, all of then representing a sequence.

A fundamental property of a list is that the objects created within the list will remain at their initialized address, and won't moved due to operations done on the list (except if it is removed). Therefore a returned pointer to an element of the container remains valid until this element is destroyed in the container.

LIST_DEF defines the singly linked list named name_t that contains objects of type type and their associated methods as static inline functions. name shall be a C identifier that will be used to identify the list. It will be used to create all the types (including the iterator) and functions to handle the container. This definition shall be done once per name and per compilation unit.

The oplist shall have at least the following operators (INIT_SET, SET and CLEAR), otherwise it won't generate compilable code.

For this container, the back is always the first element, and the front is the last element: the list grows from the back. Therefore, the iteration of this container using iterator objects will go from the back element to the front element (contrary to an array).

Even if it provides random access functions, theses access are slow and should be avoided: it iterates linearly over all the elements of the container until it reaches the requested element. The size method has the same drawback.

The push/pop methods of the container always operate on the back of the container.

LIST_DEF_AS is the same as LIST_DEF except the name of the types name_t, name_it_t are provided by the user, and not computed from the name prefix.

Example:

#include <stdio.h>
#include <gmp.h>
#include "m-list.h"

#define MPZ_OUT_STR(stream, x) mpz_out_str(stream, 0, x)
LIST_DEF(list_mpz, mpz_t,                                  \
    (INIT(mpz_init), INIT_SET(mpz_init_set), SET(mpz_set), \
        CLEAR(mpz_clear), OUT_STR(MPZ_OUT_STR)))

int main(void) {
  list_mpz_t a;
  list_mpz_init(a);
  mpz_t x;
  mpz_init_set_ui(x, 16);
  list_mpz_push_back (a, x);
  mpz_set_ui(x, 45);             
  list_mpz_push_back (a, x);
  mpz_clear(x);
  printf ("LIST is: ");
  list_mpz_out_str(stdout, a);
  printf ("\n");
  printf ("First element is: ");
  mpz_out_str(stdout, 0, *list_mpz_back(a));
  printf ("\n");
  list_mpz_clear(a);
}

LIST_DEF(list_uint, unsigned int, (MEMPOOL(list_mpool), MEMPOOL_LINKAGE(static)))

static void test_list (size_t n)
{
  list_uint_mempool_init(list_mpool);
  M_LET(a1, LIST_OPLIST(uint)) {
      for(size_t i = 0; i < n; i++)
          list_uint_push_back(a1, rand_get() );
  }
  list_uint_mempool_clear(list_mpool);
}

LIST_DEF(list_int, int)
list_int_t my_list = LIST_INIT_VALUE();

void name_init(name_t list)
void name_init_set(name_t list, const name_t ref)
void name_set(name_t list, const name_t ref)
void name_init_move(name_t list, name_t ref)
void name_move(name_t list, name_t ref)
void name_clear(name_t list)
void name_reset(name_t list)
type *name_back(const name_t list)
void name_push_back(name_t list, const type value)
type *name_push_raw(name_t list)
type *name_push_new(name_t list)
void name_push_move(name_t list, type *value)
void name_emplace_back[suffix](name_t list, args...)
void name_pop_back(type *data, name_t list)
void name_pop_move(type *data, name_t list)
bool name_empty_p(const name_t list)
void name_swap(name_t list1, name_t list2)
void name_it(name_it_t it, const name_t list)
void name_it_set(name_it_t it, const name_it_t ref)
void name_it_end(name_it_t it, const name_t list)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
void name_next(name_it_t it)
type *name_ref(name_it_t it)
const type *name_cref(const name_it_t it)
type *name_get(const name_t list, size_t i)
const type *name_cget(const name_t list, size_t i)
size_t name_size(const name_t list)
void name_insert(name_t list, const name_it_t it, const type x)
void name_remove(name_t list, name_it_t it)
void name_get_str(string_t str, const name_t list, bool append)
bool name_parse_str(name_t list, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t list)
bool name_in_str(name_t list, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t list1, const name_t list2)
size_t name_hash(const name_t list)

#include <stdio.h>
#include <gmp.h>
#include "m-list.h"

#define MPZ_OUT_STR(stream, x) mpz_out_str(stream, 0, x)
LIST_DUAL_PUSH_DEF(list_mpz, mpz_t,                        \
    (INIT(mpz_init), INIT_SET(mpz_init_set), SET(mpz_set), \
        CLEAR(mpz_clear), OUT_STR(MPZ_OUT_STR)))

int main(void) {
  list_mpz_t a;
  list_mpz_init(a);
  mpz_t x;
  mpz_init_set_ui(x, 16);
  list_mpz_push_back (a, x);
  mpz_set_ui(x, 45);             
  list_mpz_push_back (a, x);
  mpz_clear(x);
  printf ("LIST is: ");
  list_mpz_out_str(stdout, a);
  printf ("\n");
  printf ("First element is: ");
  mpz_out_str(stdout, 0, *list_mpz_back(a));
  printf ("\n");
  list_mpz_clear(a);
}

LIST_DUAL_PUSH_DEF(list_int, int)
list_int_t my_list = LIST_DUAL_PUSH_INIT_VALUE();

void name_init(name_t list)
void name_init_set(name_t list, const name_t ref)
void name_set(name_t list, const name_t ref)
void name_init_move(name_t list, name_t ref)
void name_move(name_t list, name_t ref)
void name_clear(name_t list)
void name_reset(name_t list)
type *name_back(const name_t list)
void name_push_back(name_t list, type value)
type *name_push_back_raw(name_t list)
type *name_push_back_new(name_t list)
void name_push_back_move(name_t list, type *value)
void name_emplace_back[suffix](name_t list, args...)
const type *name_front(const name_t list)
void name_push_front(name_t list, type value)
type *name_push_front_raw(name_t list)
type *name_push_front_new(name_t list)
void name_push_front_move(name_t list, type *value)
void name_emplace_front[suffix](name_t list, args...)
void name_pop_back(type *data, name_t list)
void name_pop_move(type *data, name_t list)
bool name_empty_p(const name_t list)
void name_swap(name_t list1, name_t list2)
void name_it(name_it_t it, name_t list)
void name_it_set(name_it_t it, const name_it_t ref)
void name_it_end(name_it_t it, const name_t list)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
void name_next(name_it_t it)
type *name_ref(name_it_t it)
const type *name_cref(const name_it_t it)
size_t name_size(const name_t list)
void name_insert(name_t list, const name_it_t it, const type x)
void name_remove(name_t list, name_it_t it)
void name_get_str(string_t str, const name_t list, bool append)
bool name_parse_str(name_t list, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t list)
bool name_in_str(name_t list, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t list1, const name_t list2)
size_t name_hash(const name_t list)

#include <stdio.h>
#include <gmp.h>
#include "m-array.h"

#define MPZ_OUT_STR(stream, x) mpz_out_str(stream, 0, x)
ARRAY_DEF(array_mpz, mpz_t,                                \
    (INIT(mpz_init), INIT_SET(mpz_init_set), SET(mpz_set), \
        CLEAR(mpz_clear), OUT_STR(MPZ_OUT_STR)))
	
int main(void) {
  array_mpz_t a;
  array_mpz_init(a);
  mpz_t x;
  mpz_init_set_ui(x, 16);
  array_mpz_push_back (a, x);
  mpz_set_ui(x, 45);             
  array_mpz_push_back (a, x);
  mpz_clear(x);
  printf ("ARRAY is: ");
  array_mpz_out_str(stdout, a);
  printf ("\n");
  printf ("First element is: ");
  mpz_out_str(stdout, 0, *array_mpz_get(a, 0));
  printf ("\n");
  array_mpz_clear(a);
}

ARRAY_DEF(array_int_t, int)
array_int_t my_array = ARRAY_INIT_VALUE();

void name_init(name_t array)
void name_init_set(name_t array, const name_t ref)
void name_set(name_t array, const name_t ref)
void name_init_move(name_t array, name_t ref)
void name_move(name_t array, name_t ref)
void name_clear(name_t array)
void name_reset(name_t array)
type *name_push_raw(name_t array)
void name_push_back(name_t array, const type value)
type *name_push_new(name_t array)
void name_push_move(name_t array, type *val)
void name_emplace_back[suffix](name_t array, args...)
void name_pop_back(type *data, name_t array)
void name_pop_move(type *data, name_t array)
type *name_front(const name_t array)
type *name_back(const name_t array)
void name_set_at(name_t array, size_t i, type value)
type *name_get(name_t array, size_t i)
const type *name_cget(const name_t it, size_t i)
type *name_safe_get(name_t array, size_t i)
bool name_empty_p(const name_t array)
size_t name_size(const name_t array)
size_t name_capacity(const name_t array)
void name_resize(name_t array, size_t size)
void name_reserve(name_t array, size_t capacity)
void name_swap(name_t array1, name_t array2)
void name_it(name_it_t it, name_t array)
void name_it_last(name_it_t it, name_t array)
void name_it_end(name_it_t it, name_t array)
void name_it_set(name_it_t it1, name_it_t it2)
bool name_end_p(name_it_t it)
bool name_last_p(name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
void name_next(name_it_t it)
void name_previous(name_it_t it)
type *name_ref(name_it_t it)
const type *name_cref(const name_it_t it)
void name_remove(name_t array, name_it_t it)
void name_insert(name_t array, name_it_t it, const type x)
void name_get_str(string_t str, const name_t array, bool append)
bool name_parse_str(name_t array, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t array)
bool name_in_str(name_t array, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t array1, const name_t array2)
size_t name_hash(const name_t array)

#include <stdio.h>
#include <gmp.h>
#include "m-deque.h"

DEQUE_DEF(deque_mpz, mpz_t,                                           \
          (INIT(mpz_init), INIT_SET(mpz_init_set), SET(mpz_set), CLEAR(mpz_clear)))

int main(void) {
  deque_mpz_t a;
  deque_mpz_init(a);
  mpz_t x;
  mpz_init_set_ui(x, 16);
  deque_mpz_push_back (a, x);
  mpz_set_ui(x, 45);             
  deque_mpz_push_front (a, x);
  deque_mpz_pop_back(&x, a);
  mpz_set_ui(x, 5);
  deque_mpz_push_back (a, x);
  mpz_clear(x);

  printf ("First element is: ");
  mpz_out_str(stdout, 0, *deque_mpz_front(a));
  printf ("\n");
  printf ("Last element is: ");
  mpz_out_str(stdout, 0, *deque_mpz_back(a));
  printf ("\n");
  deque_mpz_clear(a);
}

void name_init(name_t deque)
void name_init_set(name_t deque, const name_t ref)
void name_set(name_t deque, const name_t ref)
void name_init_move(name_t deque, name_t ref)
void name_move(name_t deque, name_t ref)
void name_clear(name_t deque)
void name_reset(name_t deque)
type *name_back(const name_t deque)
void name_push_back(name_t deque, type value)
type *name_push_back_raw(name_t deque)
type *name_push_back_new(name_t deque)
void name_emplace_back[suffix](name_t list, args...)
void name_pop_back(type *data, name_t deque)
type *name_front(const name_t deque)
void name_push_front(name_t deque, type value)
type *name_push_front_raw(name_t deque)
type *name_push_front_new(name_t deque)
void name_emplace_front[suffix](name_t list, args...)
void name_pop_front(type *data, name_t deque)
bool name_empty_p(const name_t deque)
void name_swap(name_t deque1, name_t deque2)
void name_it(name_it_t it, name_t deque)
void name_it_set(name_it_t it, const name_it_t ref)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
void name_next(name_it_t it)
void name_previous(name_it_t it)
type *name_ref(name_it_t it)
const type *name_cref(const name_it_t it)
void name_remove(name_t deque, name_it_t it)
type *name_get(const name_t deque, size_t i)
const type *name_cget(const name_t deque, size_t i)
size_t name_size(const name_t deque)
void name_get_str(string_t str, const name_t deque, bool append)
bool name_parse_str(name_t deque, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t deque)
bool name_in_str(name_t deque, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t deque1, const name_t deque2)
size_t name_hash(const name_t deque)
void name_swap_at(name_t deque, size_t i, size_t j)

#include <stdio.h>
#include "m-string.h"
#include "m-dict.h"

DICT_DEF2(dict_string, string_t, unsigned)

int main(void) {
  dict_string_t a;
  dict_string_init(a);
  string_t x;
  string_init_set_str(x, "This is an example");
  dict_string_set_at (a, x, 1);
  string_set_str(x, "This is an another example");
  dict_string_set_at (a, x, 2);

  string_set_str(x, "This is an example");
  unsigned *val = dict_string_get(a, x);
  printf ("Value of %s is %u\n", string_get_cstr(x), *val);
  string_clear(x);

  printf ("Dictionary is: ");
  dict_string_out_str(stdout, a);
  printf ("\n");
  dict_string_clear(a);
}

#include <stdio.h>
#include "m-string.h"
#include "m-dict.h"

// Define an Out Of Range equal function
static inline bool oor_equal_p(unsigned k, unsigned char n) {
  return k == (unsigned)(-n-1);
}
// Define an Out Of Range function
static inline void oor_set(unsigned *k, unsigned char n) {
  *k = (unsigned)(-n-1);
}

DICT_OA_DEF2(dict_unsigned, unsigned, M_OPEXTEND(M_BASIC_OPLIST, 
            OOR_EQUAL(oor_equal_p), OOR_SET(API_2(oor_set))), long long, M_BASIC_OPLIST)

unsigned main(void) {
  dict_unsigned_t a;
  dict_unsigned_init(a);
  dict_unsigned_set_at (a, 13566, 14890943049);
  dict_unsigned_set_at (a, 656, -2);

  long long *val = dict_unsigned_get(a, 458);
  printf ("Value of %d is %p\n", 458, val); // Not found value
  val = dict_unsigned_get(a, 656);
  printf ("Value of %d is %lld\n", 656, *val);

  dict_unsigned_clear(a);
}

#include <stdio.h>
#include "m-string.h"
#include "m-dict.h"

DICT_SET_DEF(set_string, double)

unsigned main(void) {
  set_string_t a;
  set_string_init(a);
  set_string_push (a, 13566);
  set_string_push (a, 656);

  double *val = set_string_get(a, 458);
  printf ("Value of %d is %p\n", 458, val); // Not found value
  val = set_string_get(a, 656);
  printf ("Value of %d is %f\n", 656, *val);

  printf("Set is ");
  set_string_out_str(stdout, a);
  printf("\n");
  set_string_clear(a);
}

void name_init(name_t dict)
void name_clear(name_t dict)
void name_init_set(name_t dict, const name_t ref)
void name_set(name_t dict, const name_t ref)
void name_init_move(name_t dict, name_t ref)
void name_move(name_t dict, name_t ref)
void name_reset(name_t dict)
size_t name_size(const name_t dict)
bool name_empty_p(const name_t dict)
value_type *name_get(const name_t dict, const key_type key)
value_type_t * name_get_emplace[suffix](name_t container, args...)
value_type *name_safe_get(name_t dict, const key_type key)
void name_set_at(name_t dict, const key_type key, const value_type value)   /* for associative array */
void name_push(name_t dict, const key_type key)       /* for dictionary set */
bool name_erase(name_t dict, const key_type key)
void name_it(name_it_t it, name_t dict)
void name_it_set(name_it_t it, const name_it_t ref)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
void name_next(name_it_t it)
name_itref_t *name_ref(name_it_t it)  /* for associative array */
key_type *name_ref(name_it_t it)       /* for dictionary set */
const name_itref_t *name_cref(name_it_t it)  /* for associative array */
const key_type *name_cref(name_it_t it)       /* for dictionary set */
void name_get_str(string_t str, const name_t dict, bool append)
bool name_parse_str(name_t dict, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t dict)
bool name_in_str(name_t dict, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t dict1, const name_t dict2)
void name_emplace[suffix](name_t container, keyargs...) [for dictionary set */
void name_emplace_key[keysuffix]_val[valsuffix](name_t container, keyargs..., valargs...) /* for associative array */
void name_reserve(name_t dict, size_t capacity)

#include <stdio.h>
#include <gmp.h>
#include "m-string.h"
#include "m-tuple.h"

#define MPZ_OUT_STR(stream, x) mpz_out_str(stream, 0, x)
TUPLE_DEF2(pair, (key_field, string_t, STRING_OPLIST),     \
    (value_field, mpz_t, M_OPEXTEND(M_CLASSIC_OPLIST(mpz), \
        OUT_STR(MPZ_OUT_STR))))

int main(void) {
  pair_t p1;
  pair_init (p1);
  string_set_str(p1->key_field, "HELLO");
  mpz_set_str(p1->value_field, "1742", 10);
  printf("The pair is ");
  pair_out_str(stdout, p1);
  printf("\n");
  pair_clear(p1);
}

void name_init(name_t tuple)
void name_init_set(name_t tuple, const name_t ref)
void name_set(name_t tuple, const name_t ref)
void name_init_move(name_t tuple, name_t ref)
void name_move(name_t tuple, name_t ref)
void name_clear(name_t tuple)
void name_reset(name_t tuple)
void name_get_str(string_t str, const name_t tuple, bool append)
bool name_parse_str(name_t tuple, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t tuple)
bool name_in_str(name_t tuple, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
size_t name_hash(const name_t tuple)
int name_equal_p(const name_t tuple1, const name_t tuple2)
int name_cmp(const name_t tuple1, const name_t tuple2)

#include <stdio.h>
#include "m-string.h"
#include "m-variant.h"

VARIANT_DEF2(item,
             (name, string_t),
             (age, long))

int main(void) {
  item_t p1;
  item_init (p1);
  item_set_name(p1, STRING_CTE("HELLO"));
  printf("The variant is ");
  item_out_str(stdout, p1);
  printf("\n");

  item_set_age(p1, 43);
  printf("The variant is now ");
  item_out_str(stdout, p1);
  printf("\n");
  
  item_clear(p1);
}

void name_init(name_t variant)
void name_init_set(name_t variant, const name_t ref)
void name_set(name_t variant, const name_t ref)
void name_init_move(name_t variant, name_t ref)
void name_move(name_t variant, name_t ref)
void name_clear(name_t variant)
void name_reset(name_t variant)
bool name_empty_p(const name_t variant)
size_t name_hash(const name_t variant)
bool name_equal_p(const name_t variant1, const name_t variant2)
void name_swap(name_t variant1, name_t variant2)
void name_get_str(string_t str, name_t variant, bool append)
bool name_parse_str(name_t variant, const char str[], const char **endp)
void name_out_str(FILE *file, name_t variant)
bool name_in_str(name_t variant, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)

RBTREE_DEF(rbtree_uint, unsigned int)
void f(unsigned int num) {
        rbtree_uint_t tree;
        rbtree_uint_init(tree);
        for(unsigned int i = 0; i < num; i++)
                rbtree_uint_push(tree, i);
        rbtree_uint_clear(tree);                              
}

void name_init(name_t rbtree)
void name_clear(name_t rbtree)
void name_init_set(name_t rbtree, const name_t ref)
void name_set(name_t rbtree, const name_t ref)
void name_init_move(name_t rbtree, name_t ref)
void name_move(name_t rbtree, name_t ref)
void name_reset(name_t rbtree)
size_t name_size(const name_t rbtree)
void name_push(name_t rbtree, const type data)
void name_emplace[suffix](name_t rbtree, args...)
type *name_get(const name_t rbtree, const type data)
const type *name_cget(const name_t rbtree, const type data)
void name_swap(name_t rbtree1, name_t rbtree2)
bool name_empty_p(const name_t rbtree)
void name_it(name_it_t it, name_t rbtree)
void name_it_set(name_it_t it, const name_it_t ref)
void name_it_last(name_it_t it, name_t rbtree)
void name_it_end(name_it_t it, name_t rbtree)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
void name_it_remove(name_t rbtree, name_it_t it)
void name_next(name_it_t it)
void name_previous(name_it_t it)
type *name_ref(name_it_t it)
const type *name_ref(name_it_t it)
void name_get_str(string_t str, const name_t rbtree, bool append)
bool name_parse_str(name_t tree, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t rbtree)
bool name_in_str(name_t rbtree, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t rbtree1, const name_t rbtree2)
size_t name_hash(const name_t rbtree)

BPTREE_DEF2(tree_uint, 4, unsigned int, (), float, ())
void f(unsigned int num) {
        tree_uint_t tree;
        tree_uint_init(tree);
        for(unsigned int i = 0; i < num; i++)
                tree_uint_set_at(tree, i, (float) i);
        tree_uint_clear(tree);
}

BPTREE_DEF(tree_uint, unsigned int)
void f(unsigned int num) {
        tree_uint_t tree;
        tree_uint_init(tree);
        for(unsigned int i = 0; i < num; i++)
                tree_uint_push(tree, i);
        tree_uint_clear(tree);
}

void name_init(name_t tree)
void name_clear(name_t tree)
void name_init_set(name_t tree, const name_t ref)
void name_set(name_t tree, const name_t ref)
void name_init_move(name_t tree, name_t ref)
void name_move(name_t tree, name_t ref)
void name_reset(name_t tree)
size_t name_size(const name_t tree)
void name_push(name_t tree, const key_type data) [for set definition only]
void name_set_at(name_t tree, const key_type data, const value_type val)  /* for associative array definition only */
bool name_erase(name_t tree, const key_type data)
value_type *name_get(const name_t tree, const key_type data)
const value_type *name_cget(const name_t tree, const key_type data)
value_type *name_safe_get(name_t tree, const key_type data)
void name_swap(name_t tree1, name_t tree2)
bool name_empty_p(const name_t tree)
void name_it(name_it_t it, name_t tree)
void name_it_set(name_it_t it, const name_it_t ref)
void name_it_end(name_it_t it, name_t tree)
bool name_end_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it1)
void name_next(name_it_t it)
name_itref_t *name_ref(name_it_t it)
const name_itref_t *name_cref(name_it_t it)
void name_get_str(string_t str, const name_t tree, bool append)
bool name_parse_str(name_t tree, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t tree)
bool name_in_str(name_t tree, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
bool name_equal_p(const name_t tree1, const name_t tree2)
size_t name_hash(const name_t tree)
void name_emplace[suffix](name_t container, keyargs...) [for dictionary set]
void name_emplace_key[keysuffix]_val[valsuffix](name_t container, keyargs..., valargs...) /* for associative array */

void name_init(name_t tree)
void name_init_set(name_t tree, const name_t ref)
void name_init_move(name_t tree, name_t ref)
void name_set(name_t tree, const name_t ref)
void name_move(name_t tree, name_t ref)
void name_clear(name_t tree)
void name_reset(name_t tree)
size_t name_size(const name_t tree)
size_t name_capacity(const name_t tree)
void name_reserve(name_t tree, size_t capacity)
bool name_empty_p(const name_t tree)
void name_swap(name_t tree1, name_t tree2)
bool name_equal_p(const name_t tree1, const name_t tree2)
bool name_end_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
const type *name_cref(name_it_t it)
type *name_ref(name_it_t it)
bool name_remove(it_t it)
void name_get_str(string_t str, const name_t tree, bool append)
bool name_parse_str(name_t tree, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t tree)
bool name_in_str(name_t tree, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)

void name_init(name_t queue)
void name_clear(name_t queue)
void name_init_set(name_t queue, const name_t ref)
void name_set(name_t queue, const name_t ref)
void name_init_move(name_t queue, name_t ref)
void name_move(name_t queue, name_t ref)
void name_reset(name_t queue)
size_t name_size(const name_t queue)
bool name_empty_p(const name_t queue)
void name_swap(name_t queue1, name_t queue2)
void name_push(name_t queue, const type x)
const type *name_front(name_t queue)
void name_pop(type *dest, name_t queue)
bool name_equal_p(const name_t queue1, const name_t queue2)
bool name_erase(name_t queue, const type_t val)
void name_it(name_it_t it, name_t queue)
void name_it_last(name_it_t it, name_t queue)
void name_it_set(name_it_t it, const name_it_t ref)
void name_it_end(name_it_t it, name_t queue)
bool name_end_p(const name_it_t it)
bool name_last_p(const name_it_t it)
bool name_it_equal_p(const name_it_t it1, const name_it_t it2)
void name_next(name_it_t it)
void name_previous(name_it_t it)
const type *name_cref(name_it_t it)
void name_get_str(string_t str, const name_t queue, bool append)
bool name_parse_str(name_t queue, const char str[], const char **endp)
void name_out_str(FILE *file, const name_t queue)
bool name_in_str(name_t queue, FILE *file)
m_serial_return_code_t name_out_serial(m_serial_write_t serial, const name_t container)
m_serial_return_code_t name_in_str(name_t container, m_serial_read_t serial)
void name_emplace[suffix](name_t queue, args...)