XKB introduces several uncommon data structures:

 - switch allows conditional inclusion of fields

 - several complex objects intermix variable and fixed size fields

 - lists with a variable number of variable size objects

To handle these objects, a number of new functions is generated:

 - _serialize() turns a structured object into a byte stream, 

   (re)ordering or including fields according to the protocol

 - _unserialize() rewrites data from a buffer into a structured object

 - _unpack() expands a buffer representing a switch object into 

   a special structured type, all flags needed to resolve the switch

   expression have to given as parameters

 - _sizeof() calculates the size of a serialized object, often by calling

   _unserialize()/_unpack() internally

The new structured data type for switch is special as it contains fixed 

and variable size fields. Variable size fields can be accessed via pointers. 

If switch appears in a request, an additional set of request helpers is 

generated with the suffix _aux or _aux_(un)checked. While the 'common'

request functions require that switch has been serialized before, the _aux

variants take the structured data type. They are especially designed to 

replace certain functions in xcb-util/aux. 

Accessors for switch members need two parameters, where the first is usually

a pointer to the respective request or reply structure, while the second 

is a pointer to the unpacked switch data structure. 

Functions from the serialize family that take a double pointer can allocate 

memory on their own, which is useful if the size of a buffer has to be 

calculated depending on the data within. These functions call malloc() when 

the double pointer is given as the address of a pointer that has been 

initialized to 0. It is the responsibility of the user to free any allocated

memory. 

Intermixed variable and fixed size fields are an important special case in XKB. 

The current implementation resolves the issue by reordering the fields before

sending them on the wire as well as before returning a reply. That means that 

these objects look like 'common' XCB data types and they can be accessed as such 

(i.e. fixed size fields directly via the structured type and variable size fields

via accessors/iterators).  

In case a list with variable size elements needs to be accessed, it is necessary 

to use iterators. The iterator functions take care of determining the actual 

object size for each element automatically. 

A small and preliminary set of auxiliary functions is available in xkb_util.c 

in the check_xkb module.