xref: /netbsd-src/external/mit/xorg/lib/libxcb/files/xkb.c (revision c201ebe368fc4b13732e29cfc99699e9060bdbf2)
1 /*
2  * This file generated automatically from xkb.xml by c_client.py.
3  * Edit at your peril.
4  */
5 
6 #ifdef HAVE_CONFIG_H
7 #include "config.h"
8 #endif
9 #include <stdlib.h>
10 #include <string.h>
11 #include <assert.h>
12 #include <stddef.h>  /* for offsetof() */
13 #include "xcbext.h"
14 #include "xkb.h"
15 
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 #include "xproto.h"
18 
19 xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 };
20 
21 void
xcb_xkb_device_spec_next(xcb_xkb_device_spec_iterator_t * i)22 xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i)
23 {
24     --i->rem;
25     ++i->data;
26     i->index += sizeof(xcb_xkb_device_spec_t);
27 }
28 
29 xcb_generic_iterator_t
xcb_xkb_device_spec_end(xcb_xkb_device_spec_iterator_t i)30 xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i)
31 {
32     xcb_generic_iterator_t ret;
33     ret.data = i.data + i.rem;
34     ret.index = i.index + ((char *) ret.data - (char *) i.data);
35     ret.rem = 0;
36     return ret;
37 }
38 
39 void
xcb_xkb_led_class_spec_next(xcb_xkb_led_class_spec_iterator_t * i)40 xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i)
41 {
42     --i->rem;
43     ++i->data;
44     i->index += sizeof(xcb_xkb_led_class_spec_t);
45 }
46 
47 xcb_generic_iterator_t
xcb_xkb_led_class_spec_end(xcb_xkb_led_class_spec_iterator_t i)48 xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i)
49 {
50     xcb_generic_iterator_t ret;
51     ret.data = i.data + i.rem;
52     ret.index = i.index + ((char *) ret.data - (char *) i.data);
53     ret.rem = 0;
54     return ret;
55 }
56 
57 void
xcb_xkb_bell_class_spec_next(xcb_xkb_bell_class_spec_iterator_t * i)58 xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i)
59 {
60     --i->rem;
61     ++i->data;
62     i->index += sizeof(xcb_xkb_bell_class_spec_t);
63 }
64 
65 xcb_generic_iterator_t
xcb_xkb_bell_class_spec_end(xcb_xkb_bell_class_spec_iterator_t i)66 xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i)
67 {
68     xcb_generic_iterator_t ret;
69     ret.data = i.data + i.rem;
70     ret.index = i.index + ((char *) ret.data - (char *) i.data);
71     ret.rem = 0;
72     return ret;
73 }
74 
75 void
xcb_xkb_id_spec_next(xcb_xkb_id_spec_iterator_t * i)76 xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i)
77 {
78     --i->rem;
79     ++i->data;
80     i->index += sizeof(xcb_xkb_id_spec_t);
81 }
82 
83 xcb_generic_iterator_t
xcb_xkb_id_spec_end(xcb_xkb_id_spec_iterator_t i)84 xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i)
85 {
86     xcb_generic_iterator_t ret;
87     ret.data = i.data + i.rem;
88     ret.index = i.index + ((char *) ret.data - (char *) i.data);
89     ret.rem = 0;
90     return ret;
91 }
92 
93 void
xcb_xkb_indicator_map_next(xcb_xkb_indicator_map_iterator_t * i)94 xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i)
95 {
96     --i->rem;
97     ++i->data;
98     i->index += sizeof(xcb_xkb_indicator_map_t);
99 }
100 
101 xcb_generic_iterator_t
xcb_xkb_indicator_map_end(xcb_xkb_indicator_map_iterator_t i)102 xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i)
103 {
104     xcb_generic_iterator_t ret;
105     ret.data = i.data + i.rem;
106     ret.index = i.index + ((char *) ret.data - (char *) i.data);
107     ret.rem = 0;
108     return ret;
109 }
110 
111 void
xcb_xkb_mod_def_next(xcb_xkb_mod_def_iterator_t * i)112 xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i)
113 {
114     --i->rem;
115     ++i->data;
116     i->index += sizeof(xcb_xkb_mod_def_t);
117 }
118 
119 xcb_generic_iterator_t
xcb_xkb_mod_def_end(xcb_xkb_mod_def_iterator_t i)120 xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i)
121 {
122     xcb_generic_iterator_t ret;
123     ret.data = i.data + i.rem;
124     ret.index = i.index + ((char *) ret.data - (char *) i.data);
125     ret.rem = 0;
126     return ret;
127 }
128 
129 void
xcb_xkb_key_name_next(xcb_xkb_key_name_iterator_t * i)130 xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i)
131 {
132     --i->rem;
133     ++i->data;
134     i->index += sizeof(xcb_xkb_key_name_t);
135 }
136 
137 xcb_generic_iterator_t
xcb_xkb_key_name_end(xcb_xkb_key_name_iterator_t i)138 xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i)
139 {
140     xcb_generic_iterator_t ret;
141     ret.data = i.data + i.rem;
142     ret.index = i.index + ((char *) ret.data - (char *) i.data);
143     ret.rem = 0;
144     return ret;
145 }
146 
147 void
xcb_xkb_key_alias_next(xcb_xkb_key_alias_iterator_t * i)148 xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i)
149 {
150     --i->rem;
151     ++i->data;
152     i->index += sizeof(xcb_xkb_key_alias_t);
153 }
154 
155 xcb_generic_iterator_t
xcb_xkb_key_alias_end(xcb_xkb_key_alias_iterator_t i)156 xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i)
157 {
158     xcb_generic_iterator_t ret;
159     ret.data = i.data + i.rem;
160     ret.index = i.index + ((char *) ret.data - (char *) i.data);
161     ret.rem = 0;
162     return ret;
163 }
164 
165 int
xcb_xkb_counted_string_16_sizeof(const void * _buffer)166 xcb_xkb_counted_string_16_sizeof (const void  *_buffer)
167 {
168     char *xcb_tmp = (char *)_buffer;
169     const xcb_xkb_counted_string_16_t *_aux = (xcb_xkb_counted_string_16_t *)_buffer;
170     unsigned int xcb_buffer_len = 0;
171     unsigned int xcb_block_len = 0;
172     unsigned int xcb_pad = 0;
173     unsigned int xcb_align_to = 0;
174 
175 
176     xcb_block_len += sizeof(xcb_xkb_counted_string_16_t);
177     xcb_tmp += xcb_block_len;
178     xcb_buffer_len += xcb_block_len;
179     xcb_block_len = 0;
180     /* string */
181     xcb_block_len += _aux->length * sizeof(char);
182     xcb_tmp += xcb_block_len;
183     xcb_align_to = ALIGNOF(char);
184     /* insert padding */
185     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
186     xcb_buffer_len += xcb_block_len + xcb_pad;
187     if (0 != xcb_pad) {
188         xcb_tmp += xcb_pad;
189         xcb_pad = 0;
190     }
191     xcb_block_len = 0;
192     /* alignment_pad */
193     xcb_block_len += (((_aux->length + 5) & (~3)) - (_aux->length + 2)) * sizeof(char);
194     xcb_tmp += xcb_block_len;
195     xcb_align_to = ALIGNOF(char);
196     /* insert padding */
197     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
198     xcb_buffer_len += xcb_block_len + xcb_pad;
199     if (0 != xcb_pad) {
200         xcb_tmp += xcb_pad;
201         xcb_pad = 0;
202     }
203     xcb_block_len = 0;
204 
205     return xcb_buffer_len;
206 }
207 
208 char *
xcb_xkb_counted_string_16_string(const xcb_xkb_counted_string_16_t * R)209 xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R)
210 {
211     return (char *) (R + 1);
212 }
213 
214 int
xcb_xkb_counted_string_16_string_length(const xcb_xkb_counted_string_16_t * R)215 xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R)
216 {
217     return R->length;
218 }
219 
220 xcb_generic_iterator_t
xcb_xkb_counted_string_16_string_end(const xcb_xkb_counted_string_16_t * R)221 xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R)
222 {
223     xcb_generic_iterator_t i;
224     i.data = ((char *) (R + 1)) + (R->length);
225     i.rem = 0;
226     i.index = (char *) i.data - (char *) R;
227     return i;
228 }
229 
230 void *
xcb_xkb_counted_string_16_alignment_pad(const xcb_xkb_counted_string_16_t * R)231 xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R)
232 {
233     xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R);
234     return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
235 }
236 
237 int
xcb_xkb_counted_string_16_alignment_pad_length(const xcb_xkb_counted_string_16_t * R)238 xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R)
239 {
240     return (((R->length + 5) & (~3)) - (R->length + 2));
241 }
242 
243 xcb_generic_iterator_t
xcb_xkb_counted_string_16_alignment_pad_end(const xcb_xkb_counted_string_16_t * R)244 xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R)
245 {
246     xcb_generic_iterator_t i;
247     xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R);
248     i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->length + 5) & (~3)) - (R->length + 2)));
249     i.rem = 0;
250     i.index = (char *) i.data - (char *) R;
251     return i;
252 }
253 
254 void
xcb_xkb_counted_string_16_next(xcb_xkb_counted_string_16_iterator_t * i)255 xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i)
256 {
257     xcb_xkb_counted_string_16_t *R = i->data;
258     xcb_generic_iterator_t child;
259     child.data = (xcb_xkb_counted_string_16_t *)(((char *)R) + xcb_xkb_counted_string_16_sizeof(R));
260     i->index = (char *) child.data - (char *) i->data;
261     --i->rem;
262     i->data = (xcb_xkb_counted_string_16_t *) child.data;
263 }
264 
265 xcb_generic_iterator_t
xcb_xkb_counted_string_16_end(xcb_xkb_counted_string_16_iterator_t i)266 xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i)
267 {
268     xcb_generic_iterator_t ret;
269     while(i.rem > 0)
270         xcb_xkb_counted_string_16_next(&i);
271     ret.data = i.data;
272     ret.rem = i.rem;
273     ret.index = i.index;
274     return ret;
275 }
276 
277 void
xcb_xkb_kt_map_entry_next(xcb_xkb_kt_map_entry_iterator_t * i)278 xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i)
279 {
280     --i->rem;
281     ++i->data;
282     i->index += sizeof(xcb_xkb_kt_map_entry_t);
283 }
284 
285 xcb_generic_iterator_t
xcb_xkb_kt_map_entry_end(xcb_xkb_kt_map_entry_iterator_t i)286 xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i)
287 {
288     xcb_generic_iterator_t ret;
289     ret.data = i.data + i.rem;
290     ret.index = i.index + ((char *) ret.data - (char *) i.data);
291     ret.rem = 0;
292     return ret;
293 }
294 
295 int
xcb_xkb_key_type_sizeof(const void * _buffer)296 xcb_xkb_key_type_sizeof (const void  *_buffer)
297 {
298     char *xcb_tmp = (char *)_buffer;
299     const xcb_xkb_key_type_t *_aux = (xcb_xkb_key_type_t *)_buffer;
300     unsigned int xcb_buffer_len = 0;
301     unsigned int xcb_block_len = 0;
302     unsigned int xcb_pad = 0;
303     unsigned int xcb_align_to = 0;
304 
305 
306     xcb_block_len += sizeof(xcb_xkb_key_type_t);
307     xcb_tmp += xcb_block_len;
308     xcb_buffer_len += xcb_block_len;
309     xcb_block_len = 0;
310     /* map */
311     xcb_block_len += _aux->nMapEntries * sizeof(xcb_xkb_kt_map_entry_t);
312     xcb_tmp += xcb_block_len;
313     xcb_align_to = ALIGNOF(xcb_xkb_kt_map_entry_t);
314     /* insert padding */
315     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
316     xcb_buffer_len += xcb_block_len + xcb_pad;
317     if (0 != xcb_pad) {
318         xcb_tmp += xcb_pad;
319         xcb_pad = 0;
320     }
321     xcb_block_len = 0;
322     /* preserve */
323     xcb_block_len += (_aux->hasPreserve * _aux->nMapEntries) * sizeof(xcb_xkb_mod_def_t);
324     xcb_tmp += xcb_block_len;
325     xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
326     /* insert padding */
327     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
328     xcb_buffer_len += xcb_block_len + xcb_pad;
329     if (0 != xcb_pad) {
330         xcb_tmp += xcb_pad;
331         xcb_pad = 0;
332     }
333     xcb_block_len = 0;
334 
335     return xcb_buffer_len;
336 }
337 
338 xcb_xkb_kt_map_entry_t *
xcb_xkb_key_type_map(const xcb_xkb_key_type_t * R)339 xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R)
340 {
341     return (xcb_xkb_kt_map_entry_t *) (R + 1);
342 }
343 
344 int
xcb_xkb_key_type_map_length(const xcb_xkb_key_type_t * R)345 xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R)
346 {
347     return R->nMapEntries;
348 }
349 
350 xcb_xkb_kt_map_entry_iterator_t
xcb_xkb_key_type_map_iterator(const xcb_xkb_key_type_t * R)351 xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R)
352 {
353     xcb_xkb_kt_map_entry_iterator_t i;
354     i.data = (xcb_xkb_kt_map_entry_t *) (R + 1);
355     i.rem = R->nMapEntries;
356     i.index = (char *) i.data - (char *) R;
357     return i;
358 }
359 
360 xcb_xkb_mod_def_t *
xcb_xkb_key_type_preserve(const xcb_xkb_key_type_t * R)361 xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R)
362 {
363     xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R));
364     return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
365 }
366 
367 int
xcb_xkb_key_type_preserve_length(const xcb_xkb_key_type_t * R)368 xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R)
369 {
370     return (R->hasPreserve * R->nMapEntries);
371 }
372 
373 xcb_xkb_mod_def_iterator_t
xcb_xkb_key_type_preserve_iterator(const xcb_xkb_key_type_t * R)374 xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R)
375 {
376     xcb_xkb_mod_def_iterator_t i;
377     xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R));
378     i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
379     i.rem = (R->hasPreserve * R->nMapEntries);
380     i.index = (char *) i.data - (char *) R;
381     return i;
382 }
383 
384 void
xcb_xkb_key_type_next(xcb_xkb_key_type_iterator_t * i)385 xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i)
386 {
387     xcb_xkb_key_type_t *R = i->data;
388     xcb_generic_iterator_t child;
389     child.data = (xcb_xkb_key_type_t *)(((char *)R) + xcb_xkb_key_type_sizeof(R));
390     i->index = (char *) child.data - (char *) i->data;
391     --i->rem;
392     i->data = (xcb_xkb_key_type_t *) child.data;
393 }
394 
395 xcb_generic_iterator_t
xcb_xkb_key_type_end(xcb_xkb_key_type_iterator_t i)396 xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i)
397 {
398     xcb_generic_iterator_t ret;
399     while(i.rem > 0)
400         xcb_xkb_key_type_next(&i);
401     ret.data = i.data;
402     ret.rem = i.rem;
403     ret.index = i.index;
404     return ret;
405 }
406 
407 int
xcb_xkb_key_sym_map_sizeof(const void * _buffer)408 xcb_xkb_key_sym_map_sizeof (const void  *_buffer)
409 {
410     char *xcb_tmp = (char *)_buffer;
411     const xcb_xkb_key_sym_map_t *_aux = (xcb_xkb_key_sym_map_t *)_buffer;
412     unsigned int xcb_buffer_len = 0;
413     unsigned int xcb_block_len = 0;
414     unsigned int xcb_pad = 0;
415     unsigned int xcb_align_to = 0;
416 
417 
418     xcb_block_len += sizeof(xcb_xkb_key_sym_map_t);
419     xcb_tmp += xcb_block_len;
420     xcb_buffer_len += xcb_block_len;
421     xcb_block_len = 0;
422     /* syms */
423     xcb_block_len += _aux->nSyms * sizeof(xcb_keysym_t);
424     xcb_tmp += xcb_block_len;
425     xcb_align_to = ALIGNOF(xcb_keysym_t);
426     /* insert padding */
427     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
428     xcb_buffer_len += xcb_block_len + xcb_pad;
429     if (0 != xcb_pad) {
430         xcb_tmp += xcb_pad;
431         xcb_pad = 0;
432     }
433     xcb_block_len = 0;
434 
435     return xcb_buffer_len;
436 }
437 
438 xcb_keysym_t *
xcb_xkb_key_sym_map_syms(const xcb_xkb_key_sym_map_t * R)439 xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R)
440 {
441     return (xcb_keysym_t *) (R + 1);
442 }
443 
444 int
xcb_xkb_key_sym_map_syms_length(const xcb_xkb_key_sym_map_t * R)445 xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R)
446 {
447     return R->nSyms;
448 }
449 
450 xcb_generic_iterator_t
xcb_xkb_key_sym_map_syms_end(const xcb_xkb_key_sym_map_t * R)451 xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R)
452 {
453     xcb_generic_iterator_t i;
454     i.data = ((xcb_keysym_t *) (R + 1)) + (R->nSyms);
455     i.rem = 0;
456     i.index = (char *) i.data - (char *) R;
457     return i;
458 }
459 
460 void
xcb_xkb_key_sym_map_next(xcb_xkb_key_sym_map_iterator_t * i)461 xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i)
462 {
463     xcb_xkb_key_sym_map_t *R = i->data;
464     xcb_generic_iterator_t child;
465     child.data = (xcb_xkb_key_sym_map_t *)(((char *)R) + xcb_xkb_key_sym_map_sizeof(R));
466     i->index = (char *) child.data - (char *) i->data;
467     --i->rem;
468     i->data = (xcb_xkb_key_sym_map_t *) child.data;
469 }
470 
471 xcb_generic_iterator_t
xcb_xkb_key_sym_map_end(xcb_xkb_key_sym_map_iterator_t i)472 xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i)
473 {
474     xcb_generic_iterator_t ret;
475     while(i.rem > 0)
476         xcb_xkb_key_sym_map_next(&i);
477     ret.data = i.data;
478     ret.rem = i.rem;
479     ret.index = i.index;
480     return ret;
481 }
482 
483 void
xcb_xkb_common_behavior_next(xcb_xkb_common_behavior_iterator_t * i)484 xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i)
485 {
486     --i->rem;
487     ++i->data;
488     i->index += sizeof(xcb_xkb_common_behavior_t);
489 }
490 
491 xcb_generic_iterator_t
xcb_xkb_common_behavior_end(xcb_xkb_common_behavior_iterator_t i)492 xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i)
493 {
494     xcb_generic_iterator_t ret;
495     ret.data = i.data + i.rem;
496     ret.index = i.index + ((char *) ret.data - (char *) i.data);
497     ret.rem = 0;
498     return ret;
499 }
500 
501 void
xcb_xkb_default_behavior_next(xcb_xkb_default_behavior_iterator_t * i)502 xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i)
503 {
504     --i->rem;
505     ++i->data;
506     i->index += sizeof(xcb_xkb_default_behavior_t);
507 }
508 
509 xcb_generic_iterator_t
xcb_xkb_default_behavior_end(xcb_xkb_default_behavior_iterator_t i)510 xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i)
511 {
512     xcb_generic_iterator_t ret;
513     ret.data = i.data + i.rem;
514     ret.index = i.index + ((char *) ret.data - (char *) i.data);
515     ret.rem = 0;
516     return ret;
517 }
518 
519 void
xcb_xkb_lock_behavior_next(xcb_xkb_lock_behavior_iterator_t * i)520 xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i)
521 {
522     --i->rem;
523     ++i->data;
524     i->index += sizeof(xcb_xkb_lock_behavior_t);
525 }
526 
527 xcb_generic_iterator_t
xcb_xkb_lock_behavior_end(xcb_xkb_lock_behavior_iterator_t i)528 xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i)
529 {
530     xcb_generic_iterator_t ret;
531     ret.data = i.data + i.rem;
532     ret.index = i.index + ((char *) ret.data - (char *) i.data);
533     ret.rem = 0;
534     return ret;
535 }
536 
537 void
xcb_xkb_radio_group_behavior_next(xcb_xkb_radio_group_behavior_iterator_t * i)538 xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i)
539 {
540     --i->rem;
541     ++i->data;
542     i->index += sizeof(xcb_xkb_radio_group_behavior_t);
543 }
544 
545 xcb_generic_iterator_t
xcb_xkb_radio_group_behavior_end(xcb_xkb_radio_group_behavior_iterator_t i)546 xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i)
547 {
548     xcb_generic_iterator_t ret;
549     ret.data = i.data + i.rem;
550     ret.index = i.index + ((char *) ret.data - (char *) i.data);
551     ret.rem = 0;
552     return ret;
553 }
554 
555 void
xcb_xkb_overlay_behavior_next(xcb_xkb_overlay_behavior_iterator_t * i)556 xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i)
557 {
558     --i->rem;
559     ++i->data;
560     i->index += sizeof(xcb_xkb_overlay_behavior_t);
561 }
562 
563 xcb_generic_iterator_t
xcb_xkb_overlay_behavior_end(xcb_xkb_overlay_behavior_iterator_t i)564 xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i)
565 {
566     xcb_generic_iterator_t ret;
567     ret.data = i.data + i.rem;
568     ret.index = i.index + ((char *) ret.data - (char *) i.data);
569     ret.rem = 0;
570     return ret;
571 }
572 
573 void
xcb_xkb_permament_lock_behavior_next(xcb_xkb_permament_lock_behavior_iterator_t * i)574 xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i)
575 {
576     --i->rem;
577     ++i->data;
578     i->index += sizeof(xcb_xkb_permament_lock_behavior_t);
579 }
580 
581 xcb_generic_iterator_t
xcb_xkb_permament_lock_behavior_end(xcb_xkb_permament_lock_behavior_iterator_t i)582 xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i)
583 {
584     xcb_generic_iterator_t ret;
585     ret.data = i.data + i.rem;
586     ret.index = i.index + ((char *) ret.data - (char *) i.data);
587     ret.rem = 0;
588     return ret;
589 }
590 
591 void
xcb_xkb_permament_radio_group_behavior_next(xcb_xkb_permament_radio_group_behavior_iterator_t * i)592 xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i)
593 {
594     --i->rem;
595     ++i->data;
596     i->index += sizeof(xcb_xkb_permament_radio_group_behavior_t);
597 }
598 
599 xcb_generic_iterator_t
xcb_xkb_permament_radio_group_behavior_end(xcb_xkb_permament_radio_group_behavior_iterator_t i)600 xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i)
601 {
602     xcb_generic_iterator_t ret;
603     ret.data = i.data + i.rem;
604     ret.index = i.index + ((char *) ret.data - (char *) i.data);
605     ret.rem = 0;
606     return ret;
607 }
608 
609 void
xcb_xkb_permament_overlay_behavior_next(xcb_xkb_permament_overlay_behavior_iterator_t * i)610 xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i)
611 {
612     --i->rem;
613     ++i->data;
614     i->index += sizeof(xcb_xkb_permament_overlay_behavior_t);
615 }
616 
617 xcb_generic_iterator_t
xcb_xkb_permament_overlay_behavior_end(xcb_xkb_permament_overlay_behavior_iterator_t i)618 xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i)
619 {
620     xcb_generic_iterator_t ret;
621     ret.data = i.data + i.rem;
622     ret.index = i.index + ((char *) ret.data - (char *) i.data);
623     ret.rem = 0;
624     return ret;
625 }
626 
627 void
xcb_xkb_behavior_next(xcb_xkb_behavior_iterator_t * i)628 xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i)
629 {
630     --i->rem;
631     ++i->data;
632     i->index += sizeof(xcb_xkb_behavior_t);
633 }
634 
635 xcb_generic_iterator_t
xcb_xkb_behavior_end(xcb_xkb_behavior_iterator_t i)636 xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i)
637 {
638     xcb_generic_iterator_t ret;
639     ret.data = i.data + i.rem;
640     ret.index = i.index + ((char *) ret.data - (char *) i.data);
641     ret.rem = 0;
642     return ret;
643 }
644 
645 void
xcb_xkb_set_behavior_next(xcb_xkb_set_behavior_iterator_t * i)646 xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i)
647 {
648     --i->rem;
649     ++i->data;
650     i->index += sizeof(xcb_xkb_set_behavior_t);
651 }
652 
653 xcb_generic_iterator_t
xcb_xkb_set_behavior_end(xcb_xkb_set_behavior_iterator_t i)654 xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i)
655 {
656     xcb_generic_iterator_t ret;
657     ret.data = i.data + i.rem;
658     ret.index = i.index + ((char *) ret.data - (char *) i.data);
659     ret.rem = 0;
660     return ret;
661 }
662 
663 void
xcb_xkb_set_explicit_next(xcb_xkb_set_explicit_iterator_t * i)664 xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i)
665 {
666     --i->rem;
667     ++i->data;
668     i->index += sizeof(xcb_xkb_set_explicit_t);
669 }
670 
671 xcb_generic_iterator_t
xcb_xkb_set_explicit_end(xcb_xkb_set_explicit_iterator_t i)672 xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i)
673 {
674     xcb_generic_iterator_t ret;
675     ret.data = i.data + i.rem;
676     ret.index = i.index + ((char *) ret.data - (char *) i.data);
677     ret.rem = 0;
678     return ret;
679 }
680 
681 void
xcb_xkb_key_mod_map_next(xcb_xkb_key_mod_map_iterator_t * i)682 xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i)
683 {
684     --i->rem;
685     ++i->data;
686     i->index += sizeof(xcb_xkb_key_mod_map_t);
687 }
688 
689 xcb_generic_iterator_t
xcb_xkb_key_mod_map_end(xcb_xkb_key_mod_map_iterator_t i)690 xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i)
691 {
692     xcb_generic_iterator_t ret;
693     ret.data = i.data + i.rem;
694     ret.index = i.index + ((char *) ret.data - (char *) i.data);
695     ret.rem = 0;
696     return ret;
697 }
698 
699 void
xcb_xkb_key_v_mod_map_next(xcb_xkb_key_v_mod_map_iterator_t * i)700 xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i)
701 {
702     --i->rem;
703     ++i->data;
704     i->index += sizeof(xcb_xkb_key_v_mod_map_t);
705 }
706 
707 xcb_generic_iterator_t
xcb_xkb_key_v_mod_map_end(xcb_xkb_key_v_mod_map_iterator_t i)708 xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i)
709 {
710     xcb_generic_iterator_t ret;
711     ret.data = i.data + i.rem;
712     ret.index = i.index + ((char *) ret.data - (char *) i.data);
713     ret.rem = 0;
714     return ret;
715 }
716 
717 void
xcb_xkb_kt_set_map_entry_next(xcb_xkb_kt_set_map_entry_iterator_t * i)718 xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i)
719 {
720     --i->rem;
721     ++i->data;
722     i->index += sizeof(xcb_xkb_kt_set_map_entry_t);
723 }
724 
725 xcb_generic_iterator_t
xcb_xkb_kt_set_map_entry_end(xcb_xkb_kt_set_map_entry_iterator_t i)726 xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i)
727 {
728     xcb_generic_iterator_t ret;
729     ret.data = i.data + i.rem;
730     ret.index = i.index + ((char *) ret.data - (char *) i.data);
731     ret.rem = 0;
732     return ret;
733 }
734 
735 int
xcb_xkb_set_key_type_sizeof(const void * _buffer)736 xcb_xkb_set_key_type_sizeof (const void  *_buffer)
737 {
738     char *xcb_tmp = (char *)_buffer;
739     const xcb_xkb_set_key_type_t *_aux = (xcb_xkb_set_key_type_t *)_buffer;
740     unsigned int xcb_buffer_len = 0;
741     unsigned int xcb_block_len = 0;
742     unsigned int xcb_pad = 0;
743     unsigned int xcb_align_to = 0;
744 
745 
746     xcb_block_len += sizeof(xcb_xkb_set_key_type_t);
747     xcb_tmp += xcb_block_len;
748     xcb_buffer_len += xcb_block_len;
749     xcb_block_len = 0;
750     /* entries */
751     xcb_block_len += _aux->nMapEntries * sizeof(xcb_xkb_kt_set_map_entry_t);
752     xcb_tmp += xcb_block_len;
753     xcb_align_to = ALIGNOF(xcb_xkb_kt_set_map_entry_t);
754     /* insert padding */
755     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
756     xcb_buffer_len += xcb_block_len + xcb_pad;
757     if (0 != xcb_pad) {
758         xcb_tmp += xcb_pad;
759         xcb_pad = 0;
760     }
761     xcb_block_len = 0;
762     /* preserve_entries */
763     xcb_block_len += (_aux->preserve * _aux->nMapEntries) * sizeof(xcb_xkb_kt_set_map_entry_t);
764     xcb_tmp += xcb_block_len;
765     xcb_align_to = ALIGNOF(xcb_xkb_kt_set_map_entry_t);
766     /* insert padding */
767     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
768     xcb_buffer_len += xcb_block_len + xcb_pad;
769     if (0 != xcb_pad) {
770         xcb_tmp += xcb_pad;
771         xcb_pad = 0;
772     }
773     xcb_block_len = 0;
774 
775     return xcb_buffer_len;
776 }
777 
778 xcb_xkb_kt_set_map_entry_t *
xcb_xkb_set_key_type_entries(const xcb_xkb_set_key_type_t * R)779 xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R)
780 {
781     return (xcb_xkb_kt_set_map_entry_t *) (R + 1);
782 }
783 
784 int
xcb_xkb_set_key_type_entries_length(const xcb_xkb_set_key_type_t * R)785 xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R)
786 {
787     return R->nMapEntries;
788 }
789 
790 xcb_xkb_kt_set_map_entry_iterator_t
xcb_xkb_set_key_type_entries_iterator(const xcb_xkb_set_key_type_t * R)791 xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R)
792 {
793     xcb_xkb_kt_set_map_entry_iterator_t i;
794     i.data = (xcb_xkb_kt_set_map_entry_t *) (R + 1);
795     i.rem = R->nMapEntries;
796     i.index = (char *) i.data - (char *) R;
797     return i;
798 }
799 
800 xcb_xkb_kt_set_map_entry_t *
xcb_xkb_set_key_type_preserve_entries(const xcb_xkb_set_key_type_t * R)801 xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R)
802 {
803     xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R));
804     return (xcb_xkb_kt_set_map_entry_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_kt_set_map_entry_t, prev.index) + 0);
805 }
806 
807 int
xcb_xkb_set_key_type_preserve_entries_length(const xcb_xkb_set_key_type_t * R)808 xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R)
809 {
810     return (R->preserve * R->nMapEntries);
811 }
812 
813 xcb_xkb_kt_set_map_entry_iterator_t
xcb_xkb_set_key_type_preserve_entries_iterator(const xcb_xkb_set_key_type_t * R)814 xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R)
815 {
816     xcb_xkb_kt_set_map_entry_iterator_t i;
817     xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R));
818     i.data = (xcb_xkb_kt_set_map_entry_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_kt_set_map_entry_t, prev.index));
819     i.rem = (R->preserve * R->nMapEntries);
820     i.index = (char *) i.data - (char *) R;
821     return i;
822 }
823 
824 void
xcb_xkb_set_key_type_next(xcb_xkb_set_key_type_iterator_t * i)825 xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i)
826 {
827     xcb_xkb_set_key_type_t *R = i->data;
828     xcb_generic_iterator_t child;
829     child.data = (xcb_xkb_set_key_type_t *)(((char *)R) + xcb_xkb_set_key_type_sizeof(R));
830     i->index = (char *) child.data - (char *) i->data;
831     --i->rem;
832     i->data = (xcb_xkb_set_key_type_t *) child.data;
833 }
834 
835 xcb_generic_iterator_t
xcb_xkb_set_key_type_end(xcb_xkb_set_key_type_iterator_t i)836 xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i)
837 {
838     xcb_generic_iterator_t ret;
839     while(i.rem > 0)
840         xcb_xkb_set_key_type_next(&i);
841     ret.data = i.data;
842     ret.rem = i.rem;
843     ret.index = i.index;
844     return ret;
845 }
846 
847 void
xcb_xkb_string8_next(xcb_xkb_string8_iterator_t * i)848 xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i)
849 {
850     --i->rem;
851     ++i->data;
852     i->index += sizeof(xcb_xkb_string8_t);
853 }
854 
855 xcb_generic_iterator_t
xcb_xkb_string8_end(xcb_xkb_string8_iterator_t i)856 xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i)
857 {
858     xcb_generic_iterator_t ret;
859     ret.data = i.data + i.rem;
860     ret.index = i.index + ((char *) ret.data - (char *) i.data);
861     ret.rem = 0;
862     return ret;
863 }
864 
865 int
xcb_xkb_outline_sizeof(const void * _buffer)866 xcb_xkb_outline_sizeof (const void  *_buffer)
867 {
868     char *xcb_tmp = (char *)_buffer;
869     const xcb_xkb_outline_t *_aux = (xcb_xkb_outline_t *)_buffer;
870     unsigned int xcb_buffer_len = 0;
871     unsigned int xcb_block_len = 0;
872     unsigned int xcb_pad = 0;
873     unsigned int xcb_align_to = 0;
874 
875 
876     xcb_block_len += sizeof(xcb_xkb_outline_t);
877     xcb_tmp += xcb_block_len;
878     xcb_buffer_len += xcb_block_len;
879     xcb_block_len = 0;
880     /* points */
881     xcb_block_len += _aux->nPoints * sizeof(xcb_point_t);
882     xcb_tmp += xcb_block_len;
883     xcb_align_to = ALIGNOF(xcb_point_t);
884     /* insert padding */
885     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
886     xcb_buffer_len += xcb_block_len + xcb_pad;
887     if (0 != xcb_pad) {
888         xcb_tmp += xcb_pad;
889         xcb_pad = 0;
890     }
891     xcb_block_len = 0;
892 
893     return xcb_buffer_len;
894 }
895 
896 xcb_point_t *
xcb_xkb_outline_points(const xcb_xkb_outline_t * R)897 xcb_xkb_outline_points (const xcb_xkb_outline_t *R)
898 {
899     return (xcb_point_t *) (R + 1);
900 }
901 
902 int
xcb_xkb_outline_points_length(const xcb_xkb_outline_t * R)903 xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R)
904 {
905     return R->nPoints;
906 }
907 
908 xcb_point_iterator_t
xcb_xkb_outline_points_iterator(const xcb_xkb_outline_t * R)909 xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R)
910 {
911     xcb_point_iterator_t i;
912     i.data = (xcb_point_t *) (R + 1);
913     i.rem = R->nPoints;
914     i.index = (char *) i.data - (char *) R;
915     return i;
916 }
917 
918 void
xcb_xkb_outline_next(xcb_xkb_outline_iterator_t * i)919 xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i)
920 {
921     xcb_xkb_outline_t *R = i->data;
922     xcb_generic_iterator_t child;
923     child.data = (xcb_xkb_outline_t *)(((char *)R) + xcb_xkb_outline_sizeof(R));
924     i->index = (char *) child.data - (char *) i->data;
925     --i->rem;
926     i->data = (xcb_xkb_outline_t *) child.data;
927 }
928 
929 xcb_generic_iterator_t
xcb_xkb_outline_end(xcb_xkb_outline_iterator_t i)930 xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i)
931 {
932     xcb_generic_iterator_t ret;
933     while(i.rem > 0)
934         xcb_xkb_outline_next(&i);
935     ret.data = i.data;
936     ret.rem = i.rem;
937     ret.index = i.index;
938     return ret;
939 }
940 
941 int
xcb_xkb_shape_sizeof(const void * _buffer)942 xcb_xkb_shape_sizeof (const void  *_buffer)
943 {
944     char *xcb_tmp = (char *)_buffer;
945     const xcb_xkb_shape_t *_aux = (xcb_xkb_shape_t *)_buffer;
946     unsigned int xcb_buffer_len = 0;
947     unsigned int xcb_block_len = 0;
948     unsigned int xcb_pad = 0;
949     unsigned int xcb_align_to = 0;
950 
951     unsigned int i;
952     unsigned int xcb_tmp_len;
953 
954     xcb_block_len += sizeof(xcb_xkb_shape_t);
955     xcb_tmp += xcb_block_len;
956     xcb_buffer_len += xcb_block_len;
957     xcb_block_len = 0;
958     /* outlines */
959     for(i=0; i<_aux->nOutlines; i++) {
960         xcb_tmp_len = xcb_xkb_outline_sizeof(xcb_tmp);
961         xcb_block_len += xcb_tmp_len;
962         xcb_tmp += xcb_tmp_len;
963     }
964     xcb_align_to = ALIGNOF(xcb_xkb_outline_t);
965     /* insert padding */
966     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
967     xcb_buffer_len += xcb_block_len + xcb_pad;
968     if (0 != xcb_pad) {
969         xcb_tmp += xcb_pad;
970         xcb_pad = 0;
971     }
972     xcb_block_len = 0;
973 
974     return xcb_buffer_len;
975 }
976 
977 int
xcb_xkb_shape_outlines_length(const xcb_xkb_shape_t * R)978 xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R)
979 {
980     return R->nOutlines;
981 }
982 
983 xcb_xkb_outline_iterator_t
xcb_xkb_shape_outlines_iterator(const xcb_xkb_shape_t * R)984 xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R)
985 {
986     xcb_xkb_outline_iterator_t i;
987     i.data = (xcb_xkb_outline_t *) (R + 1);
988     i.rem = R->nOutlines;
989     i.index = (char *) i.data - (char *) R;
990     return i;
991 }
992 
993 void
xcb_xkb_shape_next(xcb_xkb_shape_iterator_t * i)994 xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i)
995 {
996     xcb_xkb_shape_t *R = i->data;
997     xcb_generic_iterator_t child;
998     child.data = (xcb_xkb_shape_t *)(((char *)R) + xcb_xkb_shape_sizeof(R));
999     i->index = (char *) child.data - (char *) i->data;
1000     --i->rem;
1001     i->data = (xcb_xkb_shape_t *) child.data;
1002 }
1003 
1004 xcb_generic_iterator_t
xcb_xkb_shape_end(xcb_xkb_shape_iterator_t i)1005 xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i)
1006 {
1007     xcb_generic_iterator_t ret;
1008     while(i.rem > 0)
1009         xcb_xkb_shape_next(&i);
1010     ret.data = i.data;
1011     ret.rem = i.rem;
1012     ret.index = i.index;
1013     return ret;
1014 }
1015 
1016 void
xcb_xkb_key_next(xcb_xkb_key_iterator_t * i)1017 xcb_xkb_key_next (xcb_xkb_key_iterator_t *i)
1018 {
1019     --i->rem;
1020     ++i->data;
1021     i->index += sizeof(xcb_xkb_key_t);
1022 }
1023 
1024 xcb_generic_iterator_t
xcb_xkb_key_end(xcb_xkb_key_iterator_t i)1025 xcb_xkb_key_end (xcb_xkb_key_iterator_t i)
1026 {
1027     xcb_generic_iterator_t ret;
1028     ret.data = i.data + i.rem;
1029     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1030     ret.rem = 0;
1031     return ret;
1032 }
1033 
1034 void
xcb_xkb_overlay_key_next(xcb_xkb_overlay_key_iterator_t * i)1035 xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i)
1036 {
1037     --i->rem;
1038     ++i->data;
1039     i->index += sizeof(xcb_xkb_overlay_key_t);
1040 }
1041 
1042 xcb_generic_iterator_t
xcb_xkb_overlay_key_end(xcb_xkb_overlay_key_iterator_t i)1043 xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i)
1044 {
1045     xcb_generic_iterator_t ret;
1046     ret.data = i.data + i.rem;
1047     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1048     ret.rem = 0;
1049     return ret;
1050 }
1051 
1052 int
xcb_xkb_overlay_row_sizeof(const void * _buffer)1053 xcb_xkb_overlay_row_sizeof (const void  *_buffer)
1054 {
1055     char *xcb_tmp = (char *)_buffer;
1056     const xcb_xkb_overlay_row_t *_aux = (xcb_xkb_overlay_row_t *)_buffer;
1057     unsigned int xcb_buffer_len = 0;
1058     unsigned int xcb_block_len = 0;
1059     unsigned int xcb_pad = 0;
1060     unsigned int xcb_align_to = 0;
1061 
1062 
1063     xcb_block_len += sizeof(xcb_xkb_overlay_row_t);
1064     xcb_tmp += xcb_block_len;
1065     xcb_buffer_len += xcb_block_len;
1066     xcb_block_len = 0;
1067     /* keys */
1068     xcb_block_len += _aux->nKeys * sizeof(xcb_xkb_overlay_key_t);
1069     xcb_tmp += xcb_block_len;
1070     xcb_align_to = ALIGNOF(xcb_xkb_overlay_key_t);
1071     /* insert padding */
1072     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1073     xcb_buffer_len += xcb_block_len + xcb_pad;
1074     if (0 != xcb_pad) {
1075         xcb_tmp += xcb_pad;
1076         xcb_pad = 0;
1077     }
1078     xcb_block_len = 0;
1079 
1080     return xcb_buffer_len;
1081 }
1082 
1083 xcb_xkb_overlay_key_t *
xcb_xkb_overlay_row_keys(const xcb_xkb_overlay_row_t * R)1084 xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R)
1085 {
1086     return (xcb_xkb_overlay_key_t *) (R + 1);
1087 }
1088 
1089 int
xcb_xkb_overlay_row_keys_length(const xcb_xkb_overlay_row_t * R)1090 xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R)
1091 {
1092     return R->nKeys;
1093 }
1094 
1095 xcb_xkb_overlay_key_iterator_t
xcb_xkb_overlay_row_keys_iterator(const xcb_xkb_overlay_row_t * R)1096 xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R)
1097 {
1098     xcb_xkb_overlay_key_iterator_t i;
1099     i.data = (xcb_xkb_overlay_key_t *) (R + 1);
1100     i.rem = R->nKeys;
1101     i.index = (char *) i.data - (char *) R;
1102     return i;
1103 }
1104 
1105 void
xcb_xkb_overlay_row_next(xcb_xkb_overlay_row_iterator_t * i)1106 xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i)
1107 {
1108     xcb_xkb_overlay_row_t *R = i->data;
1109     xcb_generic_iterator_t child;
1110     child.data = (xcb_xkb_overlay_row_t *)(((char *)R) + xcb_xkb_overlay_row_sizeof(R));
1111     i->index = (char *) child.data - (char *) i->data;
1112     --i->rem;
1113     i->data = (xcb_xkb_overlay_row_t *) child.data;
1114 }
1115 
1116 xcb_generic_iterator_t
xcb_xkb_overlay_row_end(xcb_xkb_overlay_row_iterator_t i)1117 xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i)
1118 {
1119     xcb_generic_iterator_t ret;
1120     while(i.rem > 0)
1121         xcb_xkb_overlay_row_next(&i);
1122     ret.data = i.data;
1123     ret.rem = i.rem;
1124     ret.index = i.index;
1125     return ret;
1126 }
1127 
1128 int
xcb_xkb_overlay_sizeof(const void * _buffer)1129 xcb_xkb_overlay_sizeof (const void  *_buffer)
1130 {
1131     char *xcb_tmp = (char *)_buffer;
1132     const xcb_xkb_overlay_t *_aux = (xcb_xkb_overlay_t *)_buffer;
1133     unsigned int xcb_buffer_len = 0;
1134     unsigned int xcb_block_len = 0;
1135     unsigned int xcb_pad = 0;
1136     unsigned int xcb_align_to = 0;
1137 
1138     unsigned int i;
1139     unsigned int xcb_tmp_len;
1140 
1141     xcb_block_len += sizeof(xcb_xkb_overlay_t);
1142     xcb_tmp += xcb_block_len;
1143     xcb_buffer_len += xcb_block_len;
1144     xcb_block_len = 0;
1145     /* rows */
1146     for(i=0; i<_aux->nRows; i++) {
1147         xcb_tmp_len = xcb_xkb_overlay_row_sizeof(xcb_tmp);
1148         xcb_block_len += xcb_tmp_len;
1149         xcb_tmp += xcb_tmp_len;
1150     }
1151     xcb_align_to = ALIGNOF(xcb_xkb_overlay_row_t);
1152     /* insert padding */
1153     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1154     xcb_buffer_len += xcb_block_len + xcb_pad;
1155     if (0 != xcb_pad) {
1156         xcb_tmp += xcb_pad;
1157         xcb_pad = 0;
1158     }
1159     xcb_block_len = 0;
1160 
1161     return xcb_buffer_len;
1162 }
1163 
1164 int
xcb_xkb_overlay_rows_length(const xcb_xkb_overlay_t * R)1165 xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R)
1166 {
1167     return R->nRows;
1168 }
1169 
1170 xcb_xkb_overlay_row_iterator_t
xcb_xkb_overlay_rows_iterator(const xcb_xkb_overlay_t * R)1171 xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R)
1172 {
1173     xcb_xkb_overlay_row_iterator_t i;
1174     i.data = (xcb_xkb_overlay_row_t *) (R + 1);
1175     i.rem = R->nRows;
1176     i.index = (char *) i.data - (char *) R;
1177     return i;
1178 }
1179 
1180 void
xcb_xkb_overlay_next(xcb_xkb_overlay_iterator_t * i)1181 xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i)
1182 {
1183     xcb_xkb_overlay_t *R = i->data;
1184     xcb_generic_iterator_t child;
1185     child.data = (xcb_xkb_overlay_t *)(((char *)R) + xcb_xkb_overlay_sizeof(R));
1186     i->index = (char *) child.data - (char *) i->data;
1187     --i->rem;
1188     i->data = (xcb_xkb_overlay_t *) child.data;
1189 }
1190 
1191 xcb_generic_iterator_t
xcb_xkb_overlay_end(xcb_xkb_overlay_iterator_t i)1192 xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i)
1193 {
1194     xcb_generic_iterator_t ret;
1195     while(i.rem > 0)
1196         xcb_xkb_overlay_next(&i);
1197     ret.data = i.data;
1198     ret.rem = i.rem;
1199     ret.index = i.index;
1200     return ret;
1201 }
1202 
1203 int
xcb_xkb_row_sizeof(const void * _buffer)1204 xcb_xkb_row_sizeof (const void  *_buffer)
1205 {
1206     char *xcb_tmp = (char *)_buffer;
1207     const xcb_xkb_row_t *_aux = (xcb_xkb_row_t *)_buffer;
1208     unsigned int xcb_buffer_len = 0;
1209     unsigned int xcb_block_len = 0;
1210     unsigned int xcb_pad = 0;
1211     unsigned int xcb_align_to = 0;
1212 
1213 
1214     xcb_block_len += sizeof(xcb_xkb_row_t);
1215     xcb_tmp += xcb_block_len;
1216     xcb_buffer_len += xcb_block_len;
1217     xcb_block_len = 0;
1218     /* keys */
1219     xcb_block_len += _aux->nKeys * sizeof(xcb_xkb_key_t);
1220     xcb_tmp += xcb_block_len;
1221     xcb_align_to = ALIGNOF(xcb_xkb_key_t);
1222     /* insert padding */
1223     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1224     xcb_buffer_len += xcb_block_len + xcb_pad;
1225     if (0 != xcb_pad) {
1226         xcb_tmp += xcb_pad;
1227         xcb_pad = 0;
1228     }
1229     xcb_block_len = 0;
1230 
1231     return xcb_buffer_len;
1232 }
1233 
1234 xcb_xkb_key_t *
xcb_xkb_row_keys(const xcb_xkb_row_t * R)1235 xcb_xkb_row_keys (const xcb_xkb_row_t *R)
1236 {
1237     return (xcb_xkb_key_t *) (R + 1);
1238 }
1239 
1240 int
xcb_xkb_row_keys_length(const xcb_xkb_row_t * R)1241 xcb_xkb_row_keys_length (const xcb_xkb_row_t *R)
1242 {
1243     return R->nKeys;
1244 }
1245 
1246 xcb_xkb_key_iterator_t
xcb_xkb_row_keys_iterator(const xcb_xkb_row_t * R)1247 xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R)
1248 {
1249     xcb_xkb_key_iterator_t i;
1250     i.data = (xcb_xkb_key_t *) (R + 1);
1251     i.rem = R->nKeys;
1252     i.index = (char *) i.data - (char *) R;
1253     return i;
1254 }
1255 
1256 void
xcb_xkb_row_next(xcb_xkb_row_iterator_t * i)1257 xcb_xkb_row_next (xcb_xkb_row_iterator_t *i)
1258 {
1259     xcb_xkb_row_t *R = i->data;
1260     xcb_generic_iterator_t child;
1261     child.data = (xcb_xkb_row_t *)(((char *)R) + xcb_xkb_row_sizeof(R));
1262     i->index = (char *) child.data - (char *) i->data;
1263     --i->rem;
1264     i->data = (xcb_xkb_row_t *) child.data;
1265 }
1266 
1267 xcb_generic_iterator_t
xcb_xkb_row_end(xcb_xkb_row_iterator_t i)1268 xcb_xkb_row_end (xcb_xkb_row_iterator_t i)
1269 {
1270     xcb_generic_iterator_t ret;
1271     while(i.rem > 0)
1272         xcb_xkb_row_next(&i);
1273     ret.data = i.data;
1274     ret.rem = i.rem;
1275     ret.index = i.index;
1276     return ret;
1277 }
1278 
1279 int
xcb_xkb_listing_sizeof(const void * _buffer)1280 xcb_xkb_listing_sizeof (const void  *_buffer)
1281 {
1282     char *xcb_tmp = (char *)_buffer;
1283     const xcb_xkb_listing_t *_aux = (xcb_xkb_listing_t *)_buffer;
1284     unsigned int xcb_buffer_len = 0;
1285     unsigned int xcb_block_len = 0;
1286     unsigned int xcb_pad = 0;
1287     unsigned int xcb_align_to = 0;
1288 
1289 
1290     xcb_block_len += sizeof(xcb_xkb_listing_t);
1291     xcb_tmp += xcb_block_len;
1292     xcb_buffer_len += xcb_block_len;
1293     xcb_block_len = 0;
1294     /* string */
1295     xcb_block_len += _aux->length * sizeof(xcb_xkb_string8_t);
1296     xcb_tmp += xcb_block_len;
1297     xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
1298     xcb_align_to = 2;
1299     /* insert padding */
1300     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1301     xcb_buffer_len += xcb_block_len + xcb_pad;
1302     if (0 != xcb_pad) {
1303         xcb_tmp += xcb_pad;
1304         xcb_pad = 0;
1305     }
1306     xcb_block_len = 0;
1307     /* insert padding */
1308     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1309     xcb_buffer_len += xcb_block_len + xcb_pad;
1310     if (0 != xcb_pad) {
1311         xcb_tmp += xcb_pad;
1312         xcb_pad = 0;
1313     }
1314     xcb_block_len = 0;
1315 
1316     return xcb_buffer_len;
1317 }
1318 
1319 xcb_xkb_string8_t *
xcb_xkb_listing_string(const xcb_xkb_listing_t * R)1320 xcb_xkb_listing_string (const xcb_xkb_listing_t *R)
1321 {
1322     return (xcb_xkb_string8_t *) (R + 1);
1323 }
1324 
1325 int
xcb_xkb_listing_string_length(const xcb_xkb_listing_t * R)1326 xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R)
1327 {
1328     return R->length;
1329 }
1330 
1331 xcb_generic_iterator_t
xcb_xkb_listing_string_end(const xcb_xkb_listing_t * R)1332 xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R)
1333 {
1334     xcb_generic_iterator_t i;
1335     i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->length);
1336     i.rem = 0;
1337     i.index = (char *) i.data - (char *) R;
1338     return i;
1339 }
1340 
1341 void
xcb_xkb_listing_next(xcb_xkb_listing_iterator_t * i)1342 xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i)
1343 {
1344     xcb_xkb_listing_t *R = i->data;
1345     xcb_generic_iterator_t child;
1346     child.data = (xcb_xkb_listing_t *)(((char *)R) + xcb_xkb_listing_sizeof(R));
1347     i->index = (char *) child.data - (char *) i->data;
1348     --i->rem;
1349     i->data = (xcb_xkb_listing_t *) child.data;
1350 }
1351 
1352 xcb_generic_iterator_t
xcb_xkb_listing_end(xcb_xkb_listing_iterator_t i)1353 xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i)
1354 {
1355     xcb_generic_iterator_t ret;
1356     while(i.rem > 0)
1357         xcb_xkb_listing_next(&i);
1358     ret.data = i.data;
1359     ret.rem = i.rem;
1360     ret.index = i.index;
1361     return ret;
1362 }
1363 
1364 int
xcb_xkb_device_led_info_sizeof(const void * _buffer)1365 xcb_xkb_device_led_info_sizeof (const void  *_buffer)
1366 {
1367     char *xcb_tmp = (char *)_buffer;
1368     const xcb_xkb_device_led_info_t *_aux = (xcb_xkb_device_led_info_t *)_buffer;
1369     unsigned int xcb_buffer_len = 0;
1370     unsigned int xcb_block_len = 0;
1371     unsigned int xcb_pad = 0;
1372     unsigned int xcb_align_to = 0;
1373 
1374 
1375     xcb_block_len += sizeof(xcb_xkb_device_led_info_t);
1376     xcb_tmp += xcb_block_len;
1377     xcb_buffer_len += xcb_block_len;
1378     xcb_block_len = 0;
1379     /* names */
1380     xcb_block_len += xcb_popcount(_aux->namesPresent) * sizeof(uint32_t);
1381     xcb_tmp += xcb_block_len;
1382     xcb_align_to = ALIGNOF(xcb_atom_t);
1383     /* insert padding */
1384     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1385     xcb_buffer_len += xcb_block_len + xcb_pad;
1386     if (0 != xcb_pad) {
1387         xcb_tmp += xcb_pad;
1388         xcb_pad = 0;
1389     }
1390     xcb_block_len = 0;
1391     /* maps */
1392     xcb_block_len += xcb_popcount(_aux->mapsPresent) * sizeof(xcb_xkb_indicator_map_t);
1393     xcb_tmp += xcb_block_len;
1394     xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
1395     /* insert padding */
1396     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1397     xcb_buffer_len += xcb_block_len + xcb_pad;
1398     if (0 != xcb_pad) {
1399         xcb_tmp += xcb_pad;
1400         xcb_pad = 0;
1401     }
1402     xcb_block_len = 0;
1403 
1404     return xcb_buffer_len;
1405 }
1406 
1407 xcb_atom_t *
xcb_xkb_device_led_info_names(const xcb_xkb_device_led_info_t * R)1408 xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R)
1409 {
1410     return (xcb_atom_t *) (R + 1);
1411 }
1412 
1413 int
xcb_xkb_device_led_info_names_length(const xcb_xkb_device_led_info_t * R)1414 xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R)
1415 {
1416     return xcb_popcount(R->namesPresent);
1417 }
1418 
1419 xcb_generic_iterator_t
xcb_xkb_device_led_info_names_end(const xcb_xkb_device_led_info_t * R)1420 xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R)
1421 {
1422     xcb_generic_iterator_t i;
1423     i.data = ((xcb_atom_t *) (R + 1)) + (xcb_popcount(R->namesPresent));
1424     i.rem = 0;
1425     i.index = (char *) i.data - (char *) R;
1426     return i;
1427 }
1428 
1429 xcb_xkb_indicator_map_t *
xcb_xkb_device_led_info_maps(const xcb_xkb_device_led_info_t * R)1430 xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R)
1431 {
1432     xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R);
1433     return (xcb_xkb_indicator_map_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_indicator_map_t, prev.index) + 0);
1434 }
1435 
1436 int
xcb_xkb_device_led_info_maps_length(const xcb_xkb_device_led_info_t * R)1437 xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R)
1438 {
1439     return xcb_popcount(R->mapsPresent);
1440 }
1441 
1442 xcb_xkb_indicator_map_iterator_t
xcb_xkb_device_led_info_maps_iterator(const xcb_xkb_device_led_info_t * R)1443 xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R)
1444 {
1445     xcb_xkb_indicator_map_iterator_t i;
1446     xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R);
1447     i.data = (xcb_xkb_indicator_map_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_indicator_map_t, prev.index));
1448     i.rem = xcb_popcount(R->mapsPresent);
1449     i.index = (char *) i.data - (char *) R;
1450     return i;
1451 }
1452 
1453 void
xcb_xkb_device_led_info_next(xcb_xkb_device_led_info_iterator_t * i)1454 xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i)
1455 {
1456     xcb_xkb_device_led_info_t *R = i->data;
1457     xcb_generic_iterator_t child;
1458     child.data = (xcb_xkb_device_led_info_t *)(((char *)R) + xcb_xkb_device_led_info_sizeof(R));
1459     i->index = (char *) child.data - (char *) i->data;
1460     --i->rem;
1461     i->data = (xcb_xkb_device_led_info_t *) child.data;
1462 }
1463 
1464 xcb_generic_iterator_t
xcb_xkb_device_led_info_end(xcb_xkb_device_led_info_iterator_t i)1465 xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i)
1466 {
1467     xcb_generic_iterator_t ret;
1468     while(i.rem > 0)
1469         xcb_xkb_device_led_info_next(&i);
1470     ret.data = i.data;
1471     ret.rem = i.rem;
1472     ret.index = i.index;
1473     return ret;
1474 }
1475 
1476 void
xcb_xkb_sa_no_action_next(xcb_xkb_sa_no_action_iterator_t * i)1477 xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i)
1478 {
1479     --i->rem;
1480     ++i->data;
1481     i->index += sizeof(xcb_xkb_sa_no_action_t);
1482 }
1483 
1484 xcb_generic_iterator_t
xcb_xkb_sa_no_action_end(xcb_xkb_sa_no_action_iterator_t i)1485 xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i)
1486 {
1487     xcb_generic_iterator_t ret;
1488     ret.data = i.data + i.rem;
1489     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1490     ret.rem = 0;
1491     return ret;
1492 }
1493 
1494 void
xcb_xkb_sa_set_mods_next(xcb_xkb_sa_set_mods_iterator_t * i)1495 xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i)
1496 {
1497     --i->rem;
1498     ++i->data;
1499     i->index += sizeof(xcb_xkb_sa_set_mods_t);
1500 }
1501 
1502 xcb_generic_iterator_t
xcb_xkb_sa_set_mods_end(xcb_xkb_sa_set_mods_iterator_t i)1503 xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i)
1504 {
1505     xcb_generic_iterator_t ret;
1506     ret.data = i.data + i.rem;
1507     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1508     ret.rem = 0;
1509     return ret;
1510 }
1511 
1512 void
xcb_xkb_sa_latch_mods_next(xcb_xkb_sa_latch_mods_iterator_t * i)1513 xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i)
1514 {
1515     --i->rem;
1516     ++i->data;
1517     i->index += sizeof(xcb_xkb_sa_latch_mods_t);
1518 }
1519 
1520 xcb_generic_iterator_t
xcb_xkb_sa_latch_mods_end(xcb_xkb_sa_latch_mods_iterator_t i)1521 xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i)
1522 {
1523     xcb_generic_iterator_t ret;
1524     ret.data = i.data + i.rem;
1525     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1526     ret.rem = 0;
1527     return ret;
1528 }
1529 
1530 void
xcb_xkb_sa_lock_mods_next(xcb_xkb_sa_lock_mods_iterator_t * i)1531 xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i)
1532 {
1533     --i->rem;
1534     ++i->data;
1535     i->index += sizeof(xcb_xkb_sa_lock_mods_t);
1536 }
1537 
1538 xcb_generic_iterator_t
xcb_xkb_sa_lock_mods_end(xcb_xkb_sa_lock_mods_iterator_t i)1539 xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i)
1540 {
1541     xcb_generic_iterator_t ret;
1542     ret.data = i.data + i.rem;
1543     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1544     ret.rem = 0;
1545     return ret;
1546 }
1547 
1548 void
xcb_xkb_sa_set_group_next(xcb_xkb_sa_set_group_iterator_t * i)1549 xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i)
1550 {
1551     --i->rem;
1552     ++i->data;
1553     i->index += sizeof(xcb_xkb_sa_set_group_t);
1554 }
1555 
1556 xcb_generic_iterator_t
xcb_xkb_sa_set_group_end(xcb_xkb_sa_set_group_iterator_t i)1557 xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i)
1558 {
1559     xcb_generic_iterator_t ret;
1560     ret.data = i.data + i.rem;
1561     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1562     ret.rem = 0;
1563     return ret;
1564 }
1565 
1566 void
xcb_xkb_sa_latch_group_next(xcb_xkb_sa_latch_group_iterator_t * i)1567 xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i)
1568 {
1569     --i->rem;
1570     ++i->data;
1571     i->index += sizeof(xcb_xkb_sa_latch_group_t);
1572 }
1573 
1574 xcb_generic_iterator_t
xcb_xkb_sa_latch_group_end(xcb_xkb_sa_latch_group_iterator_t i)1575 xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i)
1576 {
1577     xcb_generic_iterator_t ret;
1578     ret.data = i.data + i.rem;
1579     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1580     ret.rem = 0;
1581     return ret;
1582 }
1583 
1584 void
xcb_xkb_sa_lock_group_next(xcb_xkb_sa_lock_group_iterator_t * i)1585 xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i)
1586 {
1587     --i->rem;
1588     ++i->data;
1589     i->index += sizeof(xcb_xkb_sa_lock_group_t);
1590 }
1591 
1592 xcb_generic_iterator_t
xcb_xkb_sa_lock_group_end(xcb_xkb_sa_lock_group_iterator_t i)1593 xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i)
1594 {
1595     xcb_generic_iterator_t ret;
1596     ret.data = i.data + i.rem;
1597     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1598     ret.rem = 0;
1599     return ret;
1600 }
1601 
1602 void
xcb_xkb_sa_move_ptr_next(xcb_xkb_sa_move_ptr_iterator_t * i)1603 xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i)
1604 {
1605     --i->rem;
1606     ++i->data;
1607     i->index += sizeof(xcb_xkb_sa_move_ptr_t);
1608 }
1609 
1610 xcb_generic_iterator_t
xcb_xkb_sa_move_ptr_end(xcb_xkb_sa_move_ptr_iterator_t i)1611 xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i)
1612 {
1613     xcb_generic_iterator_t ret;
1614     ret.data = i.data + i.rem;
1615     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1616     ret.rem = 0;
1617     return ret;
1618 }
1619 
1620 void
xcb_xkb_sa_ptr_btn_next(xcb_xkb_sa_ptr_btn_iterator_t * i)1621 xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i)
1622 {
1623     --i->rem;
1624     ++i->data;
1625     i->index += sizeof(xcb_xkb_sa_ptr_btn_t);
1626 }
1627 
1628 xcb_generic_iterator_t
xcb_xkb_sa_ptr_btn_end(xcb_xkb_sa_ptr_btn_iterator_t i)1629 xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i)
1630 {
1631     xcb_generic_iterator_t ret;
1632     ret.data = i.data + i.rem;
1633     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1634     ret.rem = 0;
1635     return ret;
1636 }
1637 
1638 void
xcb_xkb_sa_lock_ptr_btn_next(xcb_xkb_sa_lock_ptr_btn_iterator_t * i)1639 xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i)
1640 {
1641     --i->rem;
1642     ++i->data;
1643     i->index += sizeof(xcb_xkb_sa_lock_ptr_btn_t);
1644 }
1645 
1646 xcb_generic_iterator_t
xcb_xkb_sa_lock_ptr_btn_end(xcb_xkb_sa_lock_ptr_btn_iterator_t i)1647 xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i)
1648 {
1649     xcb_generic_iterator_t ret;
1650     ret.data = i.data + i.rem;
1651     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1652     ret.rem = 0;
1653     return ret;
1654 }
1655 
1656 void
xcb_xkb_sa_set_ptr_dflt_next(xcb_xkb_sa_set_ptr_dflt_iterator_t * i)1657 xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i)
1658 {
1659     --i->rem;
1660     ++i->data;
1661     i->index += sizeof(xcb_xkb_sa_set_ptr_dflt_t);
1662 }
1663 
1664 xcb_generic_iterator_t
xcb_xkb_sa_set_ptr_dflt_end(xcb_xkb_sa_set_ptr_dflt_iterator_t i)1665 xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i)
1666 {
1667     xcb_generic_iterator_t ret;
1668     ret.data = i.data + i.rem;
1669     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1670     ret.rem = 0;
1671     return ret;
1672 }
1673 
1674 void
xcb_xkb_sa_iso_lock_next(xcb_xkb_sa_iso_lock_iterator_t * i)1675 xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i)
1676 {
1677     --i->rem;
1678     ++i->data;
1679     i->index += sizeof(xcb_xkb_sa_iso_lock_t);
1680 }
1681 
1682 xcb_generic_iterator_t
xcb_xkb_sa_iso_lock_end(xcb_xkb_sa_iso_lock_iterator_t i)1683 xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i)
1684 {
1685     xcb_generic_iterator_t ret;
1686     ret.data = i.data + i.rem;
1687     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1688     ret.rem = 0;
1689     return ret;
1690 }
1691 
1692 void
xcb_xkb_sa_terminate_next(xcb_xkb_sa_terminate_iterator_t * i)1693 xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i)
1694 {
1695     --i->rem;
1696     ++i->data;
1697     i->index += sizeof(xcb_xkb_sa_terminate_t);
1698 }
1699 
1700 xcb_generic_iterator_t
xcb_xkb_sa_terminate_end(xcb_xkb_sa_terminate_iterator_t i)1701 xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i)
1702 {
1703     xcb_generic_iterator_t ret;
1704     ret.data = i.data + i.rem;
1705     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1706     ret.rem = 0;
1707     return ret;
1708 }
1709 
1710 void
xcb_xkb_sa_switch_screen_next(xcb_xkb_sa_switch_screen_iterator_t * i)1711 xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i)
1712 {
1713     --i->rem;
1714     ++i->data;
1715     i->index += sizeof(xcb_xkb_sa_switch_screen_t);
1716 }
1717 
1718 xcb_generic_iterator_t
xcb_xkb_sa_switch_screen_end(xcb_xkb_sa_switch_screen_iterator_t i)1719 xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i)
1720 {
1721     xcb_generic_iterator_t ret;
1722     ret.data = i.data + i.rem;
1723     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1724     ret.rem = 0;
1725     return ret;
1726 }
1727 
1728 void
xcb_xkb_sa_set_controls_next(xcb_xkb_sa_set_controls_iterator_t * i)1729 xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i)
1730 {
1731     --i->rem;
1732     ++i->data;
1733     i->index += sizeof(xcb_xkb_sa_set_controls_t);
1734 }
1735 
1736 xcb_generic_iterator_t
xcb_xkb_sa_set_controls_end(xcb_xkb_sa_set_controls_iterator_t i)1737 xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i)
1738 {
1739     xcb_generic_iterator_t ret;
1740     ret.data = i.data + i.rem;
1741     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1742     ret.rem = 0;
1743     return ret;
1744 }
1745 
1746 void
xcb_xkb_sa_lock_controls_next(xcb_xkb_sa_lock_controls_iterator_t * i)1747 xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i)
1748 {
1749     --i->rem;
1750     ++i->data;
1751     i->index += sizeof(xcb_xkb_sa_lock_controls_t);
1752 }
1753 
1754 xcb_generic_iterator_t
xcb_xkb_sa_lock_controls_end(xcb_xkb_sa_lock_controls_iterator_t i)1755 xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i)
1756 {
1757     xcb_generic_iterator_t ret;
1758     ret.data = i.data + i.rem;
1759     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1760     ret.rem = 0;
1761     return ret;
1762 }
1763 
1764 void
xcb_xkb_sa_action_message_next(xcb_xkb_sa_action_message_iterator_t * i)1765 xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i)
1766 {
1767     --i->rem;
1768     ++i->data;
1769     i->index += sizeof(xcb_xkb_sa_action_message_t);
1770 }
1771 
1772 xcb_generic_iterator_t
xcb_xkb_sa_action_message_end(xcb_xkb_sa_action_message_iterator_t i)1773 xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i)
1774 {
1775     xcb_generic_iterator_t ret;
1776     ret.data = i.data + i.rem;
1777     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1778     ret.rem = 0;
1779     return ret;
1780 }
1781 
1782 void
xcb_xkb_sa_redirect_key_next(xcb_xkb_sa_redirect_key_iterator_t * i)1783 xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i)
1784 {
1785     --i->rem;
1786     ++i->data;
1787     i->index += sizeof(xcb_xkb_sa_redirect_key_t);
1788 }
1789 
1790 xcb_generic_iterator_t
xcb_xkb_sa_redirect_key_end(xcb_xkb_sa_redirect_key_iterator_t i)1791 xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i)
1792 {
1793     xcb_generic_iterator_t ret;
1794     ret.data = i.data + i.rem;
1795     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1796     ret.rem = 0;
1797     return ret;
1798 }
1799 
1800 void
xcb_xkb_sa_device_btn_next(xcb_xkb_sa_device_btn_iterator_t * i)1801 xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i)
1802 {
1803     --i->rem;
1804     ++i->data;
1805     i->index += sizeof(xcb_xkb_sa_device_btn_t);
1806 }
1807 
1808 xcb_generic_iterator_t
xcb_xkb_sa_device_btn_end(xcb_xkb_sa_device_btn_iterator_t i)1809 xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i)
1810 {
1811     xcb_generic_iterator_t ret;
1812     ret.data = i.data + i.rem;
1813     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1814     ret.rem = 0;
1815     return ret;
1816 }
1817 
1818 void
xcb_xkb_sa_lock_device_btn_next(xcb_xkb_sa_lock_device_btn_iterator_t * i)1819 xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i)
1820 {
1821     --i->rem;
1822     ++i->data;
1823     i->index += sizeof(xcb_xkb_sa_lock_device_btn_t);
1824 }
1825 
1826 xcb_generic_iterator_t
xcb_xkb_sa_lock_device_btn_end(xcb_xkb_sa_lock_device_btn_iterator_t i)1827 xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i)
1828 {
1829     xcb_generic_iterator_t ret;
1830     ret.data = i.data + i.rem;
1831     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1832     ret.rem = 0;
1833     return ret;
1834 }
1835 
1836 void
xcb_xkb_sa_device_valuator_next(xcb_xkb_sa_device_valuator_iterator_t * i)1837 xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i)
1838 {
1839     --i->rem;
1840     ++i->data;
1841     i->index += sizeof(xcb_xkb_sa_device_valuator_t);
1842 }
1843 
1844 xcb_generic_iterator_t
xcb_xkb_sa_device_valuator_end(xcb_xkb_sa_device_valuator_iterator_t i)1845 xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i)
1846 {
1847     xcb_generic_iterator_t ret;
1848     ret.data = i.data + i.rem;
1849     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1850     ret.rem = 0;
1851     return ret;
1852 }
1853 
1854 void
xcb_xkb_si_action_next(xcb_xkb_si_action_iterator_t * i)1855 xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i)
1856 {
1857     --i->rem;
1858     ++i->data;
1859     i->index += sizeof(xcb_xkb_si_action_t);
1860 }
1861 
1862 xcb_generic_iterator_t
xcb_xkb_si_action_end(xcb_xkb_si_action_iterator_t i)1863 xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i)
1864 {
1865     xcb_generic_iterator_t ret;
1866     ret.data = i.data + i.rem;
1867     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1868     ret.rem = 0;
1869     return ret;
1870 }
1871 
1872 void
xcb_xkb_sym_interpret_next(xcb_xkb_sym_interpret_iterator_t * i)1873 xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i)
1874 {
1875     --i->rem;
1876     ++i->data;
1877     i->index += sizeof(xcb_xkb_sym_interpret_t);
1878 }
1879 
1880 xcb_generic_iterator_t
xcb_xkb_sym_interpret_end(xcb_xkb_sym_interpret_iterator_t i)1881 xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i)
1882 {
1883     xcb_generic_iterator_t ret;
1884     ret.data = i.data + i.rem;
1885     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1886     ret.rem = 0;
1887     return ret;
1888 }
1889 
1890 void
xcb_xkb_action_next(xcb_xkb_action_iterator_t * i)1891 xcb_xkb_action_next (xcb_xkb_action_iterator_t *i)
1892 {
1893     --i->rem;
1894     ++i->data;
1895     i->index += sizeof(xcb_xkb_action_t);
1896 }
1897 
1898 xcb_generic_iterator_t
xcb_xkb_action_end(xcb_xkb_action_iterator_t i)1899 xcb_xkb_action_end (xcb_xkb_action_iterator_t i)
1900 {
1901     xcb_generic_iterator_t ret;
1902     ret.data = i.data + i.rem;
1903     ret.index = i.index + ((char *) ret.data - (char *) i.data);
1904     ret.rem = 0;
1905     return ret;
1906 }
1907 
1908 xcb_xkb_use_extension_cookie_t
xcb_xkb_use_extension(xcb_connection_t * c,uint16_t wantedMajor,uint16_t wantedMinor)1909 xcb_xkb_use_extension (xcb_connection_t *c,
1910                        uint16_t          wantedMajor,
1911                        uint16_t          wantedMinor)
1912 {
1913     static const xcb_protocol_request_t xcb_req = {
1914         .count = 2,
1915         .ext = &xcb_xkb_id,
1916         .opcode = XCB_XKB_USE_EXTENSION,
1917         .isvoid = 0
1918     };
1919 
1920     struct iovec xcb_parts[4];
1921     xcb_xkb_use_extension_cookie_t xcb_ret;
1922     xcb_xkb_use_extension_request_t xcb_out;
1923 
1924     xcb_out.wantedMajor = wantedMajor;
1925     xcb_out.wantedMinor = wantedMinor;
1926 
1927     xcb_parts[2].iov_base = (char *) &xcb_out;
1928     xcb_parts[2].iov_len = sizeof(xcb_out);
1929     xcb_parts[3].iov_base = 0;
1930     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1931 
1932     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1933     return xcb_ret;
1934 }
1935 
1936 xcb_xkb_use_extension_cookie_t
xcb_xkb_use_extension_unchecked(xcb_connection_t * c,uint16_t wantedMajor,uint16_t wantedMinor)1937 xcb_xkb_use_extension_unchecked (xcb_connection_t *c,
1938                                  uint16_t          wantedMajor,
1939                                  uint16_t          wantedMinor)
1940 {
1941     static const xcb_protocol_request_t xcb_req = {
1942         .count = 2,
1943         .ext = &xcb_xkb_id,
1944         .opcode = XCB_XKB_USE_EXTENSION,
1945         .isvoid = 0
1946     };
1947 
1948     struct iovec xcb_parts[4];
1949     xcb_xkb_use_extension_cookie_t xcb_ret;
1950     xcb_xkb_use_extension_request_t xcb_out;
1951 
1952     xcb_out.wantedMajor = wantedMajor;
1953     xcb_out.wantedMinor = wantedMinor;
1954 
1955     xcb_parts[2].iov_base = (char *) &xcb_out;
1956     xcb_parts[2].iov_len = sizeof(xcb_out);
1957     xcb_parts[3].iov_base = 0;
1958     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1959 
1960     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1961     return xcb_ret;
1962 }
1963 
1964 xcb_xkb_use_extension_reply_t *
xcb_xkb_use_extension_reply(xcb_connection_t * c,xcb_xkb_use_extension_cookie_t cookie,xcb_generic_error_t ** e)1965 xcb_xkb_use_extension_reply (xcb_connection_t                *c,
1966                              xcb_xkb_use_extension_cookie_t   cookie  /**< */,
1967                              xcb_generic_error_t            **e)
1968 {
1969     return (xcb_xkb_use_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1970 }
1971 
1972 int
xcb_xkb_select_events_details_serialize(void ** _buffer,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,const xcb_xkb_select_events_details_t * _aux)1973 xcb_xkb_select_events_details_serialize (void                                  **_buffer,
1974                                          uint16_t                                affectWhich,
1975                                          uint16_t                                clear,
1976                                          uint16_t                                selectAll,
1977                                          const xcb_xkb_select_events_details_t  *_aux)
1978 {
1979     char *xcb_out = *_buffer;
1980     unsigned int xcb_buffer_len = 0;
1981     unsigned int xcb_align_to = 0;
1982     unsigned int xcb_padding_offset = 0;
1983 
1984     unsigned int xcb_pad = 0;
1985     char xcb_pad0[3] = {0, 0, 0};
1986     struct iovec xcb_parts[23];
1987     unsigned int xcb_parts_idx = 0;
1988     unsigned int xcb_block_len = 0;
1989     unsigned int i;
1990     char *xcb_tmp;
1991 
1992     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY) {
1993         /* xcb_xkb_select_events_details_t.affectNewKeyboard */
1994         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectNewKeyboard;
1995         xcb_block_len += sizeof(uint16_t);
1996         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
1997         xcb_parts_idx++;
1998         xcb_align_to = ALIGNOF(uint16_t);
1999         /* xcb_xkb_select_events_details_t.newKeyboardDetails */
2000         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->newKeyboardDetails;
2001         xcb_block_len += sizeof(uint16_t);
2002         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2003         xcb_parts_idx++;
2004         xcb_align_to = ALIGNOF(uint16_t);
2005     }
2006     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_STATE_NOTIFY) {
2007         /* xcb_xkb_select_events_details_t.affectState */
2008         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectState;
2009         xcb_block_len += sizeof(uint16_t);
2010         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2011         xcb_parts_idx++;
2012         xcb_align_to = ALIGNOF(uint16_t);
2013         /* xcb_xkb_select_events_details_t.stateDetails */
2014         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stateDetails;
2015         xcb_block_len += sizeof(uint16_t);
2016         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2017         xcb_parts_idx++;
2018         xcb_align_to = ALIGNOF(uint16_t);
2019     }
2020     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_CONTROLS_NOTIFY) {
2021         /* xcb_xkb_select_events_details_t.affectCtrls */
2022         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectCtrls;
2023         xcb_block_len += sizeof(uint32_t);
2024         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2025         xcb_parts_idx++;
2026         xcb_align_to = ALIGNOF(uint32_t);
2027         /* xcb_xkb_select_events_details_t.ctrlDetails */
2028         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->ctrlDetails;
2029         xcb_block_len += sizeof(uint32_t);
2030         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2031         xcb_parts_idx++;
2032         xcb_align_to = ALIGNOF(uint32_t);
2033     }
2034     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_STATE_NOTIFY) {
2035         /* xcb_xkb_select_events_details_t.affectIndicatorState */
2036         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectIndicatorState;
2037         xcb_block_len += sizeof(uint32_t);
2038         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2039         xcb_parts_idx++;
2040         xcb_align_to = ALIGNOF(uint32_t);
2041         /* xcb_xkb_select_events_details_t.indicatorStateDetails */
2042         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicatorStateDetails;
2043         xcb_block_len += sizeof(uint32_t);
2044         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2045         xcb_parts_idx++;
2046         xcb_align_to = ALIGNOF(uint32_t);
2047     }
2048     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_MAP_NOTIFY) {
2049         /* xcb_xkb_select_events_details_t.affectIndicatorMap */
2050         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectIndicatorMap;
2051         xcb_block_len += sizeof(uint32_t);
2052         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2053         xcb_parts_idx++;
2054         xcb_align_to = ALIGNOF(uint32_t);
2055         /* xcb_xkb_select_events_details_t.indicatorMapDetails */
2056         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicatorMapDetails;
2057         xcb_block_len += sizeof(uint32_t);
2058         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
2059         xcb_parts_idx++;
2060         xcb_align_to = ALIGNOF(uint32_t);
2061     }
2062     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NAMES_NOTIFY) {
2063         /* xcb_xkb_select_events_details_t.affectNames */
2064         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectNames;
2065         xcb_block_len += sizeof(uint16_t);
2066         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2067         xcb_parts_idx++;
2068         xcb_align_to = ALIGNOF(uint16_t);
2069         /* xcb_xkb_select_events_details_t.namesDetails */
2070         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->namesDetails;
2071         xcb_block_len += sizeof(uint16_t);
2072         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2073         xcb_parts_idx++;
2074         xcb_align_to = ALIGNOF(uint16_t);
2075     }
2076     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_COMPAT_MAP_NOTIFY) {
2077         /* xcb_xkb_select_events_details_t.affectCompat */
2078         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectCompat;
2079         xcb_block_len += sizeof(uint8_t);
2080         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2081         xcb_parts_idx++;
2082         xcb_align_to = ALIGNOF(uint8_t);
2083         /* xcb_xkb_select_events_details_t.compatDetails */
2084         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatDetails;
2085         xcb_block_len += sizeof(uint8_t);
2086         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2087         xcb_parts_idx++;
2088         xcb_align_to = ALIGNOF(uint8_t);
2089     }
2090     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_BELL_NOTIFY) {
2091         /* xcb_xkb_select_events_details_t.affectBell */
2092         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectBell;
2093         xcb_block_len += sizeof(uint8_t);
2094         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2095         xcb_parts_idx++;
2096         xcb_align_to = ALIGNOF(uint8_t);
2097         /* xcb_xkb_select_events_details_t.bellDetails */
2098         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bellDetails;
2099         xcb_block_len += sizeof(uint8_t);
2100         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2101         xcb_parts_idx++;
2102         xcb_align_to = ALIGNOF(uint8_t);
2103     }
2104     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACTION_MESSAGE) {
2105         /* xcb_xkb_select_events_details_t.affectMsgDetails */
2106         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectMsgDetails;
2107         xcb_block_len += sizeof(uint8_t);
2108         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2109         xcb_parts_idx++;
2110         xcb_align_to = ALIGNOF(uint8_t);
2111         /* xcb_xkb_select_events_details_t.msgDetails */
2112         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->msgDetails;
2113         xcb_block_len += sizeof(uint8_t);
2114         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
2115         xcb_parts_idx++;
2116         xcb_align_to = ALIGNOF(uint8_t);
2117     }
2118     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACCESS_X_NOTIFY) {
2119         /* xcb_xkb_select_events_details_t.affectAccessX */
2120         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectAccessX;
2121         xcb_block_len += sizeof(uint16_t);
2122         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2123         xcb_parts_idx++;
2124         xcb_align_to = ALIGNOF(uint16_t);
2125         /* xcb_xkb_select_events_details_t.accessXDetails */
2126         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->accessXDetails;
2127         xcb_block_len += sizeof(uint16_t);
2128         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2129         xcb_parts_idx++;
2130         xcb_align_to = ALIGNOF(uint16_t);
2131     }
2132     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_EXTENSION_DEVICE_NOTIFY) {
2133         /* xcb_xkb_select_events_details_t.affectExtDev */
2134         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectExtDev;
2135         xcb_block_len += sizeof(uint16_t);
2136         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2137         xcb_parts_idx++;
2138         xcb_align_to = ALIGNOF(uint16_t);
2139         /* xcb_xkb_select_events_details_t.extdevDetails */
2140         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->extdevDetails;
2141         xcb_block_len += sizeof(uint16_t);
2142         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
2143         xcb_parts_idx++;
2144         xcb_align_to = ALIGNOF(uint16_t);
2145     }
2146     /* insert padding */
2147     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
2148     xcb_buffer_len += xcb_block_len + xcb_pad;
2149     if (0 != xcb_pad) {
2150         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
2151         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
2152         xcb_parts_idx++;
2153         xcb_pad = 0;
2154     }
2155     xcb_block_len = 0;
2156     xcb_padding_offset = 0;
2157 
2158     if (NULL == xcb_out) {
2159         /* allocate memory */
2160         xcb_out = malloc(xcb_buffer_len);
2161         *_buffer = xcb_out;
2162     }
2163 
2164     xcb_tmp = xcb_out;
2165     for(i=0; i<xcb_parts_idx; i++) {
2166         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
2167             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
2168         if (0 != xcb_parts[i].iov_len)
2169             xcb_tmp += xcb_parts[i].iov_len;
2170     }
2171 
2172     return xcb_buffer_len;
2173 }
2174 
2175 int
xcb_xkb_select_events_details_unpack(const void * _buffer,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,xcb_xkb_select_events_details_t * _aux)2176 xcb_xkb_select_events_details_unpack (const void                       *_buffer,
2177                                       uint16_t                          affectWhich,
2178                                       uint16_t                          clear,
2179                                       uint16_t                          selectAll,
2180                                       xcb_xkb_select_events_details_t  *_aux)
2181 {
2182     char *xcb_tmp = (char *)_buffer;
2183     unsigned int xcb_buffer_len = 0;
2184     unsigned int xcb_block_len = 0;
2185     unsigned int xcb_pad = 0;
2186     unsigned int xcb_align_to = 0;
2187     unsigned int xcb_padding_offset = 0;
2188 
2189 
2190     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY) {
2191         /* xcb_xkb_select_events_details_t.affectNewKeyboard */
2192         _aux->affectNewKeyboard = *(uint16_t *)xcb_tmp;
2193         xcb_block_len += sizeof(uint16_t);
2194         xcb_tmp += sizeof(uint16_t);
2195         xcb_align_to = ALIGNOF(uint16_t);
2196         /* xcb_xkb_select_events_details_t.newKeyboardDetails */
2197         _aux->newKeyboardDetails = *(uint16_t *)xcb_tmp;
2198         xcb_block_len += sizeof(uint16_t);
2199         xcb_tmp += sizeof(uint16_t);
2200         xcb_align_to = ALIGNOF(uint16_t);
2201     }
2202     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_STATE_NOTIFY) {
2203         /* xcb_xkb_select_events_details_t.affectState */
2204         _aux->affectState = *(uint16_t *)xcb_tmp;
2205         xcb_block_len += sizeof(uint16_t);
2206         xcb_tmp += sizeof(uint16_t);
2207         xcb_align_to = ALIGNOF(uint16_t);
2208         /* xcb_xkb_select_events_details_t.stateDetails */
2209         _aux->stateDetails = *(uint16_t *)xcb_tmp;
2210         xcb_block_len += sizeof(uint16_t);
2211         xcb_tmp += sizeof(uint16_t);
2212         xcb_align_to = ALIGNOF(uint16_t);
2213     }
2214     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_CONTROLS_NOTIFY) {
2215         /* xcb_xkb_select_events_details_t.affectCtrls */
2216         _aux->affectCtrls = *(uint32_t *)xcb_tmp;
2217         xcb_block_len += sizeof(uint32_t);
2218         xcb_tmp += sizeof(uint32_t);
2219         xcb_align_to = ALIGNOF(uint32_t);
2220         /* xcb_xkb_select_events_details_t.ctrlDetails */
2221         _aux->ctrlDetails = *(uint32_t *)xcb_tmp;
2222         xcb_block_len += sizeof(uint32_t);
2223         xcb_tmp += sizeof(uint32_t);
2224         xcb_align_to = ALIGNOF(uint32_t);
2225     }
2226     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_STATE_NOTIFY) {
2227         /* xcb_xkb_select_events_details_t.affectIndicatorState */
2228         _aux->affectIndicatorState = *(uint32_t *)xcb_tmp;
2229         xcb_block_len += sizeof(uint32_t);
2230         xcb_tmp += sizeof(uint32_t);
2231         xcb_align_to = ALIGNOF(uint32_t);
2232         /* xcb_xkb_select_events_details_t.indicatorStateDetails */
2233         _aux->indicatorStateDetails = *(uint32_t *)xcb_tmp;
2234         xcb_block_len += sizeof(uint32_t);
2235         xcb_tmp += sizeof(uint32_t);
2236         xcb_align_to = ALIGNOF(uint32_t);
2237     }
2238     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_MAP_NOTIFY) {
2239         /* xcb_xkb_select_events_details_t.affectIndicatorMap */
2240         _aux->affectIndicatorMap = *(uint32_t *)xcb_tmp;
2241         xcb_block_len += sizeof(uint32_t);
2242         xcb_tmp += sizeof(uint32_t);
2243         xcb_align_to = ALIGNOF(uint32_t);
2244         /* xcb_xkb_select_events_details_t.indicatorMapDetails */
2245         _aux->indicatorMapDetails = *(uint32_t *)xcb_tmp;
2246         xcb_block_len += sizeof(uint32_t);
2247         xcb_tmp += sizeof(uint32_t);
2248         xcb_align_to = ALIGNOF(uint32_t);
2249     }
2250     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NAMES_NOTIFY) {
2251         /* xcb_xkb_select_events_details_t.affectNames */
2252         _aux->affectNames = *(uint16_t *)xcb_tmp;
2253         xcb_block_len += sizeof(uint16_t);
2254         xcb_tmp += sizeof(uint16_t);
2255         xcb_align_to = ALIGNOF(uint16_t);
2256         /* xcb_xkb_select_events_details_t.namesDetails */
2257         _aux->namesDetails = *(uint16_t *)xcb_tmp;
2258         xcb_block_len += sizeof(uint16_t);
2259         xcb_tmp += sizeof(uint16_t);
2260         xcb_align_to = ALIGNOF(uint16_t);
2261     }
2262     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_COMPAT_MAP_NOTIFY) {
2263         /* xcb_xkb_select_events_details_t.affectCompat */
2264         _aux->affectCompat = *(uint8_t *)xcb_tmp;
2265         xcb_block_len += sizeof(uint8_t);
2266         xcb_tmp += sizeof(uint8_t);
2267         xcb_align_to = ALIGNOF(uint8_t);
2268         /* xcb_xkb_select_events_details_t.compatDetails */
2269         _aux->compatDetails = *(uint8_t *)xcb_tmp;
2270         xcb_block_len += sizeof(uint8_t);
2271         xcb_tmp += sizeof(uint8_t);
2272         xcb_align_to = ALIGNOF(uint8_t);
2273     }
2274     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_BELL_NOTIFY) {
2275         /* xcb_xkb_select_events_details_t.affectBell */
2276         _aux->affectBell = *(uint8_t *)xcb_tmp;
2277         xcb_block_len += sizeof(uint8_t);
2278         xcb_tmp += sizeof(uint8_t);
2279         xcb_align_to = ALIGNOF(uint8_t);
2280         /* xcb_xkb_select_events_details_t.bellDetails */
2281         _aux->bellDetails = *(uint8_t *)xcb_tmp;
2282         xcb_block_len += sizeof(uint8_t);
2283         xcb_tmp += sizeof(uint8_t);
2284         xcb_align_to = ALIGNOF(uint8_t);
2285     }
2286     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACTION_MESSAGE) {
2287         /* xcb_xkb_select_events_details_t.affectMsgDetails */
2288         _aux->affectMsgDetails = *(uint8_t *)xcb_tmp;
2289         xcb_block_len += sizeof(uint8_t);
2290         xcb_tmp += sizeof(uint8_t);
2291         xcb_align_to = ALIGNOF(uint8_t);
2292         /* xcb_xkb_select_events_details_t.msgDetails */
2293         _aux->msgDetails = *(uint8_t *)xcb_tmp;
2294         xcb_block_len += sizeof(uint8_t);
2295         xcb_tmp += sizeof(uint8_t);
2296         xcb_align_to = ALIGNOF(uint8_t);
2297     }
2298     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACCESS_X_NOTIFY) {
2299         /* xcb_xkb_select_events_details_t.affectAccessX */
2300         _aux->affectAccessX = *(uint16_t *)xcb_tmp;
2301         xcb_block_len += sizeof(uint16_t);
2302         xcb_tmp += sizeof(uint16_t);
2303         xcb_align_to = ALIGNOF(uint16_t);
2304         /* xcb_xkb_select_events_details_t.accessXDetails */
2305         _aux->accessXDetails = *(uint16_t *)xcb_tmp;
2306         xcb_block_len += sizeof(uint16_t);
2307         xcb_tmp += sizeof(uint16_t);
2308         xcb_align_to = ALIGNOF(uint16_t);
2309     }
2310     if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_EXTENSION_DEVICE_NOTIFY) {
2311         /* xcb_xkb_select_events_details_t.affectExtDev */
2312         _aux->affectExtDev = *(uint16_t *)xcb_tmp;
2313         xcb_block_len += sizeof(uint16_t);
2314         xcb_tmp += sizeof(uint16_t);
2315         xcb_align_to = ALIGNOF(uint16_t);
2316         /* xcb_xkb_select_events_details_t.extdevDetails */
2317         _aux->extdevDetails = *(uint16_t *)xcb_tmp;
2318         xcb_block_len += sizeof(uint16_t);
2319         xcb_tmp += sizeof(uint16_t);
2320         xcb_align_to = ALIGNOF(uint16_t);
2321     }
2322     /* insert padding */
2323     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
2324     xcb_buffer_len += xcb_block_len + xcb_pad;
2325     if (0 != xcb_pad) {
2326         xcb_tmp += xcb_pad;
2327         xcb_pad = 0;
2328     }
2329     xcb_block_len = 0;
2330     xcb_padding_offset = 0;
2331 
2332     return xcb_buffer_len;
2333 }
2334 
2335 int
xcb_xkb_select_events_details_sizeof(const void * _buffer,uint16_t affectWhich,uint16_t clear,uint16_t selectAll)2336 xcb_xkb_select_events_details_sizeof (const void  *_buffer,
2337                                       uint16_t     affectWhich,
2338                                       uint16_t     clear,
2339                                       uint16_t     selectAll)
2340 {
2341     xcb_xkb_select_events_details_t _aux;
2342     return xcb_xkb_select_events_details_unpack(_buffer, affectWhich, clear, selectAll, &_aux);
2343 }
2344 
2345 int
xcb_xkb_select_events_sizeof(const void * _buffer)2346 xcb_xkb_select_events_sizeof (const void  *_buffer)
2347 {
2348     char *xcb_tmp = (char *)_buffer;
2349     const xcb_xkb_select_events_request_t *_aux = (xcb_xkb_select_events_request_t *)_buffer;
2350     unsigned int xcb_buffer_len = 0;
2351     unsigned int xcb_block_len = 0;
2352     unsigned int xcb_pad = 0;
2353     unsigned int xcb_align_to = 0;
2354 
2355 
2356     xcb_block_len += sizeof(xcb_xkb_select_events_request_t);
2357     xcb_tmp += xcb_block_len;
2358     xcb_buffer_len += xcb_block_len;
2359     xcb_block_len = 0;
2360     /* details */
2361     xcb_block_len += xcb_xkb_select_events_details_sizeof(xcb_tmp, _aux->affectWhich, _aux->clear, _aux->selectAll);
2362     xcb_tmp += xcb_block_len;
2363     xcb_align_to = ALIGNOF(char);
2364     /* insert padding */
2365     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2366     xcb_buffer_len += xcb_block_len + xcb_pad;
2367     if (0 != xcb_pad) {
2368         xcb_tmp += xcb_pad;
2369         xcb_pad = 0;
2370     }
2371     xcb_block_len = 0;
2372 
2373     return xcb_buffer_len;
2374 }
2375 
2376 xcb_void_cookie_t
xcb_xkb_select_events_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,uint16_t affectMap,uint16_t map,const void * details)2377 xcb_xkb_select_events_checked (xcb_connection_t      *c,
2378                                xcb_xkb_device_spec_t  deviceSpec,
2379                                uint16_t               affectWhich,
2380                                uint16_t               clear,
2381                                uint16_t               selectAll,
2382                                uint16_t               affectMap,
2383                                uint16_t               map,
2384                                const void            *details)
2385 {
2386     static const xcb_protocol_request_t xcb_req = {
2387         .count = 3,
2388         .ext = &xcb_xkb_id,
2389         .opcode = XCB_XKB_SELECT_EVENTS,
2390         .isvoid = 1
2391     };
2392 
2393     struct iovec xcb_parts[5];
2394     xcb_void_cookie_t xcb_ret;
2395     xcb_xkb_select_events_request_t xcb_out;
2396 
2397     xcb_out.deviceSpec = deviceSpec;
2398     xcb_out.affectWhich = affectWhich;
2399     xcb_out.clear = clear;
2400     xcb_out.selectAll = selectAll;
2401     xcb_out.affectMap = affectMap;
2402     xcb_out.map = map;
2403 
2404     xcb_parts[2].iov_base = (char *) &xcb_out;
2405     xcb_parts[2].iov_len = sizeof(xcb_out);
2406     xcb_parts[3].iov_base = 0;
2407     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2408     /* xcb_xkb_select_events_details_t details */
2409     xcb_parts[4].iov_base = (char *) details;
2410     xcb_parts[4].iov_len =
2411       xcb_xkb_select_events_details_sizeof (details, affectWhich, clear, selectAll);
2412 
2413     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2414     return xcb_ret;
2415 }
2416 
2417 xcb_void_cookie_t
xcb_xkb_select_events(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,uint16_t affectMap,uint16_t map,const void * details)2418 xcb_xkb_select_events (xcb_connection_t      *c,
2419                        xcb_xkb_device_spec_t  deviceSpec,
2420                        uint16_t               affectWhich,
2421                        uint16_t               clear,
2422                        uint16_t               selectAll,
2423                        uint16_t               affectMap,
2424                        uint16_t               map,
2425                        const void            *details)
2426 {
2427     static const xcb_protocol_request_t xcb_req = {
2428         .count = 3,
2429         .ext = &xcb_xkb_id,
2430         .opcode = XCB_XKB_SELECT_EVENTS,
2431         .isvoid = 1
2432     };
2433 
2434     struct iovec xcb_parts[5];
2435     xcb_void_cookie_t xcb_ret;
2436     xcb_xkb_select_events_request_t xcb_out;
2437 
2438     xcb_out.deviceSpec = deviceSpec;
2439     xcb_out.affectWhich = affectWhich;
2440     xcb_out.clear = clear;
2441     xcb_out.selectAll = selectAll;
2442     xcb_out.affectMap = affectMap;
2443     xcb_out.map = map;
2444 
2445     xcb_parts[2].iov_base = (char *) &xcb_out;
2446     xcb_parts[2].iov_len = sizeof(xcb_out);
2447     xcb_parts[3].iov_base = 0;
2448     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2449     /* xcb_xkb_select_events_details_t details */
2450     xcb_parts[4].iov_base = (char *) details;
2451     xcb_parts[4].iov_len =
2452       xcb_xkb_select_events_details_sizeof (details, affectWhich, clear, selectAll);
2453 
2454     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2455     return xcb_ret;
2456 }
2457 
2458 xcb_void_cookie_t
xcb_xkb_select_events_aux_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,uint16_t affectMap,uint16_t map,const xcb_xkb_select_events_details_t * details)2459 xcb_xkb_select_events_aux_checked (xcb_connection_t                      *c,
2460                                    xcb_xkb_device_spec_t                  deviceSpec,
2461                                    uint16_t                               affectWhich,
2462                                    uint16_t                               clear,
2463                                    uint16_t                               selectAll,
2464                                    uint16_t                               affectMap,
2465                                    uint16_t                               map,
2466                                    const xcb_xkb_select_events_details_t *details)
2467 {
2468     static const xcb_protocol_request_t xcb_req = {
2469         .count = 3,
2470         .ext = &xcb_xkb_id,
2471         .opcode = XCB_XKB_SELECT_EVENTS,
2472         .isvoid = 1
2473     };
2474 
2475     struct iovec xcb_parts[5];
2476     xcb_void_cookie_t xcb_ret;
2477     xcb_xkb_select_events_request_t xcb_out;
2478     void *xcb_aux0 = 0;
2479 
2480     xcb_out.deviceSpec = deviceSpec;
2481     xcb_out.affectWhich = affectWhich;
2482     xcb_out.clear = clear;
2483     xcb_out.selectAll = selectAll;
2484     xcb_out.affectMap = affectMap;
2485     xcb_out.map = map;
2486 
2487     xcb_parts[2].iov_base = (char *) &xcb_out;
2488     xcb_parts[2].iov_len = sizeof(xcb_out);
2489     xcb_parts[3].iov_base = 0;
2490     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2491     /* xcb_xkb_select_events_details_t details */
2492     xcb_parts[4].iov_len =
2493       xcb_xkb_select_events_details_serialize (&xcb_aux0, affectWhich, clear, selectAll, details);
2494     xcb_parts[4].iov_base = xcb_aux0;
2495 
2496     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2497     free(xcb_aux0);
2498     return xcb_ret;
2499 }
2500 
2501 xcb_void_cookie_t
xcb_xkb_select_events_aux(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t affectWhich,uint16_t clear,uint16_t selectAll,uint16_t affectMap,uint16_t map,const xcb_xkb_select_events_details_t * details)2502 xcb_xkb_select_events_aux (xcb_connection_t                      *c,
2503                            xcb_xkb_device_spec_t                  deviceSpec,
2504                            uint16_t                               affectWhich,
2505                            uint16_t                               clear,
2506                            uint16_t                               selectAll,
2507                            uint16_t                               affectMap,
2508                            uint16_t                               map,
2509                            const xcb_xkb_select_events_details_t *details)
2510 {
2511     static const xcb_protocol_request_t xcb_req = {
2512         .count = 3,
2513         .ext = &xcb_xkb_id,
2514         .opcode = XCB_XKB_SELECT_EVENTS,
2515         .isvoid = 1
2516     };
2517 
2518     struct iovec xcb_parts[5];
2519     xcb_void_cookie_t xcb_ret;
2520     xcb_xkb_select_events_request_t xcb_out;
2521     void *xcb_aux0 = 0;
2522 
2523     xcb_out.deviceSpec = deviceSpec;
2524     xcb_out.affectWhich = affectWhich;
2525     xcb_out.clear = clear;
2526     xcb_out.selectAll = selectAll;
2527     xcb_out.affectMap = affectMap;
2528     xcb_out.map = map;
2529 
2530     xcb_parts[2].iov_base = (char *) &xcb_out;
2531     xcb_parts[2].iov_len = sizeof(xcb_out);
2532     xcb_parts[3].iov_base = 0;
2533     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2534     /* xcb_xkb_select_events_details_t details */
2535     xcb_parts[4].iov_len =
2536       xcb_xkb_select_events_details_serialize (&xcb_aux0, affectWhich, clear, selectAll, details);
2537     xcb_parts[4].iov_base = xcb_aux0;
2538 
2539     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2540     free(xcb_aux0);
2541     return xcb_ret;
2542 }
2543 
2544 void *
xcb_xkb_select_events_details(const xcb_xkb_select_events_request_t * R)2545 xcb_xkb_select_events_details (const xcb_xkb_select_events_request_t *R)
2546 {
2547     return (void *) (R + 1);
2548 }
2549 
2550 xcb_void_cookie_t
xcb_xkb_bell_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_bell_class_spec_t bellClass,xcb_xkb_id_spec_t bellID,int8_t percent,uint8_t forceSound,uint8_t eventOnly,int16_t pitch,int16_t duration,xcb_atom_t name,xcb_window_t window)2551 xcb_xkb_bell_checked (xcb_connection_t          *c,
2552                       xcb_xkb_device_spec_t      deviceSpec,
2553                       xcb_xkb_bell_class_spec_t  bellClass,
2554                       xcb_xkb_id_spec_t          bellID,
2555                       int8_t                     percent,
2556                       uint8_t                    forceSound,
2557                       uint8_t                    eventOnly,
2558                       int16_t                    pitch,
2559                       int16_t                    duration,
2560                       xcb_atom_t                 name,
2561                       xcb_window_t               window)
2562 {
2563     static const xcb_protocol_request_t xcb_req = {
2564         .count = 2,
2565         .ext = &xcb_xkb_id,
2566         .opcode = XCB_XKB_BELL,
2567         .isvoid = 1
2568     };
2569 
2570     struct iovec xcb_parts[4];
2571     xcb_void_cookie_t xcb_ret;
2572     xcb_xkb_bell_request_t xcb_out;
2573 
2574     xcb_out.deviceSpec = deviceSpec;
2575     xcb_out.bellClass = bellClass;
2576     xcb_out.bellID = bellID;
2577     xcb_out.percent = percent;
2578     xcb_out.forceSound = forceSound;
2579     xcb_out.eventOnly = eventOnly;
2580     xcb_out.pad0 = 0;
2581     xcb_out.pitch = pitch;
2582     xcb_out.duration = duration;
2583     memset(xcb_out.pad1, 0, 2);
2584     xcb_out.name = name;
2585     xcb_out.window = window;
2586 
2587     xcb_parts[2].iov_base = (char *) &xcb_out;
2588     xcb_parts[2].iov_len = sizeof(xcb_out);
2589     xcb_parts[3].iov_base = 0;
2590     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2591 
2592     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2593     return xcb_ret;
2594 }
2595 
2596 xcb_void_cookie_t
xcb_xkb_bell(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_bell_class_spec_t bellClass,xcb_xkb_id_spec_t bellID,int8_t percent,uint8_t forceSound,uint8_t eventOnly,int16_t pitch,int16_t duration,xcb_atom_t name,xcb_window_t window)2597 xcb_xkb_bell (xcb_connection_t          *c,
2598               xcb_xkb_device_spec_t      deviceSpec,
2599               xcb_xkb_bell_class_spec_t  bellClass,
2600               xcb_xkb_id_spec_t          bellID,
2601               int8_t                     percent,
2602               uint8_t                    forceSound,
2603               uint8_t                    eventOnly,
2604               int16_t                    pitch,
2605               int16_t                    duration,
2606               xcb_atom_t                 name,
2607               xcb_window_t               window)
2608 {
2609     static const xcb_protocol_request_t xcb_req = {
2610         .count = 2,
2611         .ext = &xcb_xkb_id,
2612         .opcode = XCB_XKB_BELL,
2613         .isvoid = 1
2614     };
2615 
2616     struct iovec xcb_parts[4];
2617     xcb_void_cookie_t xcb_ret;
2618     xcb_xkb_bell_request_t xcb_out;
2619 
2620     xcb_out.deviceSpec = deviceSpec;
2621     xcb_out.bellClass = bellClass;
2622     xcb_out.bellID = bellID;
2623     xcb_out.percent = percent;
2624     xcb_out.forceSound = forceSound;
2625     xcb_out.eventOnly = eventOnly;
2626     xcb_out.pad0 = 0;
2627     xcb_out.pitch = pitch;
2628     xcb_out.duration = duration;
2629     memset(xcb_out.pad1, 0, 2);
2630     xcb_out.name = name;
2631     xcb_out.window = window;
2632 
2633     xcb_parts[2].iov_base = (char *) &xcb_out;
2634     xcb_parts[2].iov_len = sizeof(xcb_out);
2635     xcb_parts[3].iov_base = 0;
2636     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2637 
2638     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2639     return xcb_ret;
2640 }
2641 
2642 xcb_xkb_get_state_cookie_t
xcb_xkb_get_state(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)2643 xcb_xkb_get_state (xcb_connection_t      *c,
2644                    xcb_xkb_device_spec_t  deviceSpec)
2645 {
2646     static const xcb_protocol_request_t xcb_req = {
2647         .count = 2,
2648         .ext = &xcb_xkb_id,
2649         .opcode = XCB_XKB_GET_STATE,
2650         .isvoid = 0
2651     };
2652 
2653     struct iovec xcb_parts[4];
2654     xcb_xkb_get_state_cookie_t xcb_ret;
2655     xcb_xkb_get_state_request_t xcb_out;
2656 
2657     xcb_out.deviceSpec = deviceSpec;
2658     memset(xcb_out.pad0, 0, 2);
2659 
2660     xcb_parts[2].iov_base = (char *) &xcb_out;
2661     xcb_parts[2].iov_len = sizeof(xcb_out);
2662     xcb_parts[3].iov_base = 0;
2663     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2664 
2665     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2666     return xcb_ret;
2667 }
2668 
2669 xcb_xkb_get_state_cookie_t
xcb_xkb_get_state_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)2670 xcb_xkb_get_state_unchecked (xcb_connection_t      *c,
2671                              xcb_xkb_device_spec_t  deviceSpec)
2672 {
2673     static const xcb_protocol_request_t xcb_req = {
2674         .count = 2,
2675         .ext = &xcb_xkb_id,
2676         .opcode = XCB_XKB_GET_STATE,
2677         .isvoid = 0
2678     };
2679 
2680     struct iovec xcb_parts[4];
2681     xcb_xkb_get_state_cookie_t xcb_ret;
2682     xcb_xkb_get_state_request_t xcb_out;
2683 
2684     xcb_out.deviceSpec = deviceSpec;
2685     memset(xcb_out.pad0, 0, 2);
2686 
2687     xcb_parts[2].iov_base = (char *) &xcb_out;
2688     xcb_parts[2].iov_len = sizeof(xcb_out);
2689     xcb_parts[3].iov_base = 0;
2690     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2691 
2692     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2693     return xcb_ret;
2694 }
2695 
2696 xcb_xkb_get_state_reply_t *
xcb_xkb_get_state_reply(xcb_connection_t * c,xcb_xkb_get_state_cookie_t cookie,xcb_generic_error_t ** e)2697 xcb_xkb_get_state_reply (xcb_connection_t            *c,
2698                          xcb_xkb_get_state_cookie_t   cookie  /**< */,
2699                          xcb_generic_error_t        **e)
2700 {
2701     return (xcb_xkb_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2702 }
2703 
2704 xcb_void_cookie_t
xcb_xkb_latch_lock_state_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t affectModLocks,uint8_t modLocks,uint8_t lockGroup,uint8_t groupLock,uint8_t affectModLatches,uint8_t latchGroup,uint16_t groupLatch)2705 xcb_xkb_latch_lock_state_checked (xcb_connection_t      *c,
2706                                   xcb_xkb_device_spec_t  deviceSpec,
2707                                   uint8_t                affectModLocks,
2708                                   uint8_t                modLocks,
2709                                   uint8_t                lockGroup,
2710                                   uint8_t                groupLock,
2711                                   uint8_t                affectModLatches,
2712                                   uint8_t                latchGroup,
2713                                   uint16_t               groupLatch)
2714 {
2715     static const xcb_protocol_request_t xcb_req = {
2716         .count = 2,
2717         .ext = &xcb_xkb_id,
2718         .opcode = XCB_XKB_LATCH_LOCK_STATE,
2719         .isvoid = 1
2720     };
2721 
2722     struct iovec xcb_parts[4];
2723     xcb_void_cookie_t xcb_ret;
2724     xcb_xkb_latch_lock_state_request_t xcb_out;
2725 
2726     xcb_out.deviceSpec = deviceSpec;
2727     xcb_out.affectModLocks = affectModLocks;
2728     xcb_out.modLocks = modLocks;
2729     xcb_out.lockGroup = lockGroup;
2730     xcb_out.groupLock = groupLock;
2731     xcb_out.affectModLatches = affectModLatches;
2732     xcb_out.pad0 = 0;
2733     xcb_out.pad1 = 0;
2734     xcb_out.latchGroup = latchGroup;
2735     xcb_out.groupLatch = groupLatch;
2736 
2737     xcb_parts[2].iov_base = (char *) &xcb_out;
2738     xcb_parts[2].iov_len = sizeof(xcb_out);
2739     xcb_parts[3].iov_base = 0;
2740     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2741 
2742     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2743     return xcb_ret;
2744 }
2745 
2746 xcb_void_cookie_t
xcb_xkb_latch_lock_state(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t affectModLocks,uint8_t modLocks,uint8_t lockGroup,uint8_t groupLock,uint8_t affectModLatches,uint8_t latchGroup,uint16_t groupLatch)2747 xcb_xkb_latch_lock_state (xcb_connection_t      *c,
2748                           xcb_xkb_device_spec_t  deviceSpec,
2749                           uint8_t                affectModLocks,
2750                           uint8_t                modLocks,
2751                           uint8_t                lockGroup,
2752                           uint8_t                groupLock,
2753                           uint8_t                affectModLatches,
2754                           uint8_t                latchGroup,
2755                           uint16_t               groupLatch)
2756 {
2757     static const xcb_protocol_request_t xcb_req = {
2758         .count = 2,
2759         .ext = &xcb_xkb_id,
2760         .opcode = XCB_XKB_LATCH_LOCK_STATE,
2761         .isvoid = 1
2762     };
2763 
2764     struct iovec xcb_parts[4];
2765     xcb_void_cookie_t xcb_ret;
2766     xcb_xkb_latch_lock_state_request_t xcb_out;
2767 
2768     xcb_out.deviceSpec = deviceSpec;
2769     xcb_out.affectModLocks = affectModLocks;
2770     xcb_out.modLocks = modLocks;
2771     xcb_out.lockGroup = lockGroup;
2772     xcb_out.groupLock = groupLock;
2773     xcb_out.affectModLatches = affectModLatches;
2774     xcb_out.pad0 = 0;
2775     xcb_out.pad1 = 0;
2776     xcb_out.latchGroup = latchGroup;
2777     xcb_out.groupLatch = groupLatch;
2778 
2779     xcb_parts[2].iov_base = (char *) &xcb_out;
2780     xcb_parts[2].iov_len = sizeof(xcb_out);
2781     xcb_parts[3].iov_base = 0;
2782     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2783 
2784     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2785     return xcb_ret;
2786 }
2787 
2788 xcb_xkb_get_controls_cookie_t
xcb_xkb_get_controls(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)2789 xcb_xkb_get_controls (xcb_connection_t      *c,
2790                       xcb_xkb_device_spec_t  deviceSpec)
2791 {
2792     static const xcb_protocol_request_t xcb_req = {
2793         .count = 2,
2794         .ext = &xcb_xkb_id,
2795         .opcode = XCB_XKB_GET_CONTROLS,
2796         .isvoid = 0
2797     };
2798 
2799     struct iovec xcb_parts[4];
2800     xcb_xkb_get_controls_cookie_t xcb_ret;
2801     xcb_xkb_get_controls_request_t xcb_out;
2802 
2803     xcb_out.deviceSpec = deviceSpec;
2804     memset(xcb_out.pad0, 0, 2);
2805 
2806     xcb_parts[2].iov_base = (char *) &xcb_out;
2807     xcb_parts[2].iov_len = sizeof(xcb_out);
2808     xcb_parts[3].iov_base = 0;
2809     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2810 
2811     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2812     return xcb_ret;
2813 }
2814 
2815 xcb_xkb_get_controls_cookie_t
xcb_xkb_get_controls_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)2816 xcb_xkb_get_controls_unchecked (xcb_connection_t      *c,
2817                                 xcb_xkb_device_spec_t  deviceSpec)
2818 {
2819     static const xcb_protocol_request_t xcb_req = {
2820         .count = 2,
2821         .ext = &xcb_xkb_id,
2822         .opcode = XCB_XKB_GET_CONTROLS,
2823         .isvoid = 0
2824     };
2825 
2826     struct iovec xcb_parts[4];
2827     xcb_xkb_get_controls_cookie_t xcb_ret;
2828     xcb_xkb_get_controls_request_t xcb_out;
2829 
2830     xcb_out.deviceSpec = deviceSpec;
2831     memset(xcb_out.pad0, 0, 2);
2832 
2833     xcb_parts[2].iov_base = (char *) &xcb_out;
2834     xcb_parts[2].iov_len = sizeof(xcb_out);
2835     xcb_parts[3].iov_base = 0;
2836     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2837 
2838     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2839     return xcb_ret;
2840 }
2841 
2842 xcb_xkb_get_controls_reply_t *
xcb_xkb_get_controls_reply(xcb_connection_t * c,xcb_xkb_get_controls_cookie_t cookie,xcb_generic_error_t ** e)2843 xcb_xkb_get_controls_reply (xcb_connection_t               *c,
2844                             xcb_xkb_get_controls_cookie_t   cookie  /**< */,
2845                             xcb_generic_error_t           **e)
2846 {
2847     return (xcb_xkb_get_controls_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2848 }
2849 
2850 xcb_void_cookie_t
xcb_xkb_set_controls_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t affectInternalRealMods,uint8_t internalRealMods,uint8_t affectIgnoreLockRealMods,uint8_t ignoreLockRealMods,uint16_t affectInternalVirtualMods,uint16_t internalVirtualMods,uint16_t affectIgnoreLockVirtualMods,uint16_t ignoreLockVirtualMods,uint8_t mouseKeysDfltBtn,uint8_t groupsWrap,uint16_t accessXOptions,uint32_t affectEnabledControls,uint32_t enabledControls,uint32_t changeControls,uint16_t repeatDelay,uint16_t repeatInterval,uint16_t slowKeysDelay,uint16_t debounceDelay,uint16_t mouseKeysDelay,uint16_t mouseKeysInterval,uint16_t mouseKeysTimeToMax,uint16_t mouseKeysMaxSpeed,int16_t mouseKeysCurve,uint16_t accessXTimeout,uint32_t accessXTimeoutMask,uint32_t accessXTimeoutValues,uint16_t accessXTimeoutOptionsMask,uint16_t accessXTimeoutOptionsValues,const uint8_t * perKeyRepeat)2851 xcb_xkb_set_controls_checked (xcb_connection_t      *c,
2852                               xcb_xkb_device_spec_t  deviceSpec,
2853                               uint8_t                affectInternalRealMods,
2854                               uint8_t                internalRealMods,
2855                               uint8_t                affectIgnoreLockRealMods,
2856                               uint8_t                ignoreLockRealMods,
2857                               uint16_t               affectInternalVirtualMods,
2858                               uint16_t               internalVirtualMods,
2859                               uint16_t               affectIgnoreLockVirtualMods,
2860                               uint16_t               ignoreLockVirtualMods,
2861                               uint8_t                mouseKeysDfltBtn,
2862                               uint8_t                groupsWrap,
2863                               uint16_t               accessXOptions,
2864                               uint32_t               affectEnabledControls,
2865                               uint32_t               enabledControls,
2866                               uint32_t               changeControls,
2867                               uint16_t               repeatDelay,
2868                               uint16_t               repeatInterval,
2869                               uint16_t               slowKeysDelay,
2870                               uint16_t               debounceDelay,
2871                               uint16_t               mouseKeysDelay,
2872                               uint16_t               mouseKeysInterval,
2873                               uint16_t               mouseKeysTimeToMax,
2874                               uint16_t               mouseKeysMaxSpeed,
2875                               int16_t                mouseKeysCurve,
2876                               uint16_t               accessXTimeout,
2877                               uint32_t               accessXTimeoutMask,
2878                               uint32_t               accessXTimeoutValues,
2879                               uint16_t               accessXTimeoutOptionsMask,
2880                               uint16_t               accessXTimeoutOptionsValues,
2881                               const uint8_t         *perKeyRepeat)
2882 {
2883     static const xcb_protocol_request_t xcb_req = {
2884         .count = 2,
2885         .ext = &xcb_xkb_id,
2886         .opcode = XCB_XKB_SET_CONTROLS,
2887         .isvoid = 1
2888     };
2889 
2890     struct iovec xcb_parts[4];
2891     xcb_void_cookie_t xcb_ret;
2892     xcb_xkb_set_controls_request_t xcb_out;
2893 
2894     xcb_out.deviceSpec = deviceSpec;
2895     xcb_out.affectInternalRealMods = affectInternalRealMods;
2896     xcb_out.internalRealMods = internalRealMods;
2897     xcb_out.affectIgnoreLockRealMods = affectIgnoreLockRealMods;
2898     xcb_out.ignoreLockRealMods = ignoreLockRealMods;
2899     xcb_out.affectInternalVirtualMods = affectInternalVirtualMods;
2900     xcb_out.internalVirtualMods = internalVirtualMods;
2901     xcb_out.affectIgnoreLockVirtualMods = affectIgnoreLockVirtualMods;
2902     xcb_out.ignoreLockVirtualMods = ignoreLockVirtualMods;
2903     xcb_out.mouseKeysDfltBtn = mouseKeysDfltBtn;
2904     xcb_out.groupsWrap = groupsWrap;
2905     xcb_out.accessXOptions = accessXOptions;
2906     memset(xcb_out.pad0, 0, 2);
2907     xcb_out.affectEnabledControls = affectEnabledControls;
2908     xcb_out.enabledControls = enabledControls;
2909     xcb_out.changeControls = changeControls;
2910     xcb_out.repeatDelay = repeatDelay;
2911     xcb_out.repeatInterval = repeatInterval;
2912     xcb_out.slowKeysDelay = slowKeysDelay;
2913     xcb_out.debounceDelay = debounceDelay;
2914     xcb_out.mouseKeysDelay = mouseKeysDelay;
2915     xcb_out.mouseKeysInterval = mouseKeysInterval;
2916     xcb_out.mouseKeysTimeToMax = mouseKeysTimeToMax;
2917     xcb_out.mouseKeysMaxSpeed = mouseKeysMaxSpeed;
2918     xcb_out.mouseKeysCurve = mouseKeysCurve;
2919     xcb_out.accessXTimeout = accessXTimeout;
2920     xcb_out.accessXTimeoutMask = accessXTimeoutMask;
2921     xcb_out.accessXTimeoutValues = accessXTimeoutValues;
2922     xcb_out.accessXTimeoutOptionsMask = accessXTimeoutOptionsMask;
2923     xcb_out.accessXTimeoutOptionsValues = accessXTimeoutOptionsValues;
2924     memcpy(xcb_out.perKeyRepeat, perKeyRepeat, 32);
2925 
2926     xcb_parts[2].iov_base = (char *) &xcb_out;
2927     xcb_parts[2].iov_len = sizeof(xcb_out);
2928     xcb_parts[3].iov_base = 0;
2929     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2930 
2931     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2932     return xcb_ret;
2933 }
2934 
2935 xcb_void_cookie_t
xcb_xkb_set_controls(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t affectInternalRealMods,uint8_t internalRealMods,uint8_t affectIgnoreLockRealMods,uint8_t ignoreLockRealMods,uint16_t affectInternalVirtualMods,uint16_t internalVirtualMods,uint16_t affectIgnoreLockVirtualMods,uint16_t ignoreLockVirtualMods,uint8_t mouseKeysDfltBtn,uint8_t groupsWrap,uint16_t accessXOptions,uint32_t affectEnabledControls,uint32_t enabledControls,uint32_t changeControls,uint16_t repeatDelay,uint16_t repeatInterval,uint16_t slowKeysDelay,uint16_t debounceDelay,uint16_t mouseKeysDelay,uint16_t mouseKeysInterval,uint16_t mouseKeysTimeToMax,uint16_t mouseKeysMaxSpeed,int16_t mouseKeysCurve,uint16_t accessXTimeout,uint32_t accessXTimeoutMask,uint32_t accessXTimeoutValues,uint16_t accessXTimeoutOptionsMask,uint16_t accessXTimeoutOptionsValues,const uint8_t * perKeyRepeat)2936 xcb_xkb_set_controls (xcb_connection_t      *c,
2937                       xcb_xkb_device_spec_t  deviceSpec,
2938                       uint8_t                affectInternalRealMods,
2939                       uint8_t                internalRealMods,
2940                       uint8_t                affectIgnoreLockRealMods,
2941                       uint8_t                ignoreLockRealMods,
2942                       uint16_t               affectInternalVirtualMods,
2943                       uint16_t               internalVirtualMods,
2944                       uint16_t               affectIgnoreLockVirtualMods,
2945                       uint16_t               ignoreLockVirtualMods,
2946                       uint8_t                mouseKeysDfltBtn,
2947                       uint8_t                groupsWrap,
2948                       uint16_t               accessXOptions,
2949                       uint32_t               affectEnabledControls,
2950                       uint32_t               enabledControls,
2951                       uint32_t               changeControls,
2952                       uint16_t               repeatDelay,
2953                       uint16_t               repeatInterval,
2954                       uint16_t               slowKeysDelay,
2955                       uint16_t               debounceDelay,
2956                       uint16_t               mouseKeysDelay,
2957                       uint16_t               mouseKeysInterval,
2958                       uint16_t               mouseKeysTimeToMax,
2959                       uint16_t               mouseKeysMaxSpeed,
2960                       int16_t                mouseKeysCurve,
2961                       uint16_t               accessXTimeout,
2962                       uint32_t               accessXTimeoutMask,
2963                       uint32_t               accessXTimeoutValues,
2964                       uint16_t               accessXTimeoutOptionsMask,
2965                       uint16_t               accessXTimeoutOptionsValues,
2966                       const uint8_t         *perKeyRepeat)
2967 {
2968     static const xcb_protocol_request_t xcb_req = {
2969         .count = 2,
2970         .ext = &xcb_xkb_id,
2971         .opcode = XCB_XKB_SET_CONTROLS,
2972         .isvoid = 1
2973     };
2974 
2975     struct iovec xcb_parts[4];
2976     xcb_void_cookie_t xcb_ret;
2977     xcb_xkb_set_controls_request_t xcb_out;
2978 
2979     xcb_out.deviceSpec = deviceSpec;
2980     xcb_out.affectInternalRealMods = affectInternalRealMods;
2981     xcb_out.internalRealMods = internalRealMods;
2982     xcb_out.affectIgnoreLockRealMods = affectIgnoreLockRealMods;
2983     xcb_out.ignoreLockRealMods = ignoreLockRealMods;
2984     xcb_out.affectInternalVirtualMods = affectInternalVirtualMods;
2985     xcb_out.internalVirtualMods = internalVirtualMods;
2986     xcb_out.affectIgnoreLockVirtualMods = affectIgnoreLockVirtualMods;
2987     xcb_out.ignoreLockVirtualMods = ignoreLockVirtualMods;
2988     xcb_out.mouseKeysDfltBtn = mouseKeysDfltBtn;
2989     xcb_out.groupsWrap = groupsWrap;
2990     xcb_out.accessXOptions = accessXOptions;
2991     memset(xcb_out.pad0, 0, 2);
2992     xcb_out.affectEnabledControls = affectEnabledControls;
2993     xcb_out.enabledControls = enabledControls;
2994     xcb_out.changeControls = changeControls;
2995     xcb_out.repeatDelay = repeatDelay;
2996     xcb_out.repeatInterval = repeatInterval;
2997     xcb_out.slowKeysDelay = slowKeysDelay;
2998     xcb_out.debounceDelay = debounceDelay;
2999     xcb_out.mouseKeysDelay = mouseKeysDelay;
3000     xcb_out.mouseKeysInterval = mouseKeysInterval;
3001     xcb_out.mouseKeysTimeToMax = mouseKeysTimeToMax;
3002     xcb_out.mouseKeysMaxSpeed = mouseKeysMaxSpeed;
3003     xcb_out.mouseKeysCurve = mouseKeysCurve;
3004     xcb_out.accessXTimeout = accessXTimeout;
3005     xcb_out.accessXTimeoutMask = accessXTimeoutMask;
3006     xcb_out.accessXTimeoutValues = accessXTimeoutValues;
3007     xcb_out.accessXTimeoutOptionsMask = accessXTimeoutOptionsMask;
3008     xcb_out.accessXTimeoutOptionsValues = accessXTimeoutOptionsValues;
3009     memcpy(xcb_out.perKeyRepeat, perKeyRepeat, 32);
3010 
3011     xcb_parts[2].iov_base = (char *) &xcb_out;
3012     xcb_parts[2].iov_len = sizeof(xcb_out);
3013     xcb_parts[3].iov_base = 0;
3014     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3015 
3016     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3017     return xcb_ret;
3018 }
3019 
3020 int
xcb_xkb_get_map_map_types_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3021 xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3022                                        const xcb_xkb_get_map_map_t *S)
3023 {
3024     return R->nTypes;
3025 }
3026 
3027 xcb_xkb_key_type_iterator_t
xcb_xkb_get_map_map_types_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3028 xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3029                                          const xcb_xkb_get_map_map_t *S)
3030 {
3031     xcb_xkb_key_type_iterator_t i;
3032     i.data = S->types_rtrn;
3033     i.rem = R->nTypes;
3034     i.index = (char *) i.data - (char *) S;
3035     return i;
3036 }
3037 
3038 int
xcb_xkb_get_map_map_syms_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3039 xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3040                                       const xcb_xkb_get_map_map_t *S)
3041 {
3042     return R->nKeySyms;
3043 }
3044 
3045 xcb_xkb_key_sym_map_iterator_t
xcb_xkb_get_map_map_syms_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3046 xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3047                                         const xcb_xkb_get_map_map_t *S)
3048 {
3049     xcb_xkb_key_sym_map_iterator_t i;
3050     i.data = S->syms_rtrn;
3051     i.rem = R->nKeySyms;
3052     i.index = (char *) i.data - (char *) S;
3053     return i;
3054 }
3055 
3056 uint8_t *
xcb_xkb_get_map_map_acts_rtrn_count(const xcb_xkb_get_map_map_t * S)3057 xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S)
3058 {
3059     return S->acts_rtrn_count;
3060 }
3061 
3062 int
xcb_xkb_get_map_map_acts_rtrn_count_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3063 xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R,
3064                                             const xcb_xkb_get_map_map_t *S)
3065 {
3066     return R->nKeyActions;
3067 }
3068 
3069 xcb_generic_iterator_t
xcb_xkb_get_map_map_acts_rtrn_count_end(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3070 xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R,
3071                                          const xcb_xkb_get_map_map_t *S)
3072 {
3073     xcb_generic_iterator_t i;
3074     i.data = S->acts_rtrn_count + R->nKeyActions;
3075     i.rem = 0;
3076     i.index = (char *) i.data - (char *) S;
3077     return i;
3078 }
3079 
3080 xcb_xkb_action_t *
xcb_xkb_get_map_map_acts_rtrn_acts(const xcb_xkb_get_map_map_t * S)3081 xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S)
3082 {
3083     return S->acts_rtrn_acts;
3084 }
3085 
3086 int
xcb_xkb_get_map_map_acts_rtrn_acts_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3087 xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R,
3088                                            const xcb_xkb_get_map_map_t *S)
3089 {
3090     return R->totalActions;
3091 }
3092 
3093 xcb_xkb_action_iterator_t
xcb_xkb_get_map_map_acts_rtrn_acts_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3094 xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R,
3095                                              const xcb_xkb_get_map_map_t *S)
3096 {
3097     xcb_xkb_action_iterator_t i;
3098     i.data = S->acts_rtrn_acts;
3099     i.rem = R->totalActions;
3100     i.index = (char *) i.data - (char *) S;
3101     return i;
3102 }
3103 
3104 xcb_xkb_set_behavior_t *
xcb_xkb_get_map_map_behaviors_rtrn(const xcb_xkb_get_map_map_t * S)3105 xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S)
3106 {
3107     return S->behaviors_rtrn;
3108 }
3109 
3110 int
xcb_xkb_get_map_map_behaviors_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3111 xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3112                                            const xcb_xkb_get_map_map_t *S)
3113 {
3114     return R->totalKeyBehaviors;
3115 }
3116 
3117 xcb_xkb_set_behavior_iterator_t
xcb_xkb_get_map_map_behaviors_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3118 xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3119                                              const xcb_xkb_get_map_map_t *S)
3120 {
3121     xcb_xkb_set_behavior_iterator_t i;
3122     i.data = S->behaviors_rtrn;
3123     i.rem = R->totalKeyBehaviors;
3124     i.index = (char *) i.data - (char *) S;
3125     return i;
3126 }
3127 
3128 uint8_t *
xcb_xkb_get_map_map_vmods_rtrn(const xcb_xkb_get_map_map_t * S)3129 xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S)
3130 {
3131     return S->vmods_rtrn;
3132 }
3133 
3134 int
xcb_xkb_get_map_map_vmods_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3135 xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3136                                        const xcb_xkb_get_map_map_t *S)
3137 {
3138     return xcb_popcount(R->virtualMods);
3139 }
3140 
3141 xcb_generic_iterator_t
xcb_xkb_get_map_map_vmods_rtrn_end(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3142 xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R,
3143                                     const xcb_xkb_get_map_map_t *S)
3144 {
3145     xcb_generic_iterator_t i;
3146     i.data = S->vmods_rtrn + xcb_popcount(R->virtualMods);
3147     i.rem = 0;
3148     i.index = (char *) i.data - (char *) S;
3149     return i;
3150 }
3151 
3152 xcb_xkb_set_explicit_t *
xcb_xkb_get_map_map_explicit_rtrn(const xcb_xkb_get_map_map_t * S)3153 xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S)
3154 {
3155     return S->explicit_rtrn;
3156 }
3157 
3158 int
xcb_xkb_get_map_map_explicit_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3159 xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3160                                           const xcb_xkb_get_map_map_t *S)
3161 {
3162     return R->totalKeyExplicit;
3163 }
3164 
3165 xcb_xkb_set_explicit_iterator_t
xcb_xkb_get_map_map_explicit_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3166 xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3167                                             const xcb_xkb_get_map_map_t *S)
3168 {
3169     xcb_xkb_set_explicit_iterator_t i;
3170     i.data = S->explicit_rtrn;
3171     i.rem = R->totalKeyExplicit;
3172     i.index = (char *) i.data - (char *) S;
3173     return i;
3174 }
3175 
3176 xcb_xkb_key_mod_map_t *
xcb_xkb_get_map_map_modmap_rtrn(const xcb_xkb_get_map_map_t * S)3177 xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S)
3178 {
3179     return S->modmap_rtrn;
3180 }
3181 
3182 int
xcb_xkb_get_map_map_modmap_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3183 xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3184                                         const xcb_xkb_get_map_map_t *S)
3185 {
3186     return R->totalModMapKeys;
3187 }
3188 
3189 xcb_xkb_key_mod_map_iterator_t
xcb_xkb_get_map_map_modmap_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3190 xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3191                                           const xcb_xkb_get_map_map_t *S)
3192 {
3193     xcb_xkb_key_mod_map_iterator_t i;
3194     i.data = S->modmap_rtrn;
3195     i.rem = R->totalModMapKeys;
3196     i.index = (char *) i.data - (char *) S;
3197     return i;
3198 }
3199 
3200 xcb_xkb_key_v_mod_map_t *
xcb_xkb_get_map_map_vmodmap_rtrn(const xcb_xkb_get_map_map_t * S)3201 xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S)
3202 {
3203     return S->vmodmap_rtrn;
3204 }
3205 
3206 int
xcb_xkb_get_map_map_vmodmap_rtrn_length(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3207 xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
3208                                          const xcb_xkb_get_map_map_t *S)
3209 {
3210     return R->totalVModMapKeys;
3211 }
3212 
3213 xcb_xkb_key_v_mod_map_iterator_t
xcb_xkb_get_map_map_vmodmap_rtrn_iterator(const xcb_xkb_get_map_reply_t * R,const xcb_xkb_get_map_map_t * S)3214 xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
3215                                            const xcb_xkb_get_map_map_t *S)
3216 {
3217     xcb_xkb_key_v_mod_map_iterator_t i;
3218     i.data = S->vmodmap_rtrn;
3219     i.rem = R->totalVModMapKeys;
3220     i.index = (char *) i.data - (char *) S;
3221     return i;
3222 }
3223 
3224 int
xcb_xkb_get_map_map_serialize(void ** _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,const xcb_xkb_get_map_map_t * _aux)3225 xcb_xkb_get_map_map_serialize (void                        **_buffer,
3226                                uint8_t                       nTypes,
3227                                uint8_t                       nKeySyms,
3228                                uint8_t                       nKeyActions,
3229                                uint16_t                      totalActions,
3230                                uint8_t                       totalKeyBehaviors,
3231                                uint16_t                      virtualMods,
3232                                uint8_t                       totalKeyExplicit,
3233                                uint8_t                       totalModMapKeys,
3234                                uint8_t                       totalVModMapKeys,
3235                                uint16_t                      present,
3236                                const xcb_xkb_get_map_map_t  *_aux)
3237 {
3238     char *xcb_out = *_buffer;
3239     unsigned int xcb_buffer_len = 0;
3240     unsigned int xcb_align_to = 0;
3241     unsigned int xcb_padding_offset = 0;
3242 
3243     unsigned int xcb_pad = 0;
3244     char xcb_pad0[3] = {0, 0, 0};
3245     struct iovec xcb_parts[23];
3246     unsigned int xcb_parts_idx = 0;
3247     unsigned int xcb_block_len = 0;
3248     unsigned int i;
3249     char *xcb_tmp;
3250 
3251     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
3252         /* insert padding */
3253         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3254         xcb_buffer_len += xcb_block_len + xcb_pad;
3255         if (0 != xcb_pad) {
3256             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3257             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3258             xcb_parts_idx++;
3259             xcb_pad = 0;
3260         }
3261         xcb_block_len = 0;
3262         xcb_padding_offset = 0;
3263         /* types_rtrn */
3264         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn;
3265         xcb_parts[xcb_parts_idx].iov_len = 0;
3266         xcb_tmp = (char *) _aux->types_rtrn;
3267         for(i=0; i<nTypes; i++) {
3268             xcb_block_len = xcb_xkb_key_type_sizeof(xcb_tmp);
3269             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
3270         }
3271         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
3272         xcb_parts_idx++;
3273         xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
3274     }
3275     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
3276         /* insert padding */
3277         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3278         xcb_buffer_len += xcb_block_len + xcb_pad;
3279         if (0 != xcb_pad) {
3280             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3281             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3282             xcb_parts_idx++;
3283             xcb_pad = 0;
3284         }
3285         xcb_block_len = 0;
3286         xcb_padding_offset = 0;
3287         /* syms_rtrn */
3288         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn;
3289         xcb_parts[xcb_parts_idx].iov_len = 0;
3290         xcb_tmp = (char *) _aux->syms_rtrn;
3291         for(i=0; i<nKeySyms; i++) {
3292             xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
3293             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
3294         }
3295         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
3296         xcb_parts_idx++;
3297         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
3298     }
3299     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
3300         /* insert padding */
3301         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3302         xcb_buffer_len += xcb_block_len + xcb_pad;
3303         if (0 != xcb_pad) {
3304             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3305             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3306             xcb_parts_idx++;
3307             xcb_pad = 0;
3308         }
3309         xcb_block_len = 0;
3310         xcb_padding_offset = 0;
3311         /* acts_rtrn_count */
3312         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count;
3313         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
3314         xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
3315         xcb_parts_idx++;
3316         xcb_align_to = ALIGNOF(uint8_t);
3317         xcb_align_to = 4;
3318         /* insert padding */
3319         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3320         xcb_buffer_len += xcb_block_len + xcb_pad;
3321         if (0 != xcb_pad) {
3322             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3323             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3324             xcb_parts_idx++;
3325             xcb_pad = 0;
3326         }
3327         xcb_block_len = 0;
3328         xcb_padding_offset = 0;
3329         /* insert padding */
3330         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3331         xcb_buffer_len += xcb_block_len + xcb_pad;
3332         if (0 != xcb_pad) {
3333             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3334             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3335             xcb_parts_idx++;
3336             xcb_pad = 0;
3337         }
3338         xcb_block_len = 0;
3339         xcb_padding_offset = 0;
3340         /* acts_rtrn_acts */
3341         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts;
3342         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
3343         xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
3344         xcb_parts_idx++;
3345         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
3346     }
3347     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
3348         /* insert padding */
3349         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3350         xcb_buffer_len += xcb_block_len + xcb_pad;
3351         if (0 != xcb_pad) {
3352             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3353             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3354             xcb_parts_idx++;
3355             xcb_pad = 0;
3356         }
3357         xcb_block_len = 0;
3358         xcb_padding_offset = 0;
3359         /* behaviors_rtrn */
3360         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn;
3361         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
3362         xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
3363         xcb_parts_idx++;
3364         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
3365     }
3366     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
3367         /* insert padding */
3368         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3369         xcb_buffer_len += xcb_block_len + xcb_pad;
3370         if (0 != xcb_pad) {
3371             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3372             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3373             xcb_parts_idx++;
3374             xcb_pad = 0;
3375         }
3376         xcb_block_len = 0;
3377         xcb_padding_offset = 0;
3378         /* vmods_rtrn */
3379         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn;
3380         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
3381         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
3382         xcb_parts_idx++;
3383         xcb_align_to = ALIGNOF(uint8_t);
3384         xcb_align_to = 4;
3385         /* insert padding */
3386         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3387         xcb_buffer_len += xcb_block_len + xcb_pad;
3388         if (0 != xcb_pad) {
3389             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3390             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3391             xcb_parts_idx++;
3392             xcb_pad = 0;
3393         }
3394         xcb_block_len = 0;
3395         xcb_padding_offset = 0;
3396     }
3397     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
3398         /* insert padding */
3399         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3400         xcb_buffer_len += xcb_block_len + xcb_pad;
3401         if (0 != xcb_pad) {
3402             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3403             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3404             xcb_parts_idx++;
3405             xcb_pad = 0;
3406         }
3407         xcb_block_len = 0;
3408         xcb_padding_offset = 0;
3409         /* explicit_rtrn */
3410         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn;
3411         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
3412         xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
3413         xcb_parts_idx++;
3414         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
3415         xcb_align_to = 4;
3416         /* insert padding */
3417         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3418         xcb_buffer_len += xcb_block_len + xcb_pad;
3419         if (0 != xcb_pad) {
3420             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3421             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3422             xcb_parts_idx++;
3423             xcb_pad = 0;
3424         }
3425         xcb_block_len = 0;
3426         xcb_padding_offset = 0;
3427     }
3428     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
3429         /* insert padding */
3430         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3431         xcb_buffer_len += xcb_block_len + xcb_pad;
3432         if (0 != xcb_pad) {
3433             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3434             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3435             xcb_parts_idx++;
3436             xcb_pad = 0;
3437         }
3438         xcb_block_len = 0;
3439         xcb_padding_offset = 0;
3440         /* modmap_rtrn */
3441         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn;
3442         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
3443         xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
3444         xcb_parts_idx++;
3445         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
3446         xcb_align_to = 4;
3447         /* insert padding */
3448         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3449         xcb_buffer_len += xcb_block_len + xcb_pad;
3450         if (0 != xcb_pad) {
3451             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3452             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3453             xcb_parts_idx++;
3454             xcb_pad = 0;
3455         }
3456         xcb_block_len = 0;
3457         xcb_padding_offset = 0;
3458     }
3459     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
3460         /* insert padding */
3461         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3462         xcb_buffer_len += xcb_block_len + xcb_pad;
3463         if (0 != xcb_pad) {
3464             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3465             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3466             xcb_parts_idx++;
3467             xcb_pad = 0;
3468         }
3469         xcb_block_len = 0;
3470         xcb_padding_offset = 0;
3471         /* vmodmap_rtrn */
3472         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn;
3473         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
3474         xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
3475         xcb_parts_idx++;
3476         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
3477     }
3478     /* insert padding */
3479     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3480     xcb_buffer_len += xcb_block_len + xcb_pad;
3481     if (0 != xcb_pad) {
3482         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
3483         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
3484         xcb_parts_idx++;
3485         xcb_pad = 0;
3486     }
3487     xcb_block_len = 0;
3488     xcb_padding_offset = 0;
3489 
3490     if (NULL == xcb_out) {
3491         /* allocate memory */
3492         xcb_out = malloc(xcb_buffer_len);
3493         *_buffer = xcb_out;
3494     }
3495 
3496     xcb_tmp = xcb_out;
3497     for(i=0; i<xcb_parts_idx; i++) {
3498         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
3499             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
3500         if (0 != xcb_parts[i].iov_len)
3501             xcb_tmp += xcb_parts[i].iov_len;
3502     }
3503 
3504     return xcb_buffer_len;
3505 }
3506 
3507 int
xcb_xkb_get_map_map_unpack(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,xcb_xkb_get_map_map_t * _aux)3508 xcb_xkb_get_map_map_unpack (const void             *_buffer,
3509                             uint8_t                 nTypes,
3510                             uint8_t                 nKeySyms,
3511                             uint8_t                 nKeyActions,
3512                             uint16_t                totalActions,
3513                             uint8_t                 totalKeyBehaviors,
3514                             uint16_t                virtualMods,
3515                             uint8_t                 totalKeyExplicit,
3516                             uint8_t                 totalModMapKeys,
3517                             uint8_t                 totalVModMapKeys,
3518                             uint16_t                present,
3519                             xcb_xkb_get_map_map_t  *_aux)
3520 {
3521     char *xcb_tmp = (char *)_buffer;
3522     unsigned int xcb_buffer_len = 0;
3523     unsigned int xcb_block_len = 0;
3524     unsigned int xcb_pad = 0;
3525     unsigned int xcb_align_to = 0;
3526     unsigned int xcb_padding_offset = 0;
3527 
3528     unsigned int i;
3529     unsigned int xcb_tmp_len;
3530 
3531     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
3532         /* insert padding */
3533         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3534         xcb_buffer_len += xcb_block_len + xcb_pad;
3535         if (0 != xcb_pad) {
3536             xcb_tmp += xcb_pad;
3537             xcb_pad = 0;
3538         }
3539         xcb_block_len = 0;
3540         xcb_padding_offset = 0;
3541         /* types_rtrn */
3542         _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp;
3543         for(i=0; i<nTypes; i++) {
3544             xcb_tmp_len = xcb_xkb_key_type_sizeof(xcb_tmp);
3545             xcb_block_len += xcb_tmp_len;
3546             xcb_tmp += xcb_tmp_len;
3547         }
3548         xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
3549     }
3550     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
3551         /* insert padding */
3552         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3553         xcb_buffer_len += xcb_block_len + xcb_pad;
3554         if (0 != xcb_pad) {
3555             xcb_tmp += xcb_pad;
3556             xcb_pad = 0;
3557         }
3558         xcb_block_len = 0;
3559         xcb_padding_offset = 0;
3560         /* syms_rtrn */
3561         _aux->syms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp;
3562         for(i=0; i<nKeySyms; i++) {
3563             xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
3564             xcb_block_len += xcb_tmp_len;
3565             xcb_tmp += xcb_tmp_len;
3566         }
3567         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
3568     }
3569     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
3570         /* insert padding */
3571         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3572         xcb_buffer_len += xcb_block_len + xcb_pad;
3573         if (0 != xcb_pad) {
3574             xcb_tmp += xcb_pad;
3575             xcb_pad = 0;
3576         }
3577         xcb_block_len = 0;
3578         xcb_padding_offset = 0;
3579         /* acts_rtrn_count */
3580         _aux->acts_rtrn_count = (uint8_t *)xcb_tmp;
3581         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
3582         xcb_tmp += xcb_block_len;
3583         xcb_align_to = ALIGNOF(uint8_t);
3584         xcb_align_to = 4;
3585         /* insert padding */
3586         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3587         xcb_buffer_len += xcb_block_len + xcb_pad;
3588         if (0 != xcb_pad) {
3589             xcb_tmp += xcb_pad;
3590             xcb_pad = 0;
3591         }
3592         xcb_block_len = 0;
3593         xcb_padding_offset = 0;
3594         /* insert padding */
3595         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3596         xcb_buffer_len += xcb_block_len + xcb_pad;
3597         if (0 != xcb_pad) {
3598             xcb_tmp += xcb_pad;
3599             xcb_pad = 0;
3600         }
3601         xcb_block_len = 0;
3602         xcb_padding_offset = 0;
3603         /* acts_rtrn_acts */
3604         _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp;
3605         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
3606         xcb_tmp += xcb_block_len;
3607         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
3608     }
3609     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
3610         /* insert padding */
3611         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3612         xcb_buffer_len += xcb_block_len + xcb_pad;
3613         if (0 != xcb_pad) {
3614             xcb_tmp += xcb_pad;
3615             xcb_pad = 0;
3616         }
3617         xcb_block_len = 0;
3618         xcb_padding_offset = 0;
3619         /* behaviors_rtrn */
3620         _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp;
3621         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
3622         xcb_tmp += xcb_block_len;
3623         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
3624     }
3625     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
3626         /* insert padding */
3627         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3628         xcb_buffer_len += xcb_block_len + xcb_pad;
3629         if (0 != xcb_pad) {
3630             xcb_tmp += xcb_pad;
3631             xcb_pad = 0;
3632         }
3633         xcb_block_len = 0;
3634         xcb_padding_offset = 0;
3635         /* vmods_rtrn */
3636         _aux->vmods_rtrn = (uint8_t *)xcb_tmp;
3637         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
3638         xcb_tmp += xcb_block_len;
3639         xcb_align_to = ALIGNOF(uint8_t);
3640         xcb_align_to = 4;
3641         /* insert padding */
3642         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3643         xcb_buffer_len += xcb_block_len + xcb_pad;
3644         if (0 != xcb_pad) {
3645             xcb_tmp += xcb_pad;
3646             xcb_pad = 0;
3647         }
3648         xcb_block_len = 0;
3649         xcb_padding_offset = 0;
3650     }
3651     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
3652         /* insert padding */
3653         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3654         xcb_buffer_len += xcb_block_len + xcb_pad;
3655         if (0 != xcb_pad) {
3656             xcb_tmp += xcb_pad;
3657             xcb_pad = 0;
3658         }
3659         xcb_block_len = 0;
3660         xcb_padding_offset = 0;
3661         /* explicit_rtrn */
3662         _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp;
3663         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
3664         xcb_tmp += xcb_block_len;
3665         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
3666         xcb_align_to = 4;
3667         /* insert padding */
3668         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3669         xcb_buffer_len += xcb_block_len + xcb_pad;
3670         if (0 != xcb_pad) {
3671             xcb_tmp += xcb_pad;
3672             xcb_pad = 0;
3673         }
3674         xcb_block_len = 0;
3675         xcb_padding_offset = 0;
3676     }
3677     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
3678         /* insert padding */
3679         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3680         xcb_buffer_len += xcb_block_len + xcb_pad;
3681         if (0 != xcb_pad) {
3682             xcb_tmp += xcb_pad;
3683             xcb_pad = 0;
3684         }
3685         xcb_block_len = 0;
3686         xcb_padding_offset = 0;
3687         /* modmap_rtrn */
3688         _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp;
3689         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
3690         xcb_tmp += xcb_block_len;
3691         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
3692         xcb_align_to = 4;
3693         /* insert padding */
3694         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3695         xcb_buffer_len += xcb_block_len + xcb_pad;
3696         if (0 != xcb_pad) {
3697             xcb_tmp += xcb_pad;
3698             xcb_pad = 0;
3699         }
3700         xcb_block_len = 0;
3701         xcb_padding_offset = 0;
3702     }
3703     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
3704         /* insert padding */
3705         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3706         xcb_buffer_len += xcb_block_len + xcb_pad;
3707         if (0 != xcb_pad) {
3708             xcb_tmp += xcb_pad;
3709             xcb_pad = 0;
3710         }
3711         xcb_block_len = 0;
3712         xcb_padding_offset = 0;
3713         /* vmodmap_rtrn */
3714         _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
3715         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
3716         xcb_tmp += xcb_block_len;
3717         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
3718     }
3719     /* insert padding */
3720     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
3721     xcb_buffer_len += xcb_block_len + xcb_pad;
3722     if (0 != xcb_pad) {
3723         xcb_tmp += xcb_pad;
3724         xcb_pad = 0;
3725     }
3726     xcb_block_len = 0;
3727     xcb_padding_offset = 0;
3728 
3729     return xcb_buffer_len;
3730 }
3731 
3732 int
xcb_xkb_get_map_map_sizeof(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present)3733 xcb_xkb_get_map_map_sizeof (const void  *_buffer,
3734                             uint8_t      nTypes,
3735                             uint8_t      nKeySyms,
3736                             uint8_t      nKeyActions,
3737                             uint16_t     totalActions,
3738                             uint8_t      totalKeyBehaviors,
3739                             uint16_t     virtualMods,
3740                             uint8_t      totalKeyExplicit,
3741                             uint8_t      totalModMapKeys,
3742                             uint8_t      totalVModMapKeys,
3743                             uint16_t     present)
3744 {
3745     xcb_xkb_get_map_map_t _aux;
3746     return xcb_xkb_get_map_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
3747 }
3748 
3749 int
xcb_xkb_get_map_sizeof(const void * _buffer)3750 xcb_xkb_get_map_sizeof (const void  *_buffer)
3751 {
3752     char *xcb_tmp = (char *)_buffer;
3753     const xcb_xkb_get_map_reply_t *_aux = (xcb_xkb_get_map_reply_t *)_buffer;
3754     unsigned int xcb_buffer_len = 0;
3755     unsigned int xcb_block_len = 0;
3756     unsigned int xcb_pad = 0;
3757     unsigned int xcb_align_to = 0;
3758 
3759 
3760     xcb_block_len += sizeof(xcb_xkb_get_map_reply_t);
3761     xcb_tmp += xcb_block_len;
3762     xcb_buffer_len += xcb_block_len;
3763     xcb_block_len = 0;
3764     /* map */
3765     xcb_block_len += xcb_xkb_get_map_map_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present);
3766     xcb_tmp += xcb_block_len;
3767     xcb_align_to = ALIGNOF(char);
3768     /* insert padding */
3769     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
3770     xcb_buffer_len += xcb_block_len + xcb_pad;
3771     if (0 != xcb_pad) {
3772         xcb_tmp += xcb_pad;
3773         xcb_pad = 0;
3774     }
3775     xcb_block_len = 0;
3776 
3777     return xcb_buffer_len;
3778 }
3779 
3780 xcb_xkb_get_map_cookie_t
xcb_xkb_get_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t full,uint16_t partial,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint16_t virtualMods,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys)3781 xcb_xkb_get_map (xcb_connection_t      *c,
3782                  xcb_xkb_device_spec_t  deviceSpec,
3783                  uint16_t               full,
3784                  uint16_t               partial,
3785                  uint8_t                firstType,
3786                  uint8_t                nTypes,
3787                  xcb_keycode_t          firstKeySym,
3788                  uint8_t                nKeySyms,
3789                  xcb_keycode_t          firstKeyAction,
3790                  uint8_t                nKeyActions,
3791                  xcb_keycode_t          firstKeyBehavior,
3792                  uint8_t                nKeyBehaviors,
3793                  uint16_t               virtualMods,
3794                  xcb_keycode_t          firstKeyExplicit,
3795                  uint8_t                nKeyExplicit,
3796                  xcb_keycode_t          firstModMapKey,
3797                  uint8_t                nModMapKeys,
3798                  xcb_keycode_t          firstVModMapKey,
3799                  uint8_t                nVModMapKeys)
3800 {
3801     static const xcb_protocol_request_t xcb_req = {
3802         .count = 2,
3803         .ext = &xcb_xkb_id,
3804         .opcode = XCB_XKB_GET_MAP,
3805         .isvoid = 0
3806     };
3807 
3808     struct iovec xcb_parts[4];
3809     xcb_xkb_get_map_cookie_t xcb_ret;
3810     xcb_xkb_get_map_request_t xcb_out;
3811 
3812     xcb_out.deviceSpec = deviceSpec;
3813     xcb_out.full = full;
3814     xcb_out.partial = partial;
3815     xcb_out.firstType = firstType;
3816     xcb_out.nTypes = nTypes;
3817     xcb_out.firstKeySym = firstKeySym;
3818     xcb_out.nKeySyms = nKeySyms;
3819     xcb_out.firstKeyAction = firstKeyAction;
3820     xcb_out.nKeyActions = nKeyActions;
3821     xcb_out.firstKeyBehavior = firstKeyBehavior;
3822     xcb_out.nKeyBehaviors = nKeyBehaviors;
3823     xcb_out.virtualMods = virtualMods;
3824     xcb_out.firstKeyExplicit = firstKeyExplicit;
3825     xcb_out.nKeyExplicit = nKeyExplicit;
3826     xcb_out.firstModMapKey = firstModMapKey;
3827     xcb_out.nModMapKeys = nModMapKeys;
3828     xcb_out.firstVModMapKey = firstVModMapKey;
3829     xcb_out.nVModMapKeys = nVModMapKeys;
3830     memset(xcb_out.pad0, 0, 2);
3831 
3832     xcb_parts[2].iov_base = (char *) &xcb_out;
3833     xcb_parts[2].iov_len = sizeof(xcb_out);
3834     xcb_parts[3].iov_base = 0;
3835     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3836 
3837     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
3838     return xcb_ret;
3839 }
3840 
3841 xcb_xkb_get_map_cookie_t
xcb_xkb_get_map_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t full,uint16_t partial,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint16_t virtualMods,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys)3842 xcb_xkb_get_map_unchecked (xcb_connection_t      *c,
3843                            xcb_xkb_device_spec_t  deviceSpec,
3844                            uint16_t               full,
3845                            uint16_t               partial,
3846                            uint8_t                firstType,
3847                            uint8_t                nTypes,
3848                            xcb_keycode_t          firstKeySym,
3849                            uint8_t                nKeySyms,
3850                            xcb_keycode_t          firstKeyAction,
3851                            uint8_t                nKeyActions,
3852                            xcb_keycode_t          firstKeyBehavior,
3853                            uint8_t                nKeyBehaviors,
3854                            uint16_t               virtualMods,
3855                            xcb_keycode_t          firstKeyExplicit,
3856                            uint8_t                nKeyExplicit,
3857                            xcb_keycode_t          firstModMapKey,
3858                            uint8_t                nModMapKeys,
3859                            xcb_keycode_t          firstVModMapKey,
3860                            uint8_t                nVModMapKeys)
3861 {
3862     static const xcb_protocol_request_t xcb_req = {
3863         .count = 2,
3864         .ext = &xcb_xkb_id,
3865         .opcode = XCB_XKB_GET_MAP,
3866         .isvoid = 0
3867     };
3868 
3869     struct iovec xcb_parts[4];
3870     xcb_xkb_get_map_cookie_t xcb_ret;
3871     xcb_xkb_get_map_request_t xcb_out;
3872 
3873     xcb_out.deviceSpec = deviceSpec;
3874     xcb_out.full = full;
3875     xcb_out.partial = partial;
3876     xcb_out.firstType = firstType;
3877     xcb_out.nTypes = nTypes;
3878     xcb_out.firstKeySym = firstKeySym;
3879     xcb_out.nKeySyms = nKeySyms;
3880     xcb_out.firstKeyAction = firstKeyAction;
3881     xcb_out.nKeyActions = nKeyActions;
3882     xcb_out.firstKeyBehavior = firstKeyBehavior;
3883     xcb_out.nKeyBehaviors = nKeyBehaviors;
3884     xcb_out.virtualMods = virtualMods;
3885     xcb_out.firstKeyExplicit = firstKeyExplicit;
3886     xcb_out.nKeyExplicit = nKeyExplicit;
3887     xcb_out.firstModMapKey = firstModMapKey;
3888     xcb_out.nModMapKeys = nModMapKeys;
3889     xcb_out.firstVModMapKey = firstVModMapKey;
3890     xcb_out.nVModMapKeys = nVModMapKeys;
3891     memset(xcb_out.pad0, 0, 2);
3892 
3893     xcb_parts[2].iov_base = (char *) &xcb_out;
3894     xcb_parts[2].iov_len = sizeof(xcb_out);
3895     xcb_parts[3].iov_base = 0;
3896     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
3897 
3898     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
3899     return xcb_ret;
3900 }
3901 
3902 void *
xcb_xkb_get_map_map(const xcb_xkb_get_map_reply_t * R)3903 xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R)
3904 {
3905     return (void *) (R + 1);
3906 }
3907 
3908 xcb_xkb_get_map_reply_t *
xcb_xkb_get_map_reply(xcb_connection_t * c,xcb_xkb_get_map_cookie_t cookie,xcb_generic_error_t ** e)3909 xcb_xkb_get_map_reply (xcb_connection_t          *c,
3910                        xcb_xkb_get_map_cookie_t   cookie  /**< */,
3911                        xcb_generic_error_t      **e)
3912 {
3913     return (xcb_xkb_get_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
3914 }
3915 
3916 int
xcb_xkb_set_map_values_types_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3917 xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R,
3918                                      const xcb_xkb_set_map_values_t *S)
3919 {
3920     return R->nTypes;
3921 }
3922 
3923 xcb_xkb_set_key_type_iterator_t
xcb_xkb_set_map_values_types_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3924 xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R,
3925                                        const xcb_xkb_set_map_values_t *S)
3926 {
3927     xcb_xkb_set_key_type_iterator_t i;
3928     i.data = S->types;
3929     i.rem = R->nTypes;
3930     i.index = (char *) i.data - (char *) S;
3931     return i;
3932 }
3933 
3934 int
xcb_xkb_set_map_values_syms_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3935 xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R,
3936                                     const xcb_xkb_set_map_values_t *S)
3937 {
3938     return R->nKeySyms;
3939 }
3940 
3941 xcb_xkb_key_sym_map_iterator_t
xcb_xkb_set_map_values_syms_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3942 xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R,
3943                                       const xcb_xkb_set_map_values_t *S)
3944 {
3945     xcb_xkb_key_sym_map_iterator_t i;
3946     i.data = S->syms;
3947     i.rem = R->nKeySyms;
3948     i.index = (char *) i.data - (char *) S;
3949     return i;
3950 }
3951 
3952 uint8_t *
xcb_xkb_set_map_values_actions_count(const xcb_xkb_set_map_values_t * S)3953 xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S)
3954 {
3955     return S->actionsCount;
3956 }
3957 
3958 int
xcb_xkb_set_map_values_actions_count_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3959 xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R,
3960                                              const xcb_xkb_set_map_values_t *S)
3961 {
3962     return R->nKeyActions;
3963 }
3964 
3965 xcb_generic_iterator_t
xcb_xkb_set_map_values_actions_count_end(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3966 xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R,
3967                                           const xcb_xkb_set_map_values_t *S)
3968 {
3969     xcb_generic_iterator_t i;
3970     i.data = S->actionsCount + R->nKeyActions;
3971     i.rem = 0;
3972     i.index = (char *) i.data - (char *) S;
3973     return i;
3974 }
3975 
3976 xcb_xkb_action_t *
xcb_xkb_set_map_values_actions(const xcb_xkb_set_map_values_t * S)3977 xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S)
3978 {
3979     return S->actions;
3980 }
3981 
3982 int
xcb_xkb_set_map_values_actions_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3983 xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R,
3984                                        const xcb_xkb_set_map_values_t *S)
3985 {
3986     return R->totalActions;
3987 }
3988 
3989 xcb_xkb_action_iterator_t
xcb_xkb_set_map_values_actions_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)3990 xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R,
3991                                          const xcb_xkb_set_map_values_t *S)
3992 {
3993     xcb_xkb_action_iterator_t i;
3994     i.data = S->actions;
3995     i.rem = R->totalActions;
3996     i.index = (char *) i.data - (char *) S;
3997     return i;
3998 }
3999 
4000 xcb_xkb_set_behavior_t *
xcb_xkb_set_map_values_behaviors(const xcb_xkb_set_map_values_t * S)4001 xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S)
4002 {
4003     return S->behaviors;
4004 }
4005 
4006 int
xcb_xkb_set_map_values_behaviors_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4007 xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R,
4008                                          const xcb_xkb_set_map_values_t *S)
4009 {
4010     return R->totalKeyBehaviors;
4011 }
4012 
4013 xcb_xkb_set_behavior_iterator_t
xcb_xkb_set_map_values_behaviors_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4014 xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R,
4015                                            const xcb_xkb_set_map_values_t *S)
4016 {
4017     xcb_xkb_set_behavior_iterator_t i;
4018     i.data = S->behaviors;
4019     i.rem = R->totalKeyBehaviors;
4020     i.index = (char *) i.data - (char *) S;
4021     return i;
4022 }
4023 
4024 uint8_t *
xcb_xkb_set_map_values_vmods(const xcb_xkb_set_map_values_t * S)4025 xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S)
4026 {
4027     return S->vmods;
4028 }
4029 
4030 int
xcb_xkb_set_map_values_vmods_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4031 xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R,
4032                                      const xcb_xkb_set_map_values_t *S)
4033 {
4034     return xcb_popcount(R->virtualMods);
4035 }
4036 
4037 xcb_generic_iterator_t
xcb_xkb_set_map_values_vmods_end(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4038 xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R,
4039                                   const xcb_xkb_set_map_values_t *S)
4040 {
4041     xcb_generic_iterator_t i;
4042     i.data = S->vmods + xcb_popcount(R->virtualMods);
4043     i.rem = 0;
4044     i.index = (char *) i.data - (char *) S;
4045     return i;
4046 }
4047 
4048 xcb_xkb_set_explicit_t *
xcb_xkb_set_map_values_explicit(const xcb_xkb_set_map_values_t * S)4049 xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S)
4050 {
4051     return S->explicit;
4052 }
4053 
4054 int
xcb_xkb_set_map_values_explicit_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4055 xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R,
4056                                         const xcb_xkb_set_map_values_t *S)
4057 {
4058     return R->totalKeyExplicit;
4059 }
4060 
4061 xcb_xkb_set_explicit_iterator_t
xcb_xkb_set_map_values_explicit_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4062 xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R,
4063                                           const xcb_xkb_set_map_values_t *S)
4064 {
4065     xcb_xkb_set_explicit_iterator_t i;
4066     i.data = S->explicit;
4067     i.rem = R->totalKeyExplicit;
4068     i.index = (char *) i.data - (char *) S;
4069     return i;
4070 }
4071 
4072 xcb_xkb_key_mod_map_t *
xcb_xkb_set_map_values_modmap(const xcb_xkb_set_map_values_t * S)4073 xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S)
4074 {
4075     return S->modmap;
4076 }
4077 
4078 int
xcb_xkb_set_map_values_modmap_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4079 xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R,
4080                                       const xcb_xkb_set_map_values_t *S)
4081 {
4082     return R->totalModMapKeys;
4083 }
4084 
4085 xcb_xkb_key_mod_map_iterator_t
xcb_xkb_set_map_values_modmap_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4086 xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R,
4087                                         const xcb_xkb_set_map_values_t *S)
4088 {
4089     xcb_xkb_key_mod_map_iterator_t i;
4090     i.data = S->modmap;
4091     i.rem = R->totalModMapKeys;
4092     i.index = (char *) i.data - (char *) S;
4093     return i;
4094 }
4095 
4096 xcb_xkb_key_v_mod_map_t *
xcb_xkb_set_map_values_vmodmap(const xcb_xkb_set_map_values_t * S)4097 xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S)
4098 {
4099     return S->vmodmap;
4100 }
4101 
4102 int
xcb_xkb_set_map_values_vmodmap_length(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4103 xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R,
4104                                        const xcb_xkb_set_map_values_t *S)
4105 {
4106     return R->totalVModMapKeys;
4107 }
4108 
4109 xcb_xkb_key_v_mod_map_iterator_t
xcb_xkb_set_map_values_vmodmap_iterator(const xcb_xkb_set_map_request_t * R,const xcb_xkb_set_map_values_t * S)4110 xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R,
4111                                          const xcb_xkb_set_map_values_t *S)
4112 {
4113     xcb_xkb_key_v_mod_map_iterator_t i;
4114     i.data = S->vmodmap;
4115     i.rem = R->totalVModMapKeys;
4116     i.index = (char *) i.data - (char *) S;
4117     return i;
4118 }
4119 
4120 int
xcb_xkb_set_map_values_serialize(void ** _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,const xcb_xkb_set_map_values_t * _aux)4121 xcb_xkb_set_map_values_serialize (void                           **_buffer,
4122                                   uint8_t                          nTypes,
4123                                   uint8_t                          nKeySyms,
4124                                   uint8_t                          nKeyActions,
4125                                   uint16_t                         totalActions,
4126                                   uint8_t                          totalKeyBehaviors,
4127                                   uint16_t                         virtualMods,
4128                                   uint8_t                          totalKeyExplicit,
4129                                   uint8_t                          totalModMapKeys,
4130                                   uint8_t                          totalVModMapKeys,
4131                                   uint16_t                         present,
4132                                   const xcb_xkb_set_map_values_t  *_aux)
4133 {
4134     char *xcb_out = *_buffer;
4135     unsigned int xcb_buffer_len = 0;
4136     unsigned int xcb_align_to = 0;
4137     unsigned int xcb_padding_offset = 0;
4138 
4139     unsigned int xcb_pad = 0;
4140     char xcb_pad0[3] = {0, 0, 0};
4141     struct iovec xcb_parts[21];
4142     unsigned int xcb_parts_idx = 0;
4143     unsigned int xcb_block_len = 0;
4144     unsigned int i;
4145     char *xcb_tmp;
4146 
4147     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
4148         /* insert padding */
4149         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4150         xcb_buffer_len += xcb_block_len + xcb_pad;
4151         if (0 != xcb_pad) {
4152             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4153             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4154             xcb_parts_idx++;
4155             xcb_pad = 0;
4156         }
4157         xcb_block_len = 0;
4158         xcb_padding_offset = 0;
4159         /* types */
4160         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types;
4161         xcb_parts[xcb_parts_idx].iov_len = 0;
4162         xcb_tmp = (char *) _aux->types;
4163         for(i=0; i<nTypes; i++) {
4164             xcb_block_len = xcb_xkb_set_key_type_sizeof(xcb_tmp);
4165             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
4166         }
4167         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
4168         xcb_parts_idx++;
4169         xcb_align_to = ALIGNOF(xcb_xkb_set_key_type_t);
4170     }
4171     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
4172         /* insert padding */
4173         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4174         xcb_buffer_len += xcb_block_len + xcb_pad;
4175         if (0 != xcb_pad) {
4176             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4177             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4178             xcb_parts_idx++;
4179             xcb_pad = 0;
4180         }
4181         xcb_block_len = 0;
4182         xcb_padding_offset = 0;
4183         /* syms */
4184         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms;
4185         xcb_parts[xcb_parts_idx].iov_len = 0;
4186         xcb_tmp = (char *) _aux->syms;
4187         for(i=0; i<nKeySyms; i++) {
4188             xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
4189             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
4190         }
4191         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
4192         xcb_parts_idx++;
4193         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
4194     }
4195     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
4196         /* insert padding */
4197         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4198         xcb_buffer_len += xcb_block_len + xcb_pad;
4199         if (0 != xcb_pad) {
4200             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4201             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4202             xcb_parts_idx++;
4203             xcb_pad = 0;
4204         }
4205         xcb_block_len = 0;
4206         xcb_padding_offset = 0;
4207         /* actionsCount */
4208         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actionsCount;
4209         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
4210         xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
4211         xcb_parts_idx++;
4212         xcb_align_to = ALIGNOF(uint8_t);
4213         xcb_align_to = 4;
4214         /* insert padding */
4215         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4216         xcb_buffer_len += xcb_block_len + xcb_pad;
4217         if (0 != xcb_pad) {
4218             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4219             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4220             xcb_parts_idx++;
4221             xcb_pad = 0;
4222         }
4223         xcb_block_len = 0;
4224         xcb_padding_offset = 0;
4225         /* insert padding */
4226         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4227         xcb_buffer_len += xcb_block_len + xcb_pad;
4228         if (0 != xcb_pad) {
4229             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4230             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4231             xcb_parts_idx++;
4232             xcb_pad = 0;
4233         }
4234         xcb_block_len = 0;
4235         xcb_padding_offset = 0;
4236         /* actions */
4237         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actions;
4238         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
4239         xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
4240         xcb_parts_idx++;
4241         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
4242     }
4243     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
4244         /* insert padding */
4245         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4246         xcb_buffer_len += xcb_block_len + xcb_pad;
4247         if (0 != xcb_pad) {
4248             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4249             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4250             xcb_parts_idx++;
4251             xcb_pad = 0;
4252         }
4253         xcb_block_len = 0;
4254         xcb_padding_offset = 0;
4255         /* behaviors */
4256         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors;
4257         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
4258         xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
4259         xcb_parts_idx++;
4260         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
4261     }
4262     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
4263         /* insert padding */
4264         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4265         xcb_buffer_len += xcb_block_len + xcb_pad;
4266         if (0 != xcb_pad) {
4267             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4268             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4269             xcb_parts_idx++;
4270             xcb_pad = 0;
4271         }
4272         xcb_block_len = 0;
4273         xcb_padding_offset = 0;
4274         /* vmods */
4275         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods;
4276         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
4277         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
4278         xcb_parts_idx++;
4279         xcb_align_to = ALIGNOF(uint8_t);
4280         xcb_align_to = 4;
4281         /* insert padding */
4282         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4283         xcb_buffer_len += xcb_block_len + xcb_pad;
4284         if (0 != xcb_pad) {
4285             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4286             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4287             xcb_parts_idx++;
4288             xcb_pad = 0;
4289         }
4290         xcb_block_len = 0;
4291         xcb_padding_offset = 0;
4292     }
4293     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
4294         /* insert padding */
4295         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4296         xcb_buffer_len += xcb_block_len + xcb_pad;
4297         if (0 != xcb_pad) {
4298             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4299             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4300             xcb_parts_idx++;
4301             xcb_pad = 0;
4302         }
4303         xcb_block_len = 0;
4304         xcb_padding_offset = 0;
4305         /* explicit */
4306         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit;
4307         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
4308         xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
4309         xcb_parts_idx++;
4310         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
4311     }
4312     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
4313         /* insert padding */
4314         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4315         xcb_buffer_len += xcb_block_len + xcb_pad;
4316         if (0 != xcb_pad) {
4317             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4318             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4319             xcb_parts_idx++;
4320             xcb_pad = 0;
4321         }
4322         xcb_block_len = 0;
4323         xcb_padding_offset = 0;
4324         /* modmap */
4325         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap;
4326         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
4327         xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
4328         xcb_parts_idx++;
4329         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
4330     }
4331     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
4332         /* insert padding */
4333         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4334         xcb_buffer_len += xcb_block_len + xcb_pad;
4335         if (0 != xcb_pad) {
4336             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4337             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4338             xcb_parts_idx++;
4339             xcb_pad = 0;
4340         }
4341         xcb_block_len = 0;
4342         xcb_padding_offset = 0;
4343         /* vmodmap */
4344         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap;
4345         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
4346         xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
4347         xcb_parts_idx++;
4348         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
4349     }
4350     /* insert padding */
4351     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4352     xcb_buffer_len += xcb_block_len + xcb_pad;
4353     if (0 != xcb_pad) {
4354         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
4355         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
4356         xcb_parts_idx++;
4357         xcb_pad = 0;
4358     }
4359     xcb_block_len = 0;
4360     xcb_padding_offset = 0;
4361 
4362     if (NULL == xcb_out) {
4363         /* allocate memory */
4364         xcb_out = malloc(xcb_buffer_len);
4365         *_buffer = xcb_out;
4366     }
4367 
4368     xcb_tmp = xcb_out;
4369     for(i=0; i<xcb_parts_idx; i++) {
4370         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
4371             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
4372         if (0 != xcb_parts[i].iov_len)
4373             xcb_tmp += xcb_parts[i].iov_len;
4374     }
4375 
4376     return xcb_buffer_len;
4377 }
4378 
4379 int
xcb_xkb_set_map_values_unpack(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,xcb_xkb_set_map_values_t * _aux)4380 xcb_xkb_set_map_values_unpack (const void                *_buffer,
4381                                uint8_t                    nTypes,
4382                                uint8_t                    nKeySyms,
4383                                uint8_t                    nKeyActions,
4384                                uint16_t                   totalActions,
4385                                uint8_t                    totalKeyBehaviors,
4386                                uint16_t                   virtualMods,
4387                                uint8_t                    totalKeyExplicit,
4388                                uint8_t                    totalModMapKeys,
4389                                uint8_t                    totalVModMapKeys,
4390                                uint16_t                   present,
4391                                xcb_xkb_set_map_values_t  *_aux)
4392 {
4393     char *xcb_tmp = (char *)_buffer;
4394     unsigned int xcb_buffer_len = 0;
4395     unsigned int xcb_block_len = 0;
4396     unsigned int xcb_pad = 0;
4397     unsigned int xcb_align_to = 0;
4398     unsigned int xcb_padding_offset = 0;
4399 
4400     unsigned int i;
4401     unsigned int xcb_tmp_len;
4402 
4403     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
4404         /* insert padding */
4405         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4406         xcb_buffer_len += xcb_block_len + xcb_pad;
4407         if (0 != xcb_pad) {
4408             xcb_tmp += xcb_pad;
4409             xcb_pad = 0;
4410         }
4411         xcb_block_len = 0;
4412         xcb_padding_offset = 0;
4413         /* types */
4414         _aux->types = (xcb_xkb_set_key_type_t *)xcb_tmp;
4415         for(i=0; i<nTypes; i++) {
4416             xcb_tmp_len = xcb_xkb_set_key_type_sizeof(xcb_tmp);
4417             xcb_block_len += xcb_tmp_len;
4418             xcb_tmp += xcb_tmp_len;
4419         }
4420         xcb_align_to = ALIGNOF(xcb_xkb_set_key_type_t);
4421     }
4422     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
4423         /* insert padding */
4424         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4425         xcb_buffer_len += xcb_block_len + xcb_pad;
4426         if (0 != xcb_pad) {
4427             xcb_tmp += xcb_pad;
4428             xcb_pad = 0;
4429         }
4430         xcb_block_len = 0;
4431         xcb_padding_offset = 0;
4432         /* syms */
4433         _aux->syms = (xcb_xkb_key_sym_map_t *)xcb_tmp;
4434         for(i=0; i<nKeySyms; i++) {
4435             xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
4436             xcb_block_len += xcb_tmp_len;
4437             xcb_tmp += xcb_tmp_len;
4438         }
4439         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
4440     }
4441     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
4442         /* insert padding */
4443         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4444         xcb_buffer_len += xcb_block_len + xcb_pad;
4445         if (0 != xcb_pad) {
4446             xcb_tmp += xcb_pad;
4447             xcb_pad = 0;
4448         }
4449         xcb_block_len = 0;
4450         xcb_padding_offset = 0;
4451         /* actionsCount */
4452         _aux->actionsCount = (uint8_t *)xcb_tmp;
4453         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
4454         xcb_tmp += xcb_block_len;
4455         xcb_align_to = ALIGNOF(uint8_t);
4456         xcb_align_to = 4;
4457         /* insert padding */
4458         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4459         xcb_buffer_len += xcb_block_len + xcb_pad;
4460         if (0 != xcb_pad) {
4461             xcb_tmp += xcb_pad;
4462             xcb_pad = 0;
4463         }
4464         xcb_block_len = 0;
4465         xcb_padding_offset = 0;
4466         /* insert padding */
4467         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4468         xcb_buffer_len += xcb_block_len + xcb_pad;
4469         if (0 != xcb_pad) {
4470             xcb_tmp += xcb_pad;
4471             xcb_pad = 0;
4472         }
4473         xcb_block_len = 0;
4474         xcb_padding_offset = 0;
4475         /* actions */
4476         _aux->actions = (xcb_xkb_action_t *)xcb_tmp;
4477         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
4478         xcb_tmp += xcb_block_len;
4479         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
4480     }
4481     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
4482         /* insert padding */
4483         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4484         xcb_buffer_len += xcb_block_len + xcb_pad;
4485         if (0 != xcb_pad) {
4486             xcb_tmp += xcb_pad;
4487             xcb_pad = 0;
4488         }
4489         xcb_block_len = 0;
4490         xcb_padding_offset = 0;
4491         /* behaviors */
4492         _aux->behaviors = (xcb_xkb_set_behavior_t *)xcb_tmp;
4493         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
4494         xcb_tmp += xcb_block_len;
4495         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
4496     }
4497     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
4498         /* insert padding */
4499         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4500         xcb_buffer_len += xcb_block_len + xcb_pad;
4501         if (0 != xcb_pad) {
4502             xcb_tmp += xcb_pad;
4503             xcb_pad = 0;
4504         }
4505         xcb_block_len = 0;
4506         xcb_padding_offset = 0;
4507         /* vmods */
4508         _aux->vmods = (uint8_t *)xcb_tmp;
4509         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
4510         xcb_tmp += xcb_block_len;
4511         xcb_align_to = ALIGNOF(uint8_t);
4512         xcb_align_to = 4;
4513         /* insert padding */
4514         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4515         xcb_buffer_len += xcb_block_len + xcb_pad;
4516         if (0 != xcb_pad) {
4517             xcb_tmp += xcb_pad;
4518             xcb_pad = 0;
4519         }
4520         xcb_block_len = 0;
4521         xcb_padding_offset = 0;
4522     }
4523     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
4524         /* insert padding */
4525         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4526         xcb_buffer_len += xcb_block_len + xcb_pad;
4527         if (0 != xcb_pad) {
4528             xcb_tmp += xcb_pad;
4529             xcb_pad = 0;
4530         }
4531         xcb_block_len = 0;
4532         xcb_padding_offset = 0;
4533         /* explicit */
4534         _aux->explicit = (xcb_xkb_set_explicit_t *)xcb_tmp;
4535         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
4536         xcb_tmp += xcb_block_len;
4537         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
4538     }
4539     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
4540         /* insert padding */
4541         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4542         xcb_buffer_len += xcb_block_len + xcb_pad;
4543         if (0 != xcb_pad) {
4544             xcb_tmp += xcb_pad;
4545             xcb_pad = 0;
4546         }
4547         xcb_block_len = 0;
4548         xcb_padding_offset = 0;
4549         /* modmap */
4550         _aux->modmap = (xcb_xkb_key_mod_map_t *)xcb_tmp;
4551         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
4552         xcb_tmp += xcb_block_len;
4553         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
4554     }
4555     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
4556         /* insert padding */
4557         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4558         xcb_buffer_len += xcb_block_len + xcb_pad;
4559         if (0 != xcb_pad) {
4560             xcb_tmp += xcb_pad;
4561             xcb_pad = 0;
4562         }
4563         xcb_block_len = 0;
4564         xcb_padding_offset = 0;
4565         /* vmodmap */
4566         _aux->vmodmap = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
4567         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
4568         xcb_tmp += xcb_block_len;
4569         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
4570     }
4571     /* insert padding */
4572     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
4573     xcb_buffer_len += xcb_block_len + xcb_pad;
4574     if (0 != xcb_pad) {
4575         xcb_tmp += xcb_pad;
4576         xcb_pad = 0;
4577     }
4578     xcb_block_len = 0;
4579     xcb_padding_offset = 0;
4580 
4581     return xcb_buffer_len;
4582 }
4583 
4584 int
xcb_xkb_set_map_values_sizeof(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present)4585 xcb_xkb_set_map_values_sizeof (const void  *_buffer,
4586                                uint8_t      nTypes,
4587                                uint8_t      nKeySyms,
4588                                uint8_t      nKeyActions,
4589                                uint16_t     totalActions,
4590                                uint8_t      totalKeyBehaviors,
4591                                uint16_t     virtualMods,
4592                                uint8_t      totalKeyExplicit,
4593                                uint8_t      totalModMapKeys,
4594                                uint8_t      totalVModMapKeys,
4595                                uint16_t     present)
4596 {
4597     xcb_xkb_set_map_values_t _aux;
4598     return xcb_xkb_set_map_values_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
4599 }
4600 
4601 int
xcb_xkb_set_map_sizeof(const void * _buffer)4602 xcb_xkb_set_map_sizeof (const void  *_buffer)
4603 {
4604     char *xcb_tmp = (char *)_buffer;
4605     const xcb_xkb_set_map_request_t *_aux = (xcb_xkb_set_map_request_t *)_buffer;
4606     unsigned int xcb_buffer_len = 0;
4607     unsigned int xcb_block_len = 0;
4608     unsigned int xcb_pad = 0;
4609     unsigned int xcb_align_to = 0;
4610 
4611 
4612     xcb_block_len += sizeof(xcb_xkb_set_map_request_t);
4613     xcb_tmp += xcb_block_len;
4614     xcb_buffer_len += xcb_block_len;
4615     xcb_block_len = 0;
4616     /* values */
4617     xcb_block_len += xcb_xkb_set_map_values_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present);
4618     xcb_tmp += xcb_block_len;
4619     xcb_align_to = ALIGNOF(char);
4620     /* insert padding */
4621     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4622     xcb_buffer_len += xcb_block_len + xcb_pad;
4623     if (0 != xcb_pad) {
4624         xcb_tmp += xcb_pad;
4625         xcb_pad = 0;
4626     }
4627     xcb_block_len = 0;
4628 
4629     return xcb_buffer_len;
4630 }
4631 
4632 xcb_void_cookie_t
xcb_xkb_set_map_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t present,uint16_t flags,xcb_keycode_t minKeyCode,xcb_keycode_t maxKeyCode,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,uint16_t totalSyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,uint16_t totalActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint8_t totalKeyBehaviors,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,uint8_t totalKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,uint8_t totalModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys,uint8_t totalVModMapKeys,uint16_t virtualMods,const void * values)4633 xcb_xkb_set_map_checked (xcb_connection_t      *c,
4634                          xcb_xkb_device_spec_t  deviceSpec,
4635                          uint16_t               present,
4636                          uint16_t               flags,
4637                          xcb_keycode_t          minKeyCode,
4638                          xcb_keycode_t          maxKeyCode,
4639                          uint8_t                firstType,
4640                          uint8_t                nTypes,
4641                          xcb_keycode_t          firstKeySym,
4642                          uint8_t                nKeySyms,
4643                          uint16_t               totalSyms,
4644                          xcb_keycode_t          firstKeyAction,
4645                          uint8_t                nKeyActions,
4646                          uint16_t               totalActions,
4647                          xcb_keycode_t          firstKeyBehavior,
4648                          uint8_t                nKeyBehaviors,
4649                          uint8_t                totalKeyBehaviors,
4650                          xcb_keycode_t          firstKeyExplicit,
4651                          uint8_t                nKeyExplicit,
4652                          uint8_t                totalKeyExplicit,
4653                          xcb_keycode_t          firstModMapKey,
4654                          uint8_t                nModMapKeys,
4655                          uint8_t                totalModMapKeys,
4656                          xcb_keycode_t          firstVModMapKey,
4657                          uint8_t                nVModMapKeys,
4658                          uint8_t                totalVModMapKeys,
4659                          uint16_t               virtualMods,
4660                          const void            *values)
4661 {
4662     static const xcb_protocol_request_t xcb_req = {
4663         .count = 3,
4664         .ext = &xcb_xkb_id,
4665         .opcode = XCB_XKB_SET_MAP,
4666         .isvoid = 1
4667     };
4668 
4669     struct iovec xcb_parts[5];
4670     xcb_void_cookie_t xcb_ret;
4671     xcb_xkb_set_map_request_t xcb_out;
4672 
4673     xcb_out.deviceSpec = deviceSpec;
4674     xcb_out.present = present;
4675     xcb_out.flags = flags;
4676     xcb_out.minKeyCode = minKeyCode;
4677     xcb_out.maxKeyCode = maxKeyCode;
4678     xcb_out.firstType = firstType;
4679     xcb_out.nTypes = nTypes;
4680     xcb_out.firstKeySym = firstKeySym;
4681     xcb_out.nKeySyms = nKeySyms;
4682     xcb_out.totalSyms = totalSyms;
4683     xcb_out.firstKeyAction = firstKeyAction;
4684     xcb_out.nKeyActions = nKeyActions;
4685     xcb_out.totalActions = totalActions;
4686     xcb_out.firstKeyBehavior = firstKeyBehavior;
4687     xcb_out.nKeyBehaviors = nKeyBehaviors;
4688     xcb_out.totalKeyBehaviors = totalKeyBehaviors;
4689     xcb_out.firstKeyExplicit = firstKeyExplicit;
4690     xcb_out.nKeyExplicit = nKeyExplicit;
4691     xcb_out.totalKeyExplicit = totalKeyExplicit;
4692     xcb_out.firstModMapKey = firstModMapKey;
4693     xcb_out.nModMapKeys = nModMapKeys;
4694     xcb_out.totalModMapKeys = totalModMapKeys;
4695     xcb_out.firstVModMapKey = firstVModMapKey;
4696     xcb_out.nVModMapKeys = nVModMapKeys;
4697     xcb_out.totalVModMapKeys = totalVModMapKeys;
4698     xcb_out.virtualMods = virtualMods;
4699 
4700     xcb_parts[2].iov_base = (char *) &xcb_out;
4701     xcb_parts[2].iov_len = sizeof(xcb_out);
4702     xcb_parts[3].iov_base = 0;
4703     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4704     /* xcb_xkb_set_map_values_t values */
4705     xcb_parts[4].iov_base = (char *) values;
4706     xcb_parts[4].iov_len =
4707       xcb_xkb_set_map_values_sizeof (values, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present);
4708 
4709     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4710     return xcb_ret;
4711 }
4712 
4713 xcb_void_cookie_t
xcb_xkb_set_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t present,uint16_t flags,xcb_keycode_t minKeyCode,xcb_keycode_t maxKeyCode,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,uint16_t totalSyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,uint16_t totalActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint8_t totalKeyBehaviors,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,uint8_t totalKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,uint8_t totalModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys,uint8_t totalVModMapKeys,uint16_t virtualMods,const void * values)4714 xcb_xkb_set_map (xcb_connection_t      *c,
4715                  xcb_xkb_device_spec_t  deviceSpec,
4716                  uint16_t               present,
4717                  uint16_t               flags,
4718                  xcb_keycode_t          minKeyCode,
4719                  xcb_keycode_t          maxKeyCode,
4720                  uint8_t                firstType,
4721                  uint8_t                nTypes,
4722                  xcb_keycode_t          firstKeySym,
4723                  uint8_t                nKeySyms,
4724                  uint16_t               totalSyms,
4725                  xcb_keycode_t          firstKeyAction,
4726                  uint8_t                nKeyActions,
4727                  uint16_t               totalActions,
4728                  xcb_keycode_t          firstKeyBehavior,
4729                  uint8_t                nKeyBehaviors,
4730                  uint8_t                totalKeyBehaviors,
4731                  xcb_keycode_t          firstKeyExplicit,
4732                  uint8_t                nKeyExplicit,
4733                  uint8_t                totalKeyExplicit,
4734                  xcb_keycode_t          firstModMapKey,
4735                  uint8_t                nModMapKeys,
4736                  uint8_t                totalModMapKeys,
4737                  xcb_keycode_t          firstVModMapKey,
4738                  uint8_t                nVModMapKeys,
4739                  uint8_t                totalVModMapKeys,
4740                  uint16_t               virtualMods,
4741                  const void            *values)
4742 {
4743     static const xcb_protocol_request_t xcb_req = {
4744         .count = 3,
4745         .ext = &xcb_xkb_id,
4746         .opcode = XCB_XKB_SET_MAP,
4747         .isvoid = 1
4748     };
4749 
4750     struct iovec xcb_parts[5];
4751     xcb_void_cookie_t xcb_ret;
4752     xcb_xkb_set_map_request_t xcb_out;
4753 
4754     xcb_out.deviceSpec = deviceSpec;
4755     xcb_out.present = present;
4756     xcb_out.flags = flags;
4757     xcb_out.minKeyCode = minKeyCode;
4758     xcb_out.maxKeyCode = maxKeyCode;
4759     xcb_out.firstType = firstType;
4760     xcb_out.nTypes = nTypes;
4761     xcb_out.firstKeySym = firstKeySym;
4762     xcb_out.nKeySyms = nKeySyms;
4763     xcb_out.totalSyms = totalSyms;
4764     xcb_out.firstKeyAction = firstKeyAction;
4765     xcb_out.nKeyActions = nKeyActions;
4766     xcb_out.totalActions = totalActions;
4767     xcb_out.firstKeyBehavior = firstKeyBehavior;
4768     xcb_out.nKeyBehaviors = nKeyBehaviors;
4769     xcb_out.totalKeyBehaviors = totalKeyBehaviors;
4770     xcb_out.firstKeyExplicit = firstKeyExplicit;
4771     xcb_out.nKeyExplicit = nKeyExplicit;
4772     xcb_out.totalKeyExplicit = totalKeyExplicit;
4773     xcb_out.firstModMapKey = firstModMapKey;
4774     xcb_out.nModMapKeys = nModMapKeys;
4775     xcb_out.totalModMapKeys = totalModMapKeys;
4776     xcb_out.firstVModMapKey = firstVModMapKey;
4777     xcb_out.nVModMapKeys = nVModMapKeys;
4778     xcb_out.totalVModMapKeys = totalVModMapKeys;
4779     xcb_out.virtualMods = virtualMods;
4780 
4781     xcb_parts[2].iov_base = (char *) &xcb_out;
4782     xcb_parts[2].iov_len = sizeof(xcb_out);
4783     xcb_parts[3].iov_base = 0;
4784     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4785     /* xcb_xkb_set_map_values_t values */
4786     xcb_parts[4].iov_base = (char *) values;
4787     xcb_parts[4].iov_len =
4788       xcb_xkb_set_map_values_sizeof (values, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present);
4789 
4790     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4791     return xcb_ret;
4792 }
4793 
4794 xcb_void_cookie_t
xcb_xkb_set_map_aux_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t present,uint16_t flags,xcb_keycode_t minKeyCode,xcb_keycode_t maxKeyCode,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,uint16_t totalSyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,uint16_t totalActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint8_t totalKeyBehaviors,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,uint8_t totalKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,uint8_t totalModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys,uint8_t totalVModMapKeys,uint16_t virtualMods,const xcb_xkb_set_map_values_t * values)4795 xcb_xkb_set_map_aux_checked (xcb_connection_t               *c,
4796                              xcb_xkb_device_spec_t           deviceSpec,
4797                              uint16_t                        present,
4798                              uint16_t                        flags,
4799                              xcb_keycode_t                   minKeyCode,
4800                              xcb_keycode_t                   maxKeyCode,
4801                              uint8_t                         firstType,
4802                              uint8_t                         nTypes,
4803                              xcb_keycode_t                   firstKeySym,
4804                              uint8_t                         nKeySyms,
4805                              uint16_t                        totalSyms,
4806                              xcb_keycode_t                   firstKeyAction,
4807                              uint8_t                         nKeyActions,
4808                              uint16_t                        totalActions,
4809                              xcb_keycode_t                   firstKeyBehavior,
4810                              uint8_t                         nKeyBehaviors,
4811                              uint8_t                         totalKeyBehaviors,
4812                              xcb_keycode_t                   firstKeyExplicit,
4813                              uint8_t                         nKeyExplicit,
4814                              uint8_t                         totalKeyExplicit,
4815                              xcb_keycode_t                   firstModMapKey,
4816                              uint8_t                         nModMapKeys,
4817                              uint8_t                         totalModMapKeys,
4818                              xcb_keycode_t                   firstVModMapKey,
4819                              uint8_t                         nVModMapKeys,
4820                              uint8_t                         totalVModMapKeys,
4821                              uint16_t                        virtualMods,
4822                              const xcb_xkb_set_map_values_t *values)
4823 {
4824     static const xcb_protocol_request_t xcb_req = {
4825         .count = 3,
4826         .ext = &xcb_xkb_id,
4827         .opcode = XCB_XKB_SET_MAP,
4828         .isvoid = 1
4829     };
4830 
4831     struct iovec xcb_parts[5];
4832     xcb_void_cookie_t xcb_ret;
4833     xcb_xkb_set_map_request_t xcb_out;
4834     void *xcb_aux0 = 0;
4835 
4836     xcb_out.deviceSpec = deviceSpec;
4837     xcb_out.present = present;
4838     xcb_out.flags = flags;
4839     xcb_out.minKeyCode = minKeyCode;
4840     xcb_out.maxKeyCode = maxKeyCode;
4841     xcb_out.firstType = firstType;
4842     xcb_out.nTypes = nTypes;
4843     xcb_out.firstKeySym = firstKeySym;
4844     xcb_out.nKeySyms = nKeySyms;
4845     xcb_out.totalSyms = totalSyms;
4846     xcb_out.firstKeyAction = firstKeyAction;
4847     xcb_out.nKeyActions = nKeyActions;
4848     xcb_out.totalActions = totalActions;
4849     xcb_out.firstKeyBehavior = firstKeyBehavior;
4850     xcb_out.nKeyBehaviors = nKeyBehaviors;
4851     xcb_out.totalKeyBehaviors = totalKeyBehaviors;
4852     xcb_out.firstKeyExplicit = firstKeyExplicit;
4853     xcb_out.nKeyExplicit = nKeyExplicit;
4854     xcb_out.totalKeyExplicit = totalKeyExplicit;
4855     xcb_out.firstModMapKey = firstModMapKey;
4856     xcb_out.nModMapKeys = nModMapKeys;
4857     xcb_out.totalModMapKeys = totalModMapKeys;
4858     xcb_out.firstVModMapKey = firstVModMapKey;
4859     xcb_out.nVModMapKeys = nVModMapKeys;
4860     xcb_out.totalVModMapKeys = totalVModMapKeys;
4861     xcb_out.virtualMods = virtualMods;
4862 
4863     xcb_parts[2].iov_base = (char *) &xcb_out;
4864     xcb_parts[2].iov_len = sizeof(xcb_out);
4865     xcb_parts[3].iov_base = 0;
4866     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4867     /* xcb_xkb_set_map_values_t values */
4868     xcb_parts[4].iov_len =
4869       xcb_xkb_set_map_values_serialize (&xcb_aux0, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, values);
4870     xcb_parts[4].iov_base = xcb_aux0;
4871 
4872     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
4873     free(xcb_aux0);
4874     return xcb_ret;
4875 }
4876 
4877 xcb_void_cookie_t
xcb_xkb_set_map_aux(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t present,uint16_t flags,xcb_keycode_t minKeyCode,xcb_keycode_t maxKeyCode,uint8_t firstType,uint8_t nTypes,xcb_keycode_t firstKeySym,uint8_t nKeySyms,uint16_t totalSyms,xcb_keycode_t firstKeyAction,uint8_t nKeyActions,uint16_t totalActions,xcb_keycode_t firstKeyBehavior,uint8_t nKeyBehaviors,uint8_t totalKeyBehaviors,xcb_keycode_t firstKeyExplicit,uint8_t nKeyExplicit,uint8_t totalKeyExplicit,xcb_keycode_t firstModMapKey,uint8_t nModMapKeys,uint8_t totalModMapKeys,xcb_keycode_t firstVModMapKey,uint8_t nVModMapKeys,uint8_t totalVModMapKeys,uint16_t virtualMods,const xcb_xkb_set_map_values_t * values)4878 xcb_xkb_set_map_aux (xcb_connection_t               *c,
4879                      xcb_xkb_device_spec_t           deviceSpec,
4880                      uint16_t                        present,
4881                      uint16_t                        flags,
4882                      xcb_keycode_t                   minKeyCode,
4883                      xcb_keycode_t                   maxKeyCode,
4884                      uint8_t                         firstType,
4885                      uint8_t                         nTypes,
4886                      xcb_keycode_t                   firstKeySym,
4887                      uint8_t                         nKeySyms,
4888                      uint16_t                        totalSyms,
4889                      xcb_keycode_t                   firstKeyAction,
4890                      uint8_t                         nKeyActions,
4891                      uint16_t                        totalActions,
4892                      xcb_keycode_t                   firstKeyBehavior,
4893                      uint8_t                         nKeyBehaviors,
4894                      uint8_t                         totalKeyBehaviors,
4895                      xcb_keycode_t                   firstKeyExplicit,
4896                      uint8_t                         nKeyExplicit,
4897                      uint8_t                         totalKeyExplicit,
4898                      xcb_keycode_t                   firstModMapKey,
4899                      uint8_t                         nModMapKeys,
4900                      uint8_t                         totalModMapKeys,
4901                      xcb_keycode_t                   firstVModMapKey,
4902                      uint8_t                         nVModMapKeys,
4903                      uint8_t                         totalVModMapKeys,
4904                      uint16_t                        virtualMods,
4905                      const xcb_xkb_set_map_values_t *values)
4906 {
4907     static const xcb_protocol_request_t xcb_req = {
4908         .count = 3,
4909         .ext = &xcb_xkb_id,
4910         .opcode = XCB_XKB_SET_MAP,
4911         .isvoid = 1
4912     };
4913 
4914     struct iovec xcb_parts[5];
4915     xcb_void_cookie_t xcb_ret;
4916     xcb_xkb_set_map_request_t xcb_out;
4917     void *xcb_aux0 = 0;
4918 
4919     xcb_out.deviceSpec = deviceSpec;
4920     xcb_out.present = present;
4921     xcb_out.flags = flags;
4922     xcb_out.minKeyCode = minKeyCode;
4923     xcb_out.maxKeyCode = maxKeyCode;
4924     xcb_out.firstType = firstType;
4925     xcb_out.nTypes = nTypes;
4926     xcb_out.firstKeySym = firstKeySym;
4927     xcb_out.nKeySyms = nKeySyms;
4928     xcb_out.totalSyms = totalSyms;
4929     xcb_out.firstKeyAction = firstKeyAction;
4930     xcb_out.nKeyActions = nKeyActions;
4931     xcb_out.totalActions = totalActions;
4932     xcb_out.firstKeyBehavior = firstKeyBehavior;
4933     xcb_out.nKeyBehaviors = nKeyBehaviors;
4934     xcb_out.totalKeyBehaviors = totalKeyBehaviors;
4935     xcb_out.firstKeyExplicit = firstKeyExplicit;
4936     xcb_out.nKeyExplicit = nKeyExplicit;
4937     xcb_out.totalKeyExplicit = totalKeyExplicit;
4938     xcb_out.firstModMapKey = firstModMapKey;
4939     xcb_out.nModMapKeys = nModMapKeys;
4940     xcb_out.totalModMapKeys = totalModMapKeys;
4941     xcb_out.firstVModMapKey = firstVModMapKey;
4942     xcb_out.nVModMapKeys = nVModMapKeys;
4943     xcb_out.totalVModMapKeys = totalVModMapKeys;
4944     xcb_out.virtualMods = virtualMods;
4945 
4946     xcb_parts[2].iov_base = (char *) &xcb_out;
4947     xcb_parts[2].iov_len = sizeof(xcb_out);
4948     xcb_parts[3].iov_base = 0;
4949     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
4950     /* xcb_xkb_set_map_values_t values */
4951     xcb_parts[4].iov_len =
4952       xcb_xkb_set_map_values_serialize (&xcb_aux0, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, values);
4953     xcb_parts[4].iov_base = xcb_aux0;
4954 
4955     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
4956     free(xcb_aux0);
4957     return xcb_ret;
4958 }
4959 
4960 void *
xcb_xkb_set_map_values(const xcb_xkb_set_map_request_t * R)4961 xcb_xkb_set_map_values (const xcb_xkb_set_map_request_t *R)
4962 {
4963     return (void *) (R + 1);
4964 }
4965 
4966 int
xcb_xkb_get_compat_map_sizeof(const void * _buffer)4967 xcb_xkb_get_compat_map_sizeof (const void  *_buffer)
4968 {
4969     char *xcb_tmp = (char *)_buffer;
4970     const xcb_xkb_get_compat_map_reply_t *_aux = (xcb_xkb_get_compat_map_reply_t *)_buffer;
4971     unsigned int xcb_buffer_len = 0;
4972     unsigned int xcb_block_len = 0;
4973     unsigned int xcb_pad = 0;
4974     unsigned int xcb_align_to = 0;
4975 
4976 
4977     xcb_block_len += sizeof(xcb_xkb_get_compat_map_reply_t);
4978     xcb_tmp += xcb_block_len;
4979     xcb_buffer_len += xcb_block_len;
4980     xcb_block_len = 0;
4981     /* si_rtrn */
4982     xcb_block_len += _aux->nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
4983     xcb_tmp += xcb_block_len;
4984     xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
4985     /* insert padding */
4986     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4987     xcb_buffer_len += xcb_block_len + xcb_pad;
4988     if (0 != xcb_pad) {
4989         xcb_tmp += xcb_pad;
4990         xcb_pad = 0;
4991     }
4992     xcb_block_len = 0;
4993     /* group_rtrn */
4994     xcb_block_len += xcb_popcount(_aux->groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
4995     xcb_tmp += xcb_block_len;
4996     xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
4997     /* insert padding */
4998     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
4999     xcb_buffer_len += xcb_block_len + xcb_pad;
5000     if (0 != xcb_pad) {
5001         xcb_tmp += xcb_pad;
5002         xcb_pad = 0;
5003     }
5004     xcb_block_len = 0;
5005 
5006     return xcb_buffer_len;
5007 }
5008 
5009 xcb_xkb_get_compat_map_cookie_t
xcb_xkb_get_compat_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t groups,uint8_t getAllSI,uint16_t firstSI,uint16_t nSI)5010 xcb_xkb_get_compat_map (xcb_connection_t      *c,
5011                         xcb_xkb_device_spec_t  deviceSpec,
5012                         uint8_t                groups,
5013                         uint8_t                getAllSI,
5014                         uint16_t               firstSI,
5015                         uint16_t               nSI)
5016 {
5017     static const xcb_protocol_request_t xcb_req = {
5018         .count = 2,
5019         .ext = &xcb_xkb_id,
5020         .opcode = XCB_XKB_GET_COMPAT_MAP,
5021         .isvoid = 0
5022     };
5023 
5024     struct iovec xcb_parts[4];
5025     xcb_xkb_get_compat_map_cookie_t xcb_ret;
5026     xcb_xkb_get_compat_map_request_t xcb_out;
5027 
5028     xcb_out.deviceSpec = deviceSpec;
5029     xcb_out.groups = groups;
5030     xcb_out.getAllSI = getAllSI;
5031     xcb_out.firstSI = firstSI;
5032     xcb_out.nSI = nSI;
5033 
5034     xcb_parts[2].iov_base = (char *) &xcb_out;
5035     xcb_parts[2].iov_len = sizeof(xcb_out);
5036     xcb_parts[3].iov_base = 0;
5037     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5038 
5039     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5040     return xcb_ret;
5041 }
5042 
5043 xcb_xkb_get_compat_map_cookie_t
xcb_xkb_get_compat_map_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t groups,uint8_t getAllSI,uint16_t firstSI,uint16_t nSI)5044 xcb_xkb_get_compat_map_unchecked (xcb_connection_t      *c,
5045                                   xcb_xkb_device_spec_t  deviceSpec,
5046                                   uint8_t                groups,
5047                                   uint8_t                getAllSI,
5048                                   uint16_t               firstSI,
5049                                   uint16_t               nSI)
5050 {
5051     static const xcb_protocol_request_t xcb_req = {
5052         .count = 2,
5053         .ext = &xcb_xkb_id,
5054         .opcode = XCB_XKB_GET_COMPAT_MAP,
5055         .isvoid = 0
5056     };
5057 
5058     struct iovec xcb_parts[4];
5059     xcb_xkb_get_compat_map_cookie_t xcb_ret;
5060     xcb_xkb_get_compat_map_request_t xcb_out;
5061 
5062     xcb_out.deviceSpec = deviceSpec;
5063     xcb_out.groups = groups;
5064     xcb_out.getAllSI = getAllSI;
5065     xcb_out.firstSI = firstSI;
5066     xcb_out.nSI = nSI;
5067 
5068     xcb_parts[2].iov_base = (char *) &xcb_out;
5069     xcb_parts[2].iov_len = sizeof(xcb_out);
5070     xcb_parts[3].iov_base = 0;
5071     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5072 
5073     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5074     return xcb_ret;
5075 }
5076 
5077 xcb_xkb_sym_interpret_t *
xcb_xkb_get_compat_map_si_rtrn(const xcb_xkb_get_compat_map_reply_t * R)5078 xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R)
5079 {
5080     return (xcb_xkb_sym_interpret_t *) (R + 1);
5081 }
5082 
5083 int
xcb_xkb_get_compat_map_si_rtrn_length(const xcb_xkb_get_compat_map_reply_t * R)5084 xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R)
5085 {
5086     return R->nSIRtrn;
5087 }
5088 
5089 xcb_xkb_sym_interpret_iterator_t
xcb_xkb_get_compat_map_si_rtrn_iterator(const xcb_xkb_get_compat_map_reply_t * R)5090 xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R)
5091 {
5092     xcb_xkb_sym_interpret_iterator_t i;
5093     i.data = (xcb_xkb_sym_interpret_t *) (R + 1);
5094     i.rem = R->nSIRtrn;
5095     i.index = (char *) i.data - (char *) R;
5096     return i;
5097 }
5098 
5099 xcb_xkb_mod_def_t *
xcb_xkb_get_compat_map_group_rtrn(const xcb_xkb_get_compat_map_reply_t * R)5100 xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R)
5101 {
5102     xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R));
5103     return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
5104 }
5105 
5106 int
xcb_xkb_get_compat_map_group_rtrn_length(const xcb_xkb_get_compat_map_reply_t * R)5107 xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R)
5108 {
5109     return xcb_popcount(R->groupsRtrn);
5110 }
5111 
5112 xcb_xkb_mod_def_iterator_t
xcb_xkb_get_compat_map_group_rtrn_iterator(const xcb_xkb_get_compat_map_reply_t * R)5113 xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R)
5114 {
5115     xcb_xkb_mod_def_iterator_t i;
5116     xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R));
5117     i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
5118     i.rem = xcb_popcount(R->groupsRtrn);
5119     i.index = (char *) i.data - (char *) R;
5120     return i;
5121 }
5122 
5123 xcb_xkb_get_compat_map_reply_t *
xcb_xkb_get_compat_map_reply(xcb_connection_t * c,xcb_xkb_get_compat_map_cookie_t cookie,xcb_generic_error_t ** e)5124 xcb_xkb_get_compat_map_reply (xcb_connection_t                 *c,
5125                               xcb_xkb_get_compat_map_cookie_t   cookie  /**< */,
5126                               xcb_generic_error_t             **e)
5127 {
5128     return (xcb_xkb_get_compat_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5129 }
5130 
5131 int
xcb_xkb_set_compat_map_sizeof(const void * _buffer)5132 xcb_xkb_set_compat_map_sizeof (const void  *_buffer)
5133 {
5134     char *xcb_tmp = (char *)_buffer;
5135     const xcb_xkb_set_compat_map_request_t *_aux = (xcb_xkb_set_compat_map_request_t *)_buffer;
5136     unsigned int xcb_buffer_len = 0;
5137     unsigned int xcb_block_len = 0;
5138     unsigned int xcb_pad = 0;
5139     unsigned int xcb_align_to = 0;
5140 
5141 
5142     xcb_block_len += sizeof(xcb_xkb_set_compat_map_request_t);
5143     xcb_tmp += xcb_block_len;
5144     xcb_buffer_len += xcb_block_len;
5145     xcb_block_len = 0;
5146     /* si */
5147     xcb_block_len += _aux->nSI * sizeof(xcb_xkb_sym_interpret_t);
5148     xcb_tmp += xcb_block_len;
5149     xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
5150     /* insert padding */
5151     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5152     xcb_buffer_len += xcb_block_len + xcb_pad;
5153     if (0 != xcb_pad) {
5154         xcb_tmp += xcb_pad;
5155         xcb_pad = 0;
5156     }
5157     xcb_block_len = 0;
5158     /* groupMaps */
5159     xcb_block_len += xcb_popcount(_aux->groups) * sizeof(xcb_xkb_mod_def_t);
5160     xcb_tmp += xcb_block_len;
5161     xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
5162     /* insert padding */
5163     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5164     xcb_buffer_len += xcb_block_len + xcb_pad;
5165     if (0 != xcb_pad) {
5166         xcb_tmp += xcb_pad;
5167         xcb_pad = 0;
5168     }
5169     xcb_block_len = 0;
5170 
5171     return xcb_buffer_len;
5172 }
5173 
5174 xcb_void_cookie_t
xcb_xkb_set_compat_map_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t recomputeActions,uint8_t truncateSI,uint8_t groups,uint16_t firstSI,uint16_t nSI,const xcb_xkb_sym_interpret_t * si,const xcb_xkb_mod_def_t * groupMaps)5175 xcb_xkb_set_compat_map_checked (xcb_connection_t              *c,
5176                                 xcb_xkb_device_spec_t          deviceSpec,
5177                                 uint8_t                        recomputeActions,
5178                                 uint8_t                        truncateSI,
5179                                 uint8_t                        groups,
5180                                 uint16_t                       firstSI,
5181                                 uint16_t                       nSI,
5182                                 const xcb_xkb_sym_interpret_t *si,
5183                                 const xcb_xkb_mod_def_t       *groupMaps)
5184 {
5185     static const xcb_protocol_request_t xcb_req = {
5186         .count = 6,
5187         .ext = &xcb_xkb_id,
5188         .opcode = XCB_XKB_SET_COMPAT_MAP,
5189         .isvoid = 1
5190     };
5191 
5192     struct iovec xcb_parts[8];
5193     xcb_void_cookie_t xcb_ret;
5194     xcb_xkb_set_compat_map_request_t xcb_out;
5195 
5196     xcb_out.deviceSpec = deviceSpec;
5197     xcb_out.pad0 = 0;
5198     xcb_out.recomputeActions = recomputeActions;
5199     xcb_out.truncateSI = truncateSI;
5200     xcb_out.groups = groups;
5201     xcb_out.firstSI = firstSI;
5202     xcb_out.nSI = nSI;
5203     memset(xcb_out.pad1, 0, 2);
5204 
5205     xcb_parts[2].iov_base = (char *) &xcb_out;
5206     xcb_parts[2].iov_len = sizeof(xcb_out);
5207     xcb_parts[3].iov_base = 0;
5208     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5209     /* xcb_xkb_sym_interpret_t si */
5210     xcb_parts[4].iov_base = (char *) si;
5211     xcb_parts[4].iov_len = nSI * sizeof(xcb_xkb_sym_interpret_t);
5212     xcb_parts[5].iov_base = 0;
5213     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5214     /* xcb_xkb_mod_def_t groupMaps */
5215     xcb_parts[6].iov_base = (char *) groupMaps;
5216     xcb_parts[6].iov_len = xcb_popcount(groups) * sizeof(xcb_xkb_mod_def_t);
5217     xcb_parts[7].iov_base = 0;
5218     xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
5219 
5220     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5221     return xcb_ret;
5222 }
5223 
5224 xcb_void_cookie_t
xcb_xkb_set_compat_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t recomputeActions,uint8_t truncateSI,uint8_t groups,uint16_t firstSI,uint16_t nSI,const xcb_xkb_sym_interpret_t * si,const xcb_xkb_mod_def_t * groupMaps)5225 xcb_xkb_set_compat_map (xcb_connection_t              *c,
5226                         xcb_xkb_device_spec_t          deviceSpec,
5227                         uint8_t                        recomputeActions,
5228                         uint8_t                        truncateSI,
5229                         uint8_t                        groups,
5230                         uint16_t                       firstSI,
5231                         uint16_t                       nSI,
5232                         const xcb_xkb_sym_interpret_t *si,
5233                         const xcb_xkb_mod_def_t       *groupMaps)
5234 {
5235     static const xcb_protocol_request_t xcb_req = {
5236         .count = 6,
5237         .ext = &xcb_xkb_id,
5238         .opcode = XCB_XKB_SET_COMPAT_MAP,
5239         .isvoid = 1
5240     };
5241 
5242     struct iovec xcb_parts[8];
5243     xcb_void_cookie_t xcb_ret;
5244     xcb_xkb_set_compat_map_request_t xcb_out;
5245 
5246     xcb_out.deviceSpec = deviceSpec;
5247     xcb_out.pad0 = 0;
5248     xcb_out.recomputeActions = recomputeActions;
5249     xcb_out.truncateSI = truncateSI;
5250     xcb_out.groups = groups;
5251     xcb_out.firstSI = firstSI;
5252     xcb_out.nSI = nSI;
5253     memset(xcb_out.pad1, 0, 2);
5254 
5255     xcb_parts[2].iov_base = (char *) &xcb_out;
5256     xcb_parts[2].iov_len = sizeof(xcb_out);
5257     xcb_parts[3].iov_base = 0;
5258     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5259     /* xcb_xkb_sym_interpret_t si */
5260     xcb_parts[4].iov_base = (char *) si;
5261     xcb_parts[4].iov_len = nSI * sizeof(xcb_xkb_sym_interpret_t);
5262     xcb_parts[5].iov_base = 0;
5263     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5264     /* xcb_xkb_mod_def_t groupMaps */
5265     xcb_parts[6].iov_base = (char *) groupMaps;
5266     xcb_parts[6].iov_len = xcb_popcount(groups) * sizeof(xcb_xkb_mod_def_t);
5267     xcb_parts[7].iov_base = 0;
5268     xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
5269 
5270     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5271     return xcb_ret;
5272 }
5273 
5274 xcb_xkb_sym_interpret_t *
xcb_xkb_set_compat_map_si(const xcb_xkb_set_compat_map_request_t * R)5275 xcb_xkb_set_compat_map_si (const xcb_xkb_set_compat_map_request_t *R)
5276 {
5277     return (xcb_xkb_sym_interpret_t *) (R + 1);
5278 }
5279 
5280 int
xcb_xkb_set_compat_map_si_length(const xcb_xkb_set_compat_map_request_t * R)5281 xcb_xkb_set_compat_map_si_length (const xcb_xkb_set_compat_map_request_t *R)
5282 {
5283     return R->nSI;
5284 }
5285 
5286 xcb_xkb_sym_interpret_iterator_t
xcb_xkb_set_compat_map_si_iterator(const xcb_xkb_set_compat_map_request_t * R)5287 xcb_xkb_set_compat_map_si_iterator (const xcb_xkb_set_compat_map_request_t *R)
5288 {
5289     xcb_xkb_sym_interpret_iterator_t i;
5290     i.data = (xcb_xkb_sym_interpret_t *) (R + 1);
5291     i.rem = R->nSI;
5292     i.index = (char *) i.data - (char *) R;
5293     return i;
5294 }
5295 
5296 xcb_xkb_mod_def_t *
xcb_xkb_set_compat_map_group_maps(const xcb_xkb_set_compat_map_request_t * R)5297 xcb_xkb_set_compat_map_group_maps (const xcb_xkb_set_compat_map_request_t *R)
5298 {
5299     xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R));
5300     return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
5301 }
5302 
5303 int
xcb_xkb_set_compat_map_group_maps_length(const xcb_xkb_set_compat_map_request_t * R)5304 xcb_xkb_set_compat_map_group_maps_length (const xcb_xkb_set_compat_map_request_t *R)
5305 {
5306     return xcb_popcount(R->groups);
5307 }
5308 
5309 xcb_xkb_mod_def_iterator_t
xcb_xkb_set_compat_map_group_maps_iterator(const xcb_xkb_set_compat_map_request_t * R)5310 xcb_xkb_set_compat_map_group_maps_iterator (const xcb_xkb_set_compat_map_request_t *R)
5311 {
5312     xcb_xkb_mod_def_iterator_t i;
5313     xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R));
5314     i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
5315     i.rem = xcb_popcount(R->groups);
5316     i.index = (char *) i.data - (char *) R;
5317     return i;
5318 }
5319 
5320 xcb_xkb_get_indicator_state_cookie_t
xcb_xkb_get_indicator_state(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)5321 xcb_xkb_get_indicator_state (xcb_connection_t      *c,
5322                              xcb_xkb_device_spec_t  deviceSpec)
5323 {
5324     static const xcb_protocol_request_t xcb_req = {
5325         .count = 2,
5326         .ext = &xcb_xkb_id,
5327         .opcode = XCB_XKB_GET_INDICATOR_STATE,
5328         .isvoid = 0
5329     };
5330 
5331     struct iovec xcb_parts[4];
5332     xcb_xkb_get_indicator_state_cookie_t xcb_ret;
5333     xcb_xkb_get_indicator_state_request_t xcb_out;
5334 
5335     xcb_out.deviceSpec = deviceSpec;
5336     memset(xcb_out.pad0, 0, 2);
5337 
5338     xcb_parts[2].iov_base = (char *) &xcb_out;
5339     xcb_parts[2].iov_len = sizeof(xcb_out);
5340     xcb_parts[3].iov_base = 0;
5341     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5342 
5343     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5344     return xcb_ret;
5345 }
5346 
5347 xcb_xkb_get_indicator_state_cookie_t
xcb_xkb_get_indicator_state_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec)5348 xcb_xkb_get_indicator_state_unchecked (xcb_connection_t      *c,
5349                                        xcb_xkb_device_spec_t  deviceSpec)
5350 {
5351     static const xcb_protocol_request_t xcb_req = {
5352         .count = 2,
5353         .ext = &xcb_xkb_id,
5354         .opcode = XCB_XKB_GET_INDICATOR_STATE,
5355         .isvoid = 0
5356     };
5357 
5358     struct iovec xcb_parts[4];
5359     xcb_xkb_get_indicator_state_cookie_t xcb_ret;
5360     xcb_xkb_get_indicator_state_request_t xcb_out;
5361 
5362     xcb_out.deviceSpec = deviceSpec;
5363     memset(xcb_out.pad0, 0, 2);
5364 
5365     xcb_parts[2].iov_base = (char *) &xcb_out;
5366     xcb_parts[2].iov_len = sizeof(xcb_out);
5367     xcb_parts[3].iov_base = 0;
5368     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5369 
5370     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5371     return xcb_ret;
5372 }
5373 
5374 xcb_xkb_get_indicator_state_reply_t *
xcb_xkb_get_indicator_state_reply(xcb_connection_t * c,xcb_xkb_get_indicator_state_cookie_t cookie,xcb_generic_error_t ** e)5375 xcb_xkb_get_indicator_state_reply (xcb_connection_t                      *c,
5376                                    xcb_xkb_get_indicator_state_cookie_t   cookie  /**< */,
5377                                    xcb_generic_error_t                  **e)
5378 {
5379     return (xcb_xkb_get_indicator_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5380 }
5381 
5382 int
xcb_xkb_get_indicator_map_sizeof(const void * _buffer)5383 xcb_xkb_get_indicator_map_sizeof (const void  *_buffer)
5384 {
5385     char *xcb_tmp = (char *)_buffer;
5386     const xcb_xkb_get_indicator_map_reply_t *_aux = (xcb_xkb_get_indicator_map_reply_t *)_buffer;
5387     unsigned int xcb_buffer_len = 0;
5388     unsigned int xcb_block_len = 0;
5389     unsigned int xcb_pad = 0;
5390     unsigned int xcb_align_to = 0;
5391 
5392 
5393     xcb_block_len += sizeof(xcb_xkb_get_indicator_map_reply_t);
5394     xcb_tmp += xcb_block_len;
5395     xcb_buffer_len += xcb_block_len;
5396     xcb_block_len = 0;
5397     /* maps */
5398     xcb_block_len += xcb_popcount(_aux->which) * sizeof(xcb_xkb_indicator_map_t);
5399     xcb_tmp += xcb_block_len;
5400     xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
5401     /* insert padding */
5402     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5403     xcb_buffer_len += xcb_block_len + xcb_pad;
5404     if (0 != xcb_pad) {
5405         xcb_tmp += xcb_pad;
5406         xcb_pad = 0;
5407     }
5408     xcb_block_len = 0;
5409 
5410     return xcb_buffer_len;
5411 }
5412 
5413 xcb_xkb_get_indicator_map_cookie_t
xcb_xkb_get_indicator_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which)5414 xcb_xkb_get_indicator_map (xcb_connection_t      *c,
5415                            xcb_xkb_device_spec_t  deviceSpec,
5416                            uint32_t               which)
5417 {
5418     static const xcb_protocol_request_t xcb_req = {
5419         .count = 2,
5420         .ext = &xcb_xkb_id,
5421         .opcode = XCB_XKB_GET_INDICATOR_MAP,
5422         .isvoid = 0
5423     };
5424 
5425     struct iovec xcb_parts[4];
5426     xcb_xkb_get_indicator_map_cookie_t xcb_ret;
5427     xcb_xkb_get_indicator_map_request_t xcb_out;
5428 
5429     xcb_out.deviceSpec = deviceSpec;
5430     memset(xcb_out.pad0, 0, 2);
5431     xcb_out.which = which;
5432 
5433     xcb_parts[2].iov_base = (char *) &xcb_out;
5434     xcb_parts[2].iov_len = sizeof(xcb_out);
5435     xcb_parts[3].iov_base = 0;
5436     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5437 
5438     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5439     return xcb_ret;
5440 }
5441 
5442 xcb_xkb_get_indicator_map_cookie_t
xcb_xkb_get_indicator_map_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which)5443 xcb_xkb_get_indicator_map_unchecked (xcb_connection_t      *c,
5444                                      xcb_xkb_device_spec_t  deviceSpec,
5445                                      uint32_t               which)
5446 {
5447     static const xcb_protocol_request_t xcb_req = {
5448         .count = 2,
5449         .ext = &xcb_xkb_id,
5450         .opcode = XCB_XKB_GET_INDICATOR_MAP,
5451         .isvoid = 0
5452     };
5453 
5454     struct iovec xcb_parts[4];
5455     xcb_xkb_get_indicator_map_cookie_t xcb_ret;
5456     xcb_xkb_get_indicator_map_request_t xcb_out;
5457 
5458     xcb_out.deviceSpec = deviceSpec;
5459     memset(xcb_out.pad0, 0, 2);
5460     xcb_out.which = which;
5461 
5462     xcb_parts[2].iov_base = (char *) &xcb_out;
5463     xcb_parts[2].iov_len = sizeof(xcb_out);
5464     xcb_parts[3].iov_base = 0;
5465     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5466 
5467     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5468     return xcb_ret;
5469 }
5470 
5471 xcb_xkb_indicator_map_t *
xcb_xkb_get_indicator_map_maps(const xcb_xkb_get_indicator_map_reply_t * R)5472 xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R)
5473 {
5474     return (xcb_xkb_indicator_map_t *) (R + 1);
5475 }
5476 
5477 int
xcb_xkb_get_indicator_map_maps_length(const xcb_xkb_get_indicator_map_reply_t * R)5478 xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R)
5479 {
5480     return xcb_popcount(R->which);
5481 }
5482 
5483 xcb_xkb_indicator_map_iterator_t
xcb_xkb_get_indicator_map_maps_iterator(const xcb_xkb_get_indicator_map_reply_t * R)5484 xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R)
5485 {
5486     xcb_xkb_indicator_map_iterator_t i;
5487     i.data = (xcb_xkb_indicator_map_t *) (R + 1);
5488     i.rem = xcb_popcount(R->which);
5489     i.index = (char *) i.data - (char *) R;
5490     return i;
5491 }
5492 
5493 xcb_xkb_get_indicator_map_reply_t *
xcb_xkb_get_indicator_map_reply(xcb_connection_t * c,xcb_xkb_get_indicator_map_cookie_t cookie,xcb_generic_error_t ** e)5494 xcb_xkb_get_indicator_map_reply (xcb_connection_t                    *c,
5495                                  xcb_xkb_get_indicator_map_cookie_t   cookie  /**< */,
5496                                  xcb_generic_error_t                **e)
5497 {
5498     return (xcb_xkb_get_indicator_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5499 }
5500 
5501 int
xcb_xkb_set_indicator_map_sizeof(const void * _buffer)5502 xcb_xkb_set_indicator_map_sizeof (const void  *_buffer)
5503 {
5504     char *xcb_tmp = (char *)_buffer;
5505     const xcb_xkb_set_indicator_map_request_t *_aux = (xcb_xkb_set_indicator_map_request_t *)_buffer;
5506     unsigned int xcb_buffer_len = 0;
5507     unsigned int xcb_block_len = 0;
5508     unsigned int xcb_pad = 0;
5509     unsigned int xcb_align_to = 0;
5510 
5511 
5512     xcb_block_len += sizeof(xcb_xkb_set_indicator_map_request_t);
5513     xcb_tmp += xcb_block_len;
5514     xcb_buffer_len += xcb_block_len;
5515     xcb_block_len = 0;
5516     /* maps */
5517     xcb_block_len += xcb_popcount(_aux->which) * sizeof(xcb_xkb_indicator_map_t);
5518     xcb_tmp += xcb_block_len;
5519     xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
5520     /* insert padding */
5521     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
5522     xcb_buffer_len += xcb_block_len + xcb_pad;
5523     if (0 != xcb_pad) {
5524         xcb_tmp += xcb_pad;
5525         xcb_pad = 0;
5526     }
5527     xcb_block_len = 0;
5528 
5529     return xcb_buffer_len;
5530 }
5531 
5532 xcb_void_cookie_t
xcb_xkb_set_indicator_map_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which,const xcb_xkb_indicator_map_t * maps)5533 xcb_xkb_set_indicator_map_checked (xcb_connection_t              *c,
5534                                    xcb_xkb_device_spec_t          deviceSpec,
5535                                    uint32_t                       which,
5536                                    const xcb_xkb_indicator_map_t *maps)
5537 {
5538     static const xcb_protocol_request_t xcb_req = {
5539         .count = 4,
5540         .ext = &xcb_xkb_id,
5541         .opcode = XCB_XKB_SET_INDICATOR_MAP,
5542         .isvoid = 1
5543     };
5544 
5545     struct iovec xcb_parts[6];
5546     xcb_void_cookie_t xcb_ret;
5547     xcb_xkb_set_indicator_map_request_t xcb_out;
5548 
5549     xcb_out.deviceSpec = deviceSpec;
5550     memset(xcb_out.pad0, 0, 2);
5551     xcb_out.which = which;
5552 
5553     xcb_parts[2].iov_base = (char *) &xcb_out;
5554     xcb_parts[2].iov_len = sizeof(xcb_out);
5555     xcb_parts[3].iov_base = 0;
5556     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5557     /* xcb_xkb_indicator_map_t maps */
5558     xcb_parts[4].iov_base = (char *) maps;
5559     xcb_parts[4].iov_len = xcb_popcount(which) * sizeof(xcb_xkb_indicator_map_t);
5560     xcb_parts[5].iov_base = 0;
5561     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5562 
5563     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5564     return xcb_ret;
5565 }
5566 
5567 xcb_void_cookie_t
xcb_xkb_set_indicator_map(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which,const xcb_xkb_indicator_map_t * maps)5568 xcb_xkb_set_indicator_map (xcb_connection_t              *c,
5569                            xcb_xkb_device_spec_t          deviceSpec,
5570                            uint32_t                       which,
5571                            const xcb_xkb_indicator_map_t *maps)
5572 {
5573     static const xcb_protocol_request_t xcb_req = {
5574         .count = 4,
5575         .ext = &xcb_xkb_id,
5576         .opcode = XCB_XKB_SET_INDICATOR_MAP,
5577         .isvoid = 1
5578     };
5579 
5580     struct iovec xcb_parts[6];
5581     xcb_void_cookie_t xcb_ret;
5582     xcb_xkb_set_indicator_map_request_t xcb_out;
5583 
5584     xcb_out.deviceSpec = deviceSpec;
5585     memset(xcb_out.pad0, 0, 2);
5586     xcb_out.which = which;
5587 
5588     xcb_parts[2].iov_base = (char *) &xcb_out;
5589     xcb_parts[2].iov_len = sizeof(xcb_out);
5590     xcb_parts[3].iov_base = 0;
5591     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5592     /* xcb_xkb_indicator_map_t maps */
5593     xcb_parts[4].iov_base = (char *) maps;
5594     xcb_parts[4].iov_len = xcb_popcount(which) * sizeof(xcb_xkb_indicator_map_t);
5595     xcb_parts[5].iov_base = 0;
5596     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
5597 
5598     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5599     return xcb_ret;
5600 }
5601 
5602 xcb_xkb_indicator_map_t *
xcb_xkb_set_indicator_map_maps(const xcb_xkb_set_indicator_map_request_t * R)5603 xcb_xkb_set_indicator_map_maps (const xcb_xkb_set_indicator_map_request_t *R)
5604 {
5605     return (xcb_xkb_indicator_map_t *) (R + 1);
5606 }
5607 
5608 int
xcb_xkb_set_indicator_map_maps_length(const xcb_xkb_set_indicator_map_request_t * R)5609 xcb_xkb_set_indicator_map_maps_length (const xcb_xkb_set_indicator_map_request_t *R)
5610 {
5611     return xcb_popcount(R->which);
5612 }
5613 
5614 xcb_xkb_indicator_map_iterator_t
xcb_xkb_set_indicator_map_maps_iterator(const xcb_xkb_set_indicator_map_request_t * R)5615 xcb_xkb_set_indicator_map_maps_iterator (const xcb_xkb_set_indicator_map_request_t *R)
5616 {
5617     xcb_xkb_indicator_map_iterator_t i;
5618     i.data = (xcb_xkb_indicator_map_t *) (R + 1);
5619     i.rem = xcb_popcount(R->which);
5620     i.index = (char *) i.data - (char *) R;
5621     return i;
5622 }
5623 
5624 xcb_xkb_get_named_indicator_cookie_t
xcb_xkb_get_named_indicator(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID,xcb_atom_t indicator)5625 xcb_xkb_get_named_indicator (xcb_connection_t         *c,
5626                              xcb_xkb_device_spec_t     deviceSpec,
5627                              xcb_xkb_led_class_spec_t  ledClass,
5628                              xcb_xkb_id_spec_t         ledID,
5629                              xcb_atom_t                indicator)
5630 {
5631     static const xcb_protocol_request_t xcb_req = {
5632         .count = 2,
5633         .ext = &xcb_xkb_id,
5634         .opcode = XCB_XKB_GET_NAMED_INDICATOR,
5635         .isvoid = 0
5636     };
5637 
5638     struct iovec xcb_parts[4];
5639     xcb_xkb_get_named_indicator_cookie_t xcb_ret;
5640     xcb_xkb_get_named_indicator_request_t xcb_out;
5641 
5642     xcb_out.deviceSpec = deviceSpec;
5643     xcb_out.ledClass = ledClass;
5644     xcb_out.ledID = ledID;
5645     memset(xcb_out.pad0, 0, 2);
5646     xcb_out.indicator = indicator;
5647 
5648     xcb_parts[2].iov_base = (char *) &xcb_out;
5649     xcb_parts[2].iov_len = sizeof(xcb_out);
5650     xcb_parts[3].iov_base = 0;
5651     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5652 
5653     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5654     return xcb_ret;
5655 }
5656 
5657 xcb_xkb_get_named_indicator_cookie_t
xcb_xkb_get_named_indicator_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID,xcb_atom_t indicator)5658 xcb_xkb_get_named_indicator_unchecked (xcb_connection_t         *c,
5659                                        xcb_xkb_device_spec_t     deviceSpec,
5660                                        xcb_xkb_led_class_spec_t  ledClass,
5661                                        xcb_xkb_id_spec_t         ledID,
5662                                        xcb_atom_t                indicator)
5663 {
5664     static const xcb_protocol_request_t xcb_req = {
5665         .count = 2,
5666         .ext = &xcb_xkb_id,
5667         .opcode = XCB_XKB_GET_NAMED_INDICATOR,
5668         .isvoid = 0
5669     };
5670 
5671     struct iovec xcb_parts[4];
5672     xcb_xkb_get_named_indicator_cookie_t xcb_ret;
5673     xcb_xkb_get_named_indicator_request_t xcb_out;
5674 
5675     xcb_out.deviceSpec = deviceSpec;
5676     xcb_out.ledClass = ledClass;
5677     xcb_out.ledID = ledID;
5678     memset(xcb_out.pad0, 0, 2);
5679     xcb_out.indicator = indicator;
5680 
5681     xcb_parts[2].iov_base = (char *) &xcb_out;
5682     xcb_parts[2].iov_len = sizeof(xcb_out);
5683     xcb_parts[3].iov_base = 0;
5684     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5685 
5686     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5687     return xcb_ret;
5688 }
5689 
5690 xcb_xkb_get_named_indicator_reply_t *
xcb_xkb_get_named_indicator_reply(xcb_connection_t * c,xcb_xkb_get_named_indicator_cookie_t cookie,xcb_generic_error_t ** e)5691 xcb_xkb_get_named_indicator_reply (xcb_connection_t                      *c,
5692                                    xcb_xkb_get_named_indicator_cookie_t   cookie  /**< */,
5693                                    xcb_generic_error_t                  **e)
5694 {
5695     return (xcb_xkb_get_named_indicator_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
5696 }
5697 
5698 xcb_void_cookie_t
xcb_xkb_set_named_indicator_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID,xcb_atom_t indicator,uint8_t setState,uint8_t on,uint8_t setMap,uint8_t createMap,uint8_t map_flags,uint8_t map_whichGroups,uint8_t map_groups,uint8_t map_whichMods,uint8_t map_realMods,uint16_t map_vmods,uint32_t map_ctrls)5699 xcb_xkb_set_named_indicator_checked (xcb_connection_t         *c,
5700                                      xcb_xkb_device_spec_t     deviceSpec,
5701                                      xcb_xkb_led_class_spec_t  ledClass,
5702                                      xcb_xkb_id_spec_t         ledID,
5703                                      xcb_atom_t                indicator,
5704                                      uint8_t                   setState,
5705                                      uint8_t                   on,
5706                                      uint8_t                   setMap,
5707                                      uint8_t                   createMap,
5708                                      uint8_t                   map_flags,
5709                                      uint8_t                   map_whichGroups,
5710                                      uint8_t                   map_groups,
5711                                      uint8_t                   map_whichMods,
5712                                      uint8_t                   map_realMods,
5713                                      uint16_t                  map_vmods,
5714                                      uint32_t                  map_ctrls)
5715 {
5716     static const xcb_protocol_request_t xcb_req = {
5717         .count = 2,
5718         .ext = &xcb_xkb_id,
5719         .opcode = XCB_XKB_SET_NAMED_INDICATOR,
5720         .isvoid = 1
5721     };
5722 
5723     struct iovec xcb_parts[4];
5724     xcb_void_cookie_t xcb_ret;
5725     xcb_xkb_set_named_indicator_request_t xcb_out;
5726 
5727     xcb_out.deviceSpec = deviceSpec;
5728     xcb_out.ledClass = ledClass;
5729     xcb_out.ledID = ledID;
5730     memset(xcb_out.pad0, 0, 2);
5731     xcb_out.indicator = indicator;
5732     xcb_out.setState = setState;
5733     xcb_out.on = on;
5734     xcb_out.setMap = setMap;
5735     xcb_out.createMap = createMap;
5736     xcb_out.pad1 = 0;
5737     xcb_out.map_flags = map_flags;
5738     xcb_out.map_whichGroups = map_whichGroups;
5739     xcb_out.map_groups = map_groups;
5740     xcb_out.map_whichMods = map_whichMods;
5741     xcb_out.map_realMods = map_realMods;
5742     xcb_out.map_vmods = map_vmods;
5743     xcb_out.map_ctrls = map_ctrls;
5744 
5745     xcb_parts[2].iov_base = (char *) &xcb_out;
5746     xcb_parts[2].iov_len = sizeof(xcb_out);
5747     xcb_parts[3].iov_base = 0;
5748     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5749 
5750     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
5751     return xcb_ret;
5752 }
5753 
5754 xcb_void_cookie_t
xcb_xkb_set_named_indicator(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID,xcb_atom_t indicator,uint8_t setState,uint8_t on,uint8_t setMap,uint8_t createMap,uint8_t map_flags,uint8_t map_whichGroups,uint8_t map_groups,uint8_t map_whichMods,uint8_t map_realMods,uint16_t map_vmods,uint32_t map_ctrls)5755 xcb_xkb_set_named_indicator (xcb_connection_t         *c,
5756                              xcb_xkb_device_spec_t     deviceSpec,
5757                              xcb_xkb_led_class_spec_t  ledClass,
5758                              xcb_xkb_id_spec_t         ledID,
5759                              xcb_atom_t                indicator,
5760                              uint8_t                   setState,
5761                              uint8_t                   on,
5762                              uint8_t                   setMap,
5763                              uint8_t                   createMap,
5764                              uint8_t                   map_flags,
5765                              uint8_t                   map_whichGroups,
5766                              uint8_t                   map_groups,
5767                              uint8_t                   map_whichMods,
5768                              uint8_t                   map_realMods,
5769                              uint16_t                  map_vmods,
5770                              uint32_t                  map_ctrls)
5771 {
5772     static const xcb_protocol_request_t xcb_req = {
5773         .count = 2,
5774         .ext = &xcb_xkb_id,
5775         .opcode = XCB_XKB_SET_NAMED_INDICATOR,
5776         .isvoid = 1
5777     };
5778 
5779     struct iovec xcb_parts[4];
5780     xcb_void_cookie_t xcb_ret;
5781     xcb_xkb_set_named_indicator_request_t xcb_out;
5782 
5783     xcb_out.deviceSpec = deviceSpec;
5784     xcb_out.ledClass = ledClass;
5785     xcb_out.ledID = ledID;
5786     memset(xcb_out.pad0, 0, 2);
5787     xcb_out.indicator = indicator;
5788     xcb_out.setState = setState;
5789     xcb_out.on = on;
5790     xcb_out.setMap = setMap;
5791     xcb_out.createMap = createMap;
5792     xcb_out.pad1 = 0;
5793     xcb_out.map_flags = map_flags;
5794     xcb_out.map_whichGroups = map_whichGroups;
5795     xcb_out.map_groups = map_groups;
5796     xcb_out.map_whichMods = map_whichMods;
5797     xcb_out.map_realMods = map_realMods;
5798     xcb_out.map_vmods = map_vmods;
5799     xcb_out.map_ctrls = map_ctrls;
5800 
5801     xcb_parts[2].iov_base = (char *) &xcb_out;
5802     xcb_parts[2].iov_len = sizeof(xcb_out);
5803     xcb_parts[3].iov_base = 0;
5804     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
5805 
5806     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
5807     return xcb_ret;
5808 }
5809 
5810 xcb_atom_t *
xcb_xkb_get_names_value_list_type_names(const xcb_xkb_get_names_value_list_t * S)5811 xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S)
5812 {
5813     return S->typeNames;
5814 }
5815 
5816 int
xcb_xkb_get_names_value_list_type_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5817 xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R,
5818                                                 const xcb_xkb_get_names_value_list_t *S)
5819 {
5820     return R->nTypes;
5821 }
5822 
5823 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_type_names_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5824 xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R,
5825                                              const xcb_xkb_get_names_value_list_t *S)
5826 {
5827     xcb_generic_iterator_t i;
5828     i.data = S->typeNames + R->nTypes;
5829     i.rem = 0;
5830     i.index = (char *) i.data - (char *) S;
5831     return i;
5832 }
5833 
5834 uint8_t *
xcb_xkb_get_names_value_list_n_levels_per_type(const xcb_xkb_get_names_value_list_t * S)5835 xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S)
5836 {
5837     return S->nLevelsPerType;
5838 }
5839 
5840 int
xcb_xkb_get_names_value_list_n_levels_per_type_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5841 xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R,
5842                                                        const xcb_xkb_get_names_value_list_t *S)
5843 {
5844     return R->nTypes;
5845 }
5846 
5847 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_n_levels_per_type_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5848 xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R,
5849                                                     const xcb_xkb_get_names_value_list_t *S)
5850 {
5851     xcb_generic_iterator_t i;
5852     i.data = S->nLevelsPerType + R->nTypes;
5853     i.rem = 0;
5854     i.index = (char *) i.data - (char *) S;
5855     return i;
5856 }
5857 
5858 xcb_atom_t *
xcb_xkb_get_names_value_list_kt_level_names(const xcb_xkb_get_names_value_list_t * S)5859 xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S)
5860 {
5861     return S->ktLevelNames;
5862 }
5863 
5864 int
xcb_xkb_get_names_value_list_kt_level_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5865 xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R,
5866                                                     const xcb_xkb_get_names_value_list_t *S)
5867 {
5868     int xcb_pre_tmp_1; /* sumof length */
5869     int xcb_pre_tmp_2; /* sumof loop counter */
5870     int64_t xcb_pre_tmp_3; /* sumof sum */
5871     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
5872     /* sumof start */
5873     xcb_pre_tmp_1 = R->nTypes;
5874     xcb_pre_tmp_3 = 0;
5875     xcb_pre_tmp_4 = S->nLevelsPerType;
5876     for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
5877         xcb_pre_tmp_3 += *xcb_pre_tmp_4;
5878         xcb_pre_tmp_4++;
5879     }
5880     /* sumof end. Result is in xcb_pre_tmp_3 */
5881     return xcb_pre_tmp_3;
5882 }
5883 
5884 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_kt_level_names_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5885 xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R,
5886                                                  const xcb_xkb_get_names_value_list_t *S)
5887 {
5888     xcb_generic_iterator_t i;
5889     int xcb_pre_tmp_5; /* sumof length */
5890     int xcb_pre_tmp_6; /* sumof loop counter */
5891     int64_t xcb_pre_tmp_7; /* sumof sum */
5892     const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
5893     /* sumof start */
5894     xcb_pre_tmp_5 = R->nTypes;
5895     xcb_pre_tmp_7 = 0;
5896     xcb_pre_tmp_8 = S->nLevelsPerType;
5897     for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
5898         xcb_pre_tmp_7 += *xcb_pre_tmp_8;
5899         xcb_pre_tmp_8++;
5900     }
5901     /* sumof end. Result is in xcb_pre_tmp_7 */
5902     i.data = S->ktLevelNames + xcb_pre_tmp_7;
5903     i.rem = 0;
5904     i.index = (char *) i.data - (char *) S;
5905     return i;
5906 }
5907 
5908 xcb_atom_t *
xcb_xkb_get_names_value_list_indicator_names(const xcb_xkb_get_names_value_list_t * S)5909 xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S)
5910 {
5911     return S->indicatorNames;
5912 }
5913 
5914 int
xcb_xkb_get_names_value_list_indicator_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5915 xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R,
5916                                                      const xcb_xkb_get_names_value_list_t *S)
5917 {
5918     return xcb_popcount(R->indicators);
5919 }
5920 
5921 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_indicator_names_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5922 xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R,
5923                                                   const xcb_xkb_get_names_value_list_t *S)
5924 {
5925     xcb_generic_iterator_t i;
5926     i.data = S->indicatorNames + xcb_popcount(R->indicators);
5927     i.rem = 0;
5928     i.index = (char *) i.data - (char *) S;
5929     return i;
5930 }
5931 
5932 xcb_atom_t *
xcb_xkb_get_names_value_list_virtual_mod_names(const xcb_xkb_get_names_value_list_t * S)5933 xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S)
5934 {
5935     return S->virtualModNames;
5936 }
5937 
5938 int
xcb_xkb_get_names_value_list_virtual_mod_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5939 xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R,
5940                                                        const xcb_xkb_get_names_value_list_t *S)
5941 {
5942     return xcb_popcount(R->virtualMods);
5943 }
5944 
5945 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_virtual_mod_names_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5946 xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R,
5947                                                     const xcb_xkb_get_names_value_list_t *S)
5948 {
5949     xcb_generic_iterator_t i;
5950     i.data = S->virtualModNames + xcb_popcount(R->virtualMods);
5951     i.rem = 0;
5952     i.index = (char *) i.data - (char *) S;
5953     return i;
5954 }
5955 
5956 xcb_atom_t *
xcb_xkb_get_names_value_list_groups(const xcb_xkb_get_names_value_list_t * S)5957 xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S)
5958 {
5959     return S->groups;
5960 }
5961 
5962 int
xcb_xkb_get_names_value_list_groups_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5963 xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R,
5964                                             const xcb_xkb_get_names_value_list_t *S)
5965 {
5966     return xcb_popcount(R->groupNames);
5967 }
5968 
5969 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_groups_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5970 xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R,
5971                                          const xcb_xkb_get_names_value_list_t *S)
5972 {
5973     xcb_generic_iterator_t i;
5974     i.data = S->groups + xcb_popcount(R->groupNames);
5975     i.rem = 0;
5976     i.index = (char *) i.data - (char *) S;
5977     return i;
5978 }
5979 
5980 xcb_xkb_key_name_t *
xcb_xkb_get_names_value_list_key_names(const xcb_xkb_get_names_value_list_t * S)5981 xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S)
5982 {
5983     return S->keyNames;
5984 }
5985 
5986 int
xcb_xkb_get_names_value_list_key_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5987 xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R,
5988                                                const xcb_xkb_get_names_value_list_t *S)
5989 {
5990     return R->nKeys;
5991 }
5992 
5993 xcb_xkb_key_name_iterator_t
xcb_xkb_get_names_value_list_key_names_iterator(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)5994 xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R,
5995                                                  const xcb_xkb_get_names_value_list_t *S)
5996 {
5997     xcb_xkb_key_name_iterator_t i;
5998     i.data = S->keyNames;
5999     i.rem = R->nKeys;
6000     i.index = (char *) i.data - (char *) S;
6001     return i;
6002 }
6003 
6004 xcb_xkb_key_alias_t *
xcb_xkb_get_names_value_list_key_aliases(const xcb_xkb_get_names_value_list_t * S)6005 xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S)
6006 {
6007     return S->keyAliases;
6008 }
6009 
6010 int
xcb_xkb_get_names_value_list_key_aliases_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)6011 xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R,
6012                                                  const xcb_xkb_get_names_value_list_t *S)
6013 {
6014     return R->nKeyAliases;
6015 }
6016 
6017 xcb_xkb_key_alias_iterator_t
xcb_xkb_get_names_value_list_key_aliases_iterator(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)6018 xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R,
6019                                                    const xcb_xkb_get_names_value_list_t *S)
6020 {
6021     xcb_xkb_key_alias_iterator_t i;
6022     i.data = S->keyAliases;
6023     i.rem = R->nKeyAliases;
6024     i.index = (char *) i.data - (char *) S;
6025     return i;
6026 }
6027 
6028 xcb_atom_t *
xcb_xkb_get_names_value_list_radio_group_names(const xcb_xkb_get_names_value_list_t * S)6029 xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S)
6030 {
6031     return S->radioGroupNames;
6032 }
6033 
6034 int
xcb_xkb_get_names_value_list_radio_group_names_length(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)6035 xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R,
6036                                                        const xcb_xkb_get_names_value_list_t *S)
6037 {
6038     return R->nRadioGroups;
6039 }
6040 
6041 xcb_generic_iterator_t
xcb_xkb_get_names_value_list_radio_group_names_end(const xcb_xkb_get_names_reply_t * R,const xcb_xkb_get_names_value_list_t * S)6042 xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R,
6043                                                     const xcb_xkb_get_names_value_list_t *S)
6044 {
6045     xcb_generic_iterator_t i;
6046     i.data = S->radioGroupNames + R->nRadioGroups;
6047     i.rem = 0;
6048     i.index = (char *) i.data - (char *) S;
6049     return i;
6050 }
6051 
6052 int
xcb_xkb_get_names_value_list_serialize(void ** _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,const xcb_xkb_get_names_value_list_t * _aux)6053 xcb_xkb_get_names_value_list_serialize (void                                 **_buffer,
6054                                         uint8_t                                nTypes,
6055                                         uint32_t                               indicators,
6056                                         uint16_t                               virtualMods,
6057                                         uint8_t                                groupNames,
6058                                         uint8_t                                nKeys,
6059                                         uint8_t                                nKeyAliases,
6060                                         uint8_t                                nRadioGroups,
6061                                         uint32_t                               which,
6062                                         const xcb_xkb_get_names_value_list_t  *_aux)
6063 {
6064     char *xcb_out = *_buffer;
6065     unsigned int xcb_buffer_len = 0;
6066     unsigned int xcb_align_to = 0;
6067     unsigned int xcb_padding_offset = 0;
6068 
6069     int xcb_pre_tmp_1; /* sumof length */
6070     int xcb_pre_tmp_2; /* sumof loop counter */
6071     int64_t xcb_pre_tmp_3; /* sumof sum */
6072     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
6073     unsigned int xcb_pad = 0;
6074     char xcb_pad0[3] = {0, 0, 0};
6075     struct iovec xcb_parts[26];
6076     unsigned int xcb_parts_idx = 0;
6077     unsigned int xcb_block_len = 0;
6078     unsigned int i;
6079     char *xcb_tmp;
6080 
6081     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
6082         /* xcb_xkb_get_names_value_list_t.keycodesName */
6083         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
6084         xcb_block_len += sizeof(xcb_atom_t);
6085         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6086         xcb_parts_idx++;
6087         xcb_align_to = ALIGNOF(xcb_atom_t);
6088     }
6089     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
6090         /* xcb_xkb_get_names_value_list_t.geometryName */
6091         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
6092         xcb_block_len += sizeof(xcb_atom_t);
6093         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6094         xcb_parts_idx++;
6095         xcb_align_to = ALIGNOF(xcb_atom_t);
6096     }
6097     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
6098         /* xcb_xkb_get_names_value_list_t.symbolsName */
6099         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
6100         xcb_block_len += sizeof(xcb_atom_t);
6101         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6102         xcb_parts_idx++;
6103         xcb_align_to = ALIGNOF(xcb_atom_t);
6104     }
6105     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
6106         /* xcb_xkb_get_names_value_list_t.physSymbolsName */
6107         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
6108         xcb_block_len += sizeof(xcb_atom_t);
6109         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6110         xcb_parts_idx++;
6111         xcb_align_to = ALIGNOF(xcb_atom_t);
6112     }
6113     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
6114         /* xcb_xkb_get_names_value_list_t.typesName */
6115         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
6116         xcb_block_len += sizeof(xcb_atom_t);
6117         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6118         xcb_parts_idx++;
6119         xcb_align_to = ALIGNOF(xcb_atom_t);
6120     }
6121     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
6122         /* xcb_xkb_get_names_value_list_t.compatName */
6123         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
6124         xcb_block_len += sizeof(xcb_atom_t);
6125         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6126         xcb_parts_idx++;
6127         xcb_align_to = ALIGNOF(xcb_atom_t);
6128     }
6129     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
6130         /* insert padding */
6131         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6132         xcb_buffer_len += xcb_block_len + xcb_pad;
6133         if (0 != xcb_pad) {
6134             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6135             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6136             xcb_parts_idx++;
6137             xcb_pad = 0;
6138         }
6139         xcb_block_len = 0;
6140         xcb_padding_offset = 0;
6141         /* typeNames */
6142         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
6143         xcb_block_len += nTypes * sizeof(xcb_atom_t);
6144         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
6145         xcb_parts_idx++;
6146         xcb_align_to = ALIGNOF(xcb_atom_t);
6147     }
6148     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
6149         /* insert padding */
6150         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6151         xcb_buffer_len += xcb_block_len + xcb_pad;
6152         if (0 != xcb_pad) {
6153             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6154             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6155             xcb_parts_idx++;
6156             xcb_pad = 0;
6157         }
6158         xcb_block_len = 0;
6159         xcb_padding_offset = 0;
6160         /* nLevelsPerType */
6161         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
6162         xcb_block_len += nTypes * sizeof(uint8_t);
6163         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
6164         xcb_parts_idx++;
6165         xcb_align_to = ALIGNOF(uint8_t);
6166         xcb_align_to = 4;
6167         /* insert padding */
6168         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6169         xcb_buffer_len += xcb_block_len + xcb_pad;
6170         if (0 != xcb_pad) {
6171             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6172             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6173             xcb_parts_idx++;
6174             xcb_pad = 0;
6175         }
6176         xcb_block_len = 0;
6177         xcb_padding_offset = 0;
6178         /* insert padding */
6179         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6180         xcb_buffer_len += xcb_block_len + xcb_pad;
6181         if (0 != xcb_pad) {
6182             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6183             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6184             xcb_parts_idx++;
6185             xcb_pad = 0;
6186         }
6187         xcb_block_len = 0;
6188         xcb_padding_offset = 0;
6189         /* ktLevelNames */
6190         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
6191         /* sumof start */
6192         xcb_pre_tmp_1 = nTypes;
6193         xcb_pre_tmp_3 = 0;
6194         xcb_pre_tmp_4 = _aux->nLevelsPerType;
6195         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
6196             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
6197             xcb_pre_tmp_4++;
6198         }
6199         /* sumof end. Result is in xcb_pre_tmp_3 */
6200         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
6201         xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
6202         xcb_parts_idx++;
6203         xcb_align_to = ALIGNOF(xcb_atom_t);
6204     }
6205     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
6206         /* insert padding */
6207         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6208         xcb_buffer_len += xcb_block_len + xcb_pad;
6209         if (0 != xcb_pad) {
6210             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6211             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6212             xcb_parts_idx++;
6213             xcb_pad = 0;
6214         }
6215         xcb_block_len = 0;
6216         xcb_padding_offset = 0;
6217         /* indicatorNames */
6218         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
6219         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
6220         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
6221         xcb_parts_idx++;
6222         xcb_align_to = ALIGNOF(xcb_atom_t);
6223     }
6224     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
6225         /* insert padding */
6226         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6227         xcb_buffer_len += xcb_block_len + xcb_pad;
6228         if (0 != xcb_pad) {
6229             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6230             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6231             xcb_parts_idx++;
6232             xcb_pad = 0;
6233         }
6234         xcb_block_len = 0;
6235         xcb_padding_offset = 0;
6236         /* virtualModNames */
6237         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
6238         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
6239         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
6240         xcb_parts_idx++;
6241         xcb_align_to = ALIGNOF(xcb_atom_t);
6242     }
6243     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
6244         /* insert padding */
6245         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6246         xcb_buffer_len += xcb_block_len + xcb_pad;
6247         if (0 != xcb_pad) {
6248             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6249             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6250             xcb_parts_idx++;
6251             xcb_pad = 0;
6252         }
6253         xcb_block_len = 0;
6254         xcb_padding_offset = 0;
6255         /* groups */
6256         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
6257         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
6258         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
6259         xcb_parts_idx++;
6260         xcb_align_to = ALIGNOF(xcb_atom_t);
6261     }
6262     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
6263         /* insert padding */
6264         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6265         xcb_buffer_len += xcb_block_len + xcb_pad;
6266         if (0 != xcb_pad) {
6267             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6268             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6269             xcb_parts_idx++;
6270             xcb_pad = 0;
6271         }
6272         xcb_block_len = 0;
6273         xcb_padding_offset = 0;
6274         /* keyNames */
6275         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
6276         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
6277         xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
6278         xcb_parts_idx++;
6279         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
6280     }
6281     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
6282         /* insert padding */
6283         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6284         xcb_buffer_len += xcb_block_len + xcb_pad;
6285         if (0 != xcb_pad) {
6286             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6287             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6288             xcb_parts_idx++;
6289             xcb_pad = 0;
6290         }
6291         xcb_block_len = 0;
6292         xcb_padding_offset = 0;
6293         /* keyAliases */
6294         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
6295         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
6296         xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
6297         xcb_parts_idx++;
6298         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
6299     }
6300     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
6301         /* insert padding */
6302         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6303         xcb_buffer_len += xcb_block_len + xcb_pad;
6304         if (0 != xcb_pad) {
6305             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6306             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6307             xcb_parts_idx++;
6308             xcb_pad = 0;
6309         }
6310         xcb_block_len = 0;
6311         xcb_padding_offset = 0;
6312         /* radioGroupNames */
6313         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
6314         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
6315         xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
6316         xcb_parts_idx++;
6317         xcb_align_to = ALIGNOF(xcb_atom_t);
6318     }
6319     /* insert padding */
6320     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6321     xcb_buffer_len += xcb_block_len + xcb_pad;
6322     if (0 != xcb_pad) {
6323         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
6324         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
6325         xcb_parts_idx++;
6326         xcb_pad = 0;
6327     }
6328     xcb_block_len = 0;
6329     xcb_padding_offset = 0;
6330 
6331     if (NULL == xcb_out) {
6332         /* allocate memory */
6333         xcb_out = malloc(xcb_buffer_len);
6334         *_buffer = xcb_out;
6335     }
6336 
6337     xcb_tmp = xcb_out;
6338     for(i=0; i<xcb_parts_idx; i++) {
6339         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
6340             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
6341         if (0 != xcb_parts[i].iov_len)
6342             xcb_tmp += xcb_parts[i].iov_len;
6343     }
6344 
6345     return xcb_buffer_len;
6346 }
6347 
6348 int
xcb_xkb_get_names_value_list_unpack(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,xcb_xkb_get_names_value_list_t * _aux)6349 xcb_xkb_get_names_value_list_unpack (const void                      *_buffer,
6350                                      uint8_t                          nTypes,
6351                                      uint32_t                         indicators,
6352                                      uint16_t                         virtualMods,
6353                                      uint8_t                          groupNames,
6354                                      uint8_t                          nKeys,
6355                                      uint8_t                          nKeyAliases,
6356                                      uint8_t                          nRadioGroups,
6357                                      uint32_t                         which,
6358                                      xcb_xkb_get_names_value_list_t  *_aux)
6359 {
6360     char *xcb_tmp = (char *)_buffer;
6361     unsigned int xcb_buffer_len = 0;
6362     unsigned int xcb_block_len = 0;
6363     unsigned int xcb_pad = 0;
6364     unsigned int xcb_align_to = 0;
6365     unsigned int xcb_padding_offset = 0;
6366 
6367     int xcb_pre_tmp_1; /* sumof length */
6368     int xcb_pre_tmp_2; /* sumof loop counter */
6369     int64_t xcb_pre_tmp_3; /* sumof sum */
6370     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
6371 
6372     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
6373         /* xcb_xkb_get_names_value_list_t.keycodesName */
6374         _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
6375         xcb_block_len += sizeof(xcb_atom_t);
6376         xcb_tmp += sizeof(xcb_atom_t);
6377         xcb_align_to = ALIGNOF(xcb_atom_t);
6378     }
6379     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
6380         /* xcb_xkb_get_names_value_list_t.geometryName */
6381         _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
6382         xcb_block_len += sizeof(xcb_atom_t);
6383         xcb_tmp += sizeof(xcb_atom_t);
6384         xcb_align_to = ALIGNOF(xcb_atom_t);
6385     }
6386     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
6387         /* xcb_xkb_get_names_value_list_t.symbolsName */
6388         _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
6389         xcb_block_len += sizeof(xcb_atom_t);
6390         xcb_tmp += sizeof(xcb_atom_t);
6391         xcb_align_to = ALIGNOF(xcb_atom_t);
6392     }
6393     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
6394         /* xcb_xkb_get_names_value_list_t.physSymbolsName */
6395         _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
6396         xcb_block_len += sizeof(xcb_atom_t);
6397         xcb_tmp += sizeof(xcb_atom_t);
6398         xcb_align_to = ALIGNOF(xcb_atom_t);
6399     }
6400     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
6401         /* xcb_xkb_get_names_value_list_t.typesName */
6402         _aux->typesName = *(xcb_atom_t *)xcb_tmp;
6403         xcb_block_len += sizeof(xcb_atom_t);
6404         xcb_tmp += sizeof(xcb_atom_t);
6405         xcb_align_to = ALIGNOF(xcb_atom_t);
6406     }
6407     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
6408         /* xcb_xkb_get_names_value_list_t.compatName */
6409         _aux->compatName = *(xcb_atom_t *)xcb_tmp;
6410         xcb_block_len += sizeof(xcb_atom_t);
6411         xcb_tmp += sizeof(xcb_atom_t);
6412         xcb_align_to = ALIGNOF(xcb_atom_t);
6413     }
6414     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
6415         /* insert padding */
6416         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6417         xcb_buffer_len += xcb_block_len + xcb_pad;
6418         if (0 != xcb_pad) {
6419             xcb_tmp += xcb_pad;
6420             xcb_pad = 0;
6421         }
6422         xcb_block_len = 0;
6423         xcb_padding_offset = 0;
6424         /* typeNames */
6425         _aux->typeNames = (xcb_atom_t *)xcb_tmp;
6426         xcb_block_len += nTypes * sizeof(xcb_atom_t);
6427         xcb_tmp += xcb_block_len;
6428         xcb_align_to = ALIGNOF(xcb_atom_t);
6429     }
6430     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
6431         /* insert padding */
6432         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6433         xcb_buffer_len += xcb_block_len + xcb_pad;
6434         if (0 != xcb_pad) {
6435             xcb_tmp += xcb_pad;
6436             xcb_pad = 0;
6437         }
6438         xcb_block_len = 0;
6439         xcb_padding_offset = 0;
6440         /* nLevelsPerType */
6441         _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
6442         xcb_block_len += nTypes * sizeof(uint8_t);
6443         xcb_tmp += xcb_block_len;
6444         xcb_align_to = ALIGNOF(uint8_t);
6445         xcb_align_to = 4;
6446         /* insert padding */
6447         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6448         xcb_buffer_len += xcb_block_len + xcb_pad;
6449         if (0 != xcb_pad) {
6450             xcb_tmp += xcb_pad;
6451             xcb_pad = 0;
6452         }
6453         xcb_block_len = 0;
6454         xcb_padding_offset = 0;
6455         /* insert padding */
6456         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6457         xcb_buffer_len += xcb_block_len + xcb_pad;
6458         if (0 != xcb_pad) {
6459             xcb_tmp += xcb_pad;
6460             xcb_pad = 0;
6461         }
6462         xcb_block_len = 0;
6463         xcb_padding_offset = 0;
6464         /* ktLevelNames */
6465         _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
6466         /* sumof start */
6467         xcb_pre_tmp_1 = nTypes;
6468         xcb_pre_tmp_3 = 0;
6469         xcb_pre_tmp_4 = _aux->nLevelsPerType;
6470         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
6471             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
6472             xcb_pre_tmp_4++;
6473         }
6474         /* sumof end. Result is in xcb_pre_tmp_3 */
6475         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
6476         xcb_tmp += xcb_block_len;
6477         xcb_align_to = ALIGNOF(xcb_atom_t);
6478     }
6479     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
6480         /* insert padding */
6481         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6482         xcb_buffer_len += xcb_block_len + xcb_pad;
6483         if (0 != xcb_pad) {
6484             xcb_tmp += xcb_pad;
6485             xcb_pad = 0;
6486         }
6487         xcb_block_len = 0;
6488         xcb_padding_offset = 0;
6489         /* indicatorNames */
6490         _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
6491         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
6492         xcb_tmp += xcb_block_len;
6493         xcb_align_to = ALIGNOF(xcb_atom_t);
6494     }
6495     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
6496         /* insert padding */
6497         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6498         xcb_buffer_len += xcb_block_len + xcb_pad;
6499         if (0 != xcb_pad) {
6500             xcb_tmp += xcb_pad;
6501             xcb_pad = 0;
6502         }
6503         xcb_block_len = 0;
6504         xcb_padding_offset = 0;
6505         /* virtualModNames */
6506         _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
6507         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
6508         xcb_tmp += xcb_block_len;
6509         xcb_align_to = ALIGNOF(xcb_atom_t);
6510     }
6511     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
6512         /* insert padding */
6513         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6514         xcb_buffer_len += xcb_block_len + xcb_pad;
6515         if (0 != xcb_pad) {
6516             xcb_tmp += xcb_pad;
6517             xcb_pad = 0;
6518         }
6519         xcb_block_len = 0;
6520         xcb_padding_offset = 0;
6521         /* groups */
6522         _aux->groups = (xcb_atom_t *)xcb_tmp;
6523         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
6524         xcb_tmp += xcb_block_len;
6525         xcb_align_to = ALIGNOF(xcb_atom_t);
6526     }
6527     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
6528         /* insert padding */
6529         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6530         xcb_buffer_len += xcb_block_len + xcb_pad;
6531         if (0 != xcb_pad) {
6532             xcb_tmp += xcb_pad;
6533             xcb_pad = 0;
6534         }
6535         xcb_block_len = 0;
6536         xcb_padding_offset = 0;
6537         /* keyNames */
6538         _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
6539         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
6540         xcb_tmp += xcb_block_len;
6541         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
6542     }
6543     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
6544         /* insert padding */
6545         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6546         xcb_buffer_len += xcb_block_len + xcb_pad;
6547         if (0 != xcb_pad) {
6548             xcb_tmp += xcb_pad;
6549             xcb_pad = 0;
6550         }
6551         xcb_block_len = 0;
6552         xcb_padding_offset = 0;
6553         /* keyAliases */
6554         _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
6555         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
6556         xcb_tmp += xcb_block_len;
6557         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
6558     }
6559     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
6560         /* insert padding */
6561         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6562         xcb_buffer_len += xcb_block_len + xcb_pad;
6563         if (0 != xcb_pad) {
6564             xcb_tmp += xcb_pad;
6565             xcb_pad = 0;
6566         }
6567         xcb_block_len = 0;
6568         xcb_padding_offset = 0;
6569         /* radioGroupNames */
6570         _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
6571         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
6572         xcb_tmp += xcb_block_len;
6573         xcb_align_to = ALIGNOF(xcb_atom_t);
6574     }
6575     /* insert padding */
6576     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
6577     xcb_buffer_len += xcb_block_len + xcb_pad;
6578     if (0 != xcb_pad) {
6579         xcb_tmp += xcb_pad;
6580         xcb_pad = 0;
6581     }
6582     xcb_block_len = 0;
6583     xcb_padding_offset = 0;
6584 
6585     return xcb_buffer_len;
6586 }
6587 
6588 int
xcb_xkb_get_names_value_list_sizeof(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which)6589 xcb_xkb_get_names_value_list_sizeof (const void  *_buffer,
6590                                      uint8_t      nTypes,
6591                                      uint32_t     indicators,
6592                                      uint16_t     virtualMods,
6593                                      uint8_t      groupNames,
6594                                      uint8_t      nKeys,
6595                                      uint8_t      nKeyAliases,
6596                                      uint8_t      nRadioGroups,
6597                                      uint32_t     which)
6598 {
6599     xcb_xkb_get_names_value_list_t _aux;
6600     return xcb_xkb_get_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
6601 }
6602 
6603 int
xcb_xkb_get_names_sizeof(const void * _buffer)6604 xcb_xkb_get_names_sizeof (const void  *_buffer)
6605 {
6606     char *xcb_tmp = (char *)_buffer;
6607     const xcb_xkb_get_names_reply_t *_aux = (xcb_xkb_get_names_reply_t *)_buffer;
6608     unsigned int xcb_buffer_len = 0;
6609     unsigned int xcb_block_len = 0;
6610     unsigned int xcb_pad = 0;
6611     unsigned int xcb_align_to = 0;
6612 
6613 
6614     xcb_block_len += sizeof(xcb_xkb_get_names_reply_t);
6615     xcb_tmp += xcb_block_len;
6616     xcb_buffer_len += xcb_block_len;
6617     xcb_block_len = 0;
6618     /* valueList */
6619     xcb_block_len += xcb_xkb_get_names_value_list_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which);
6620     xcb_tmp += xcb_block_len;
6621     xcb_align_to = ALIGNOF(char);
6622     /* insert padding */
6623     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
6624     xcb_buffer_len += xcb_block_len + xcb_pad;
6625     if (0 != xcb_pad) {
6626         xcb_tmp += xcb_pad;
6627         xcb_pad = 0;
6628     }
6629     xcb_block_len = 0;
6630 
6631     return xcb_buffer_len;
6632 }
6633 
6634 xcb_xkb_get_names_cookie_t
xcb_xkb_get_names(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which)6635 xcb_xkb_get_names (xcb_connection_t      *c,
6636                    xcb_xkb_device_spec_t  deviceSpec,
6637                    uint32_t               which)
6638 {
6639     static const xcb_protocol_request_t xcb_req = {
6640         .count = 2,
6641         .ext = &xcb_xkb_id,
6642         .opcode = XCB_XKB_GET_NAMES,
6643         .isvoid = 0
6644     };
6645 
6646     struct iovec xcb_parts[4];
6647     xcb_xkb_get_names_cookie_t xcb_ret;
6648     xcb_xkb_get_names_request_t xcb_out;
6649 
6650     xcb_out.deviceSpec = deviceSpec;
6651     memset(xcb_out.pad0, 0, 2);
6652     xcb_out.which = which;
6653 
6654     xcb_parts[2].iov_base = (char *) &xcb_out;
6655     xcb_parts[2].iov_len = sizeof(xcb_out);
6656     xcb_parts[3].iov_base = 0;
6657     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6658 
6659     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
6660     return xcb_ret;
6661 }
6662 
6663 xcb_xkb_get_names_cookie_t
xcb_xkb_get_names_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t which)6664 xcb_xkb_get_names_unchecked (xcb_connection_t      *c,
6665                              xcb_xkb_device_spec_t  deviceSpec,
6666                              uint32_t               which)
6667 {
6668     static const xcb_protocol_request_t xcb_req = {
6669         .count = 2,
6670         .ext = &xcb_xkb_id,
6671         .opcode = XCB_XKB_GET_NAMES,
6672         .isvoid = 0
6673     };
6674 
6675     struct iovec xcb_parts[4];
6676     xcb_xkb_get_names_cookie_t xcb_ret;
6677     xcb_xkb_get_names_request_t xcb_out;
6678 
6679     xcb_out.deviceSpec = deviceSpec;
6680     memset(xcb_out.pad0, 0, 2);
6681     xcb_out.which = which;
6682 
6683     xcb_parts[2].iov_base = (char *) &xcb_out;
6684     xcb_parts[2].iov_len = sizeof(xcb_out);
6685     xcb_parts[3].iov_base = 0;
6686     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
6687 
6688     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
6689     return xcb_ret;
6690 }
6691 
6692 void *
xcb_xkb_get_names_value_list(const xcb_xkb_get_names_reply_t * R)6693 xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R)
6694 {
6695     return (void *) (R + 1);
6696 }
6697 
6698 xcb_xkb_get_names_reply_t *
xcb_xkb_get_names_reply(xcb_connection_t * c,xcb_xkb_get_names_cookie_t cookie,xcb_generic_error_t ** e)6699 xcb_xkb_get_names_reply (xcb_connection_t            *c,
6700                          xcb_xkb_get_names_cookie_t   cookie  /**< */,
6701                          xcb_generic_error_t        **e)
6702 {
6703     return (xcb_xkb_get_names_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
6704 }
6705 
6706 xcb_atom_t *
xcb_xkb_set_names_values_type_names(const xcb_xkb_set_names_values_t * S)6707 xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S)
6708 {
6709     return S->typeNames;
6710 }
6711 
6712 int
xcb_xkb_set_names_values_type_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6713 xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R,
6714                                             const xcb_xkb_set_names_values_t *S)
6715 {
6716     return R->nTypes;
6717 }
6718 
6719 xcb_generic_iterator_t
xcb_xkb_set_names_values_type_names_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6720 xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R,
6721                                          const xcb_xkb_set_names_values_t *S)
6722 {
6723     xcb_generic_iterator_t i;
6724     i.data = S->typeNames + R->nTypes;
6725     i.rem = 0;
6726     i.index = (char *) i.data - (char *) S;
6727     return i;
6728 }
6729 
6730 uint8_t *
xcb_xkb_set_names_values_n_levels_per_type(const xcb_xkb_set_names_values_t * S)6731 xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S)
6732 {
6733     return S->nLevelsPerType;
6734 }
6735 
6736 int
xcb_xkb_set_names_values_n_levels_per_type_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6737 xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R,
6738                                                    const xcb_xkb_set_names_values_t *S)
6739 {
6740     return R->nTypes;
6741 }
6742 
6743 xcb_generic_iterator_t
xcb_xkb_set_names_values_n_levels_per_type_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6744 xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R,
6745                                                 const xcb_xkb_set_names_values_t *S)
6746 {
6747     xcb_generic_iterator_t i;
6748     i.data = S->nLevelsPerType + R->nTypes;
6749     i.rem = 0;
6750     i.index = (char *) i.data - (char *) S;
6751     return i;
6752 }
6753 
6754 xcb_atom_t *
xcb_xkb_set_names_values_kt_level_names(const xcb_xkb_set_names_values_t * S)6755 xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S)
6756 {
6757     return S->ktLevelNames;
6758 }
6759 
6760 int
xcb_xkb_set_names_values_kt_level_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6761 xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R,
6762                                                 const xcb_xkb_set_names_values_t *S)
6763 {
6764     int xcb_pre_tmp_1; /* sumof length */
6765     int xcb_pre_tmp_2; /* sumof loop counter */
6766     int64_t xcb_pre_tmp_3; /* sumof sum */
6767     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
6768     /* sumof start */
6769     xcb_pre_tmp_1 = R->nTypes;
6770     xcb_pre_tmp_3 = 0;
6771     xcb_pre_tmp_4 = S->nLevelsPerType;
6772     for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
6773         xcb_pre_tmp_3 += *xcb_pre_tmp_4;
6774         xcb_pre_tmp_4++;
6775     }
6776     /* sumof end. Result is in xcb_pre_tmp_3 */
6777     return xcb_pre_tmp_3;
6778 }
6779 
6780 xcb_generic_iterator_t
xcb_xkb_set_names_values_kt_level_names_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6781 xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R,
6782                                              const xcb_xkb_set_names_values_t *S)
6783 {
6784     xcb_generic_iterator_t i;
6785     int xcb_pre_tmp_5; /* sumof length */
6786     int xcb_pre_tmp_6; /* sumof loop counter */
6787     int64_t xcb_pre_tmp_7; /* sumof sum */
6788     const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
6789     /* sumof start */
6790     xcb_pre_tmp_5 = R->nTypes;
6791     xcb_pre_tmp_7 = 0;
6792     xcb_pre_tmp_8 = S->nLevelsPerType;
6793     for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
6794         xcb_pre_tmp_7 += *xcb_pre_tmp_8;
6795         xcb_pre_tmp_8++;
6796     }
6797     /* sumof end. Result is in xcb_pre_tmp_7 */
6798     i.data = S->ktLevelNames + xcb_pre_tmp_7;
6799     i.rem = 0;
6800     i.index = (char *) i.data - (char *) S;
6801     return i;
6802 }
6803 
6804 xcb_atom_t *
xcb_xkb_set_names_values_indicator_names(const xcb_xkb_set_names_values_t * S)6805 xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S)
6806 {
6807     return S->indicatorNames;
6808 }
6809 
6810 int
xcb_xkb_set_names_values_indicator_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6811 xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R,
6812                                                  const xcb_xkb_set_names_values_t *S)
6813 {
6814     return xcb_popcount(R->indicators);
6815 }
6816 
6817 xcb_generic_iterator_t
xcb_xkb_set_names_values_indicator_names_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6818 xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R,
6819                                               const xcb_xkb_set_names_values_t *S)
6820 {
6821     xcb_generic_iterator_t i;
6822     i.data = S->indicatorNames + xcb_popcount(R->indicators);
6823     i.rem = 0;
6824     i.index = (char *) i.data - (char *) S;
6825     return i;
6826 }
6827 
6828 xcb_atom_t *
xcb_xkb_set_names_values_virtual_mod_names(const xcb_xkb_set_names_values_t * S)6829 xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S)
6830 {
6831     return S->virtualModNames;
6832 }
6833 
6834 int
xcb_xkb_set_names_values_virtual_mod_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6835 xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R,
6836                                                    const xcb_xkb_set_names_values_t *S)
6837 {
6838     return xcb_popcount(R->virtualMods);
6839 }
6840 
6841 xcb_generic_iterator_t
xcb_xkb_set_names_values_virtual_mod_names_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6842 xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R,
6843                                                 const xcb_xkb_set_names_values_t *S)
6844 {
6845     xcb_generic_iterator_t i;
6846     i.data = S->virtualModNames + xcb_popcount(R->virtualMods);
6847     i.rem = 0;
6848     i.index = (char *) i.data - (char *) S;
6849     return i;
6850 }
6851 
6852 xcb_atom_t *
xcb_xkb_set_names_values_groups(const xcb_xkb_set_names_values_t * S)6853 xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S)
6854 {
6855     return S->groups;
6856 }
6857 
6858 int
xcb_xkb_set_names_values_groups_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6859 xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R,
6860                                         const xcb_xkb_set_names_values_t *S)
6861 {
6862     return xcb_popcount(R->groupNames);
6863 }
6864 
6865 xcb_generic_iterator_t
xcb_xkb_set_names_values_groups_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6866 xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R,
6867                                      const xcb_xkb_set_names_values_t *S)
6868 {
6869     xcb_generic_iterator_t i;
6870     i.data = S->groups + xcb_popcount(R->groupNames);
6871     i.rem = 0;
6872     i.index = (char *) i.data - (char *) S;
6873     return i;
6874 }
6875 
6876 xcb_xkb_key_name_t *
xcb_xkb_set_names_values_key_names(const xcb_xkb_set_names_values_t * S)6877 xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S)
6878 {
6879     return S->keyNames;
6880 }
6881 
6882 int
xcb_xkb_set_names_values_key_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6883 xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R,
6884                                            const xcb_xkb_set_names_values_t *S)
6885 {
6886     return R->nKeys;
6887 }
6888 
6889 xcb_xkb_key_name_iterator_t
xcb_xkb_set_names_values_key_names_iterator(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6890 xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R,
6891                                              const xcb_xkb_set_names_values_t *S)
6892 {
6893     xcb_xkb_key_name_iterator_t i;
6894     i.data = S->keyNames;
6895     i.rem = R->nKeys;
6896     i.index = (char *) i.data - (char *) S;
6897     return i;
6898 }
6899 
6900 xcb_xkb_key_alias_t *
xcb_xkb_set_names_values_key_aliases(const xcb_xkb_set_names_values_t * S)6901 xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S)
6902 {
6903     return S->keyAliases;
6904 }
6905 
6906 int
xcb_xkb_set_names_values_key_aliases_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6907 xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R,
6908                                              const xcb_xkb_set_names_values_t *S)
6909 {
6910     return R->nKeyAliases;
6911 }
6912 
6913 xcb_xkb_key_alias_iterator_t
xcb_xkb_set_names_values_key_aliases_iterator(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6914 xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R,
6915                                                const xcb_xkb_set_names_values_t *S)
6916 {
6917     xcb_xkb_key_alias_iterator_t i;
6918     i.data = S->keyAliases;
6919     i.rem = R->nKeyAliases;
6920     i.index = (char *) i.data - (char *) S;
6921     return i;
6922 }
6923 
6924 xcb_atom_t *
xcb_xkb_set_names_values_radio_group_names(const xcb_xkb_set_names_values_t * S)6925 xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S)
6926 {
6927     return S->radioGroupNames;
6928 }
6929 
6930 int
xcb_xkb_set_names_values_radio_group_names_length(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6931 xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R,
6932                                                    const xcb_xkb_set_names_values_t *S)
6933 {
6934     return R->nRadioGroups;
6935 }
6936 
6937 xcb_generic_iterator_t
xcb_xkb_set_names_values_radio_group_names_end(const xcb_xkb_set_names_request_t * R,const xcb_xkb_set_names_values_t * S)6938 xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R,
6939                                                 const xcb_xkb_set_names_values_t *S)
6940 {
6941     xcb_generic_iterator_t i;
6942     i.data = S->radioGroupNames + R->nRadioGroups;
6943     i.rem = 0;
6944     i.index = (char *) i.data - (char *) S;
6945     return i;
6946 }
6947 
6948 int
xcb_xkb_set_names_values_serialize(void ** _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,const xcb_xkb_set_names_values_t * _aux)6949 xcb_xkb_set_names_values_serialize (void                             **_buffer,
6950                                     uint8_t                            nTypes,
6951                                     uint32_t                           indicators,
6952                                     uint16_t                           virtualMods,
6953                                     uint8_t                            groupNames,
6954                                     uint8_t                            nKeys,
6955                                     uint8_t                            nKeyAliases,
6956                                     uint8_t                            nRadioGroups,
6957                                     uint32_t                           which,
6958                                     const xcb_xkb_set_names_values_t  *_aux)
6959 {
6960     char *xcb_out = *_buffer;
6961     unsigned int xcb_buffer_len = 0;
6962     unsigned int xcb_align_to = 0;
6963     unsigned int xcb_padding_offset = 0;
6964 
6965     int xcb_pre_tmp_1; /* sumof length */
6966     int xcb_pre_tmp_2; /* sumof loop counter */
6967     int64_t xcb_pre_tmp_3; /* sumof sum */
6968     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
6969     unsigned int xcb_pad = 0;
6970     char xcb_pad0[3] = {0, 0, 0};
6971     struct iovec xcb_parts[26];
6972     unsigned int xcb_parts_idx = 0;
6973     unsigned int xcb_block_len = 0;
6974     unsigned int i;
6975     char *xcb_tmp;
6976 
6977     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
6978         /* xcb_xkb_set_names_values_t.keycodesName */
6979         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
6980         xcb_block_len += sizeof(xcb_atom_t);
6981         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6982         xcb_parts_idx++;
6983         xcb_align_to = ALIGNOF(xcb_atom_t);
6984     }
6985     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
6986         /* xcb_xkb_set_names_values_t.geometryName */
6987         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
6988         xcb_block_len += sizeof(xcb_atom_t);
6989         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6990         xcb_parts_idx++;
6991         xcb_align_to = ALIGNOF(xcb_atom_t);
6992     }
6993     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
6994         /* xcb_xkb_set_names_values_t.symbolsName */
6995         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
6996         xcb_block_len += sizeof(xcb_atom_t);
6997         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
6998         xcb_parts_idx++;
6999         xcb_align_to = ALIGNOF(xcb_atom_t);
7000     }
7001     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
7002         /* xcb_xkb_set_names_values_t.physSymbolsName */
7003         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
7004         xcb_block_len += sizeof(xcb_atom_t);
7005         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
7006         xcb_parts_idx++;
7007         xcb_align_to = ALIGNOF(xcb_atom_t);
7008     }
7009     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
7010         /* xcb_xkb_set_names_values_t.typesName */
7011         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
7012         xcb_block_len += sizeof(xcb_atom_t);
7013         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
7014         xcb_parts_idx++;
7015         xcb_align_to = ALIGNOF(xcb_atom_t);
7016     }
7017     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
7018         /* xcb_xkb_set_names_values_t.compatName */
7019         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
7020         xcb_block_len += sizeof(xcb_atom_t);
7021         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
7022         xcb_parts_idx++;
7023         xcb_align_to = ALIGNOF(xcb_atom_t);
7024     }
7025     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
7026         /* insert padding */
7027         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7028         xcb_buffer_len += xcb_block_len + xcb_pad;
7029         if (0 != xcb_pad) {
7030             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7031             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7032             xcb_parts_idx++;
7033             xcb_pad = 0;
7034         }
7035         xcb_block_len = 0;
7036         xcb_padding_offset = 0;
7037         /* typeNames */
7038         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
7039         xcb_block_len += nTypes * sizeof(xcb_atom_t);
7040         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
7041         xcb_parts_idx++;
7042         xcb_align_to = ALIGNOF(xcb_atom_t);
7043     }
7044     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
7045         /* insert padding */
7046         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7047         xcb_buffer_len += xcb_block_len + xcb_pad;
7048         if (0 != xcb_pad) {
7049             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7050             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7051             xcb_parts_idx++;
7052             xcb_pad = 0;
7053         }
7054         xcb_block_len = 0;
7055         xcb_padding_offset = 0;
7056         /* nLevelsPerType */
7057         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
7058         xcb_block_len += nTypes * sizeof(uint8_t);
7059         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
7060         xcb_parts_idx++;
7061         xcb_align_to = ALIGNOF(uint8_t);
7062         xcb_align_to = 4;
7063         /* insert padding */
7064         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7065         xcb_buffer_len += xcb_block_len + xcb_pad;
7066         if (0 != xcb_pad) {
7067             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7068             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7069             xcb_parts_idx++;
7070             xcb_pad = 0;
7071         }
7072         xcb_block_len = 0;
7073         xcb_padding_offset = 0;
7074         /* insert padding */
7075         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7076         xcb_buffer_len += xcb_block_len + xcb_pad;
7077         if (0 != xcb_pad) {
7078             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7079             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7080             xcb_parts_idx++;
7081             xcb_pad = 0;
7082         }
7083         xcb_block_len = 0;
7084         xcb_padding_offset = 0;
7085         /* ktLevelNames */
7086         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
7087         /* sumof start */
7088         xcb_pre_tmp_1 = nTypes;
7089         xcb_pre_tmp_3 = 0;
7090         xcb_pre_tmp_4 = _aux->nLevelsPerType;
7091         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
7092             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
7093             xcb_pre_tmp_4++;
7094         }
7095         /* sumof end. Result is in xcb_pre_tmp_3 */
7096         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
7097         xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
7098         xcb_parts_idx++;
7099         xcb_align_to = ALIGNOF(xcb_atom_t);
7100     }
7101     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
7102         /* insert padding */
7103         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7104         xcb_buffer_len += xcb_block_len + xcb_pad;
7105         if (0 != xcb_pad) {
7106             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7107             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7108             xcb_parts_idx++;
7109             xcb_pad = 0;
7110         }
7111         xcb_block_len = 0;
7112         xcb_padding_offset = 0;
7113         /* indicatorNames */
7114         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
7115         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
7116         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
7117         xcb_parts_idx++;
7118         xcb_align_to = ALIGNOF(xcb_atom_t);
7119     }
7120     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
7121         /* insert padding */
7122         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7123         xcb_buffer_len += xcb_block_len + xcb_pad;
7124         if (0 != xcb_pad) {
7125             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7126             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7127             xcb_parts_idx++;
7128             xcb_pad = 0;
7129         }
7130         xcb_block_len = 0;
7131         xcb_padding_offset = 0;
7132         /* virtualModNames */
7133         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
7134         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
7135         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
7136         xcb_parts_idx++;
7137         xcb_align_to = ALIGNOF(xcb_atom_t);
7138     }
7139     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
7140         /* insert padding */
7141         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7142         xcb_buffer_len += xcb_block_len + xcb_pad;
7143         if (0 != xcb_pad) {
7144             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7145             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7146             xcb_parts_idx++;
7147             xcb_pad = 0;
7148         }
7149         xcb_block_len = 0;
7150         xcb_padding_offset = 0;
7151         /* groups */
7152         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
7153         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
7154         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
7155         xcb_parts_idx++;
7156         xcb_align_to = ALIGNOF(xcb_atom_t);
7157     }
7158     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
7159         /* insert padding */
7160         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7161         xcb_buffer_len += xcb_block_len + xcb_pad;
7162         if (0 != xcb_pad) {
7163             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7164             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7165             xcb_parts_idx++;
7166             xcb_pad = 0;
7167         }
7168         xcb_block_len = 0;
7169         xcb_padding_offset = 0;
7170         /* keyNames */
7171         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
7172         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
7173         xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
7174         xcb_parts_idx++;
7175         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
7176     }
7177     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
7178         /* insert padding */
7179         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7180         xcb_buffer_len += xcb_block_len + xcb_pad;
7181         if (0 != xcb_pad) {
7182             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7183             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7184             xcb_parts_idx++;
7185             xcb_pad = 0;
7186         }
7187         xcb_block_len = 0;
7188         xcb_padding_offset = 0;
7189         /* keyAliases */
7190         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
7191         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
7192         xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
7193         xcb_parts_idx++;
7194         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
7195     }
7196     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
7197         /* insert padding */
7198         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7199         xcb_buffer_len += xcb_block_len + xcb_pad;
7200         if (0 != xcb_pad) {
7201             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7202             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7203             xcb_parts_idx++;
7204             xcb_pad = 0;
7205         }
7206         xcb_block_len = 0;
7207         xcb_padding_offset = 0;
7208         /* radioGroupNames */
7209         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
7210         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
7211         xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
7212         xcb_parts_idx++;
7213         xcb_align_to = ALIGNOF(xcb_atom_t);
7214     }
7215     /* insert padding */
7216     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7217     xcb_buffer_len += xcb_block_len + xcb_pad;
7218     if (0 != xcb_pad) {
7219         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
7220         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
7221         xcb_parts_idx++;
7222         xcb_pad = 0;
7223     }
7224     xcb_block_len = 0;
7225     xcb_padding_offset = 0;
7226 
7227     if (NULL == xcb_out) {
7228         /* allocate memory */
7229         xcb_out = malloc(xcb_buffer_len);
7230         *_buffer = xcb_out;
7231     }
7232 
7233     xcb_tmp = xcb_out;
7234     for(i=0; i<xcb_parts_idx; i++) {
7235         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
7236             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
7237         if (0 != xcb_parts[i].iov_len)
7238             xcb_tmp += xcb_parts[i].iov_len;
7239     }
7240 
7241     return xcb_buffer_len;
7242 }
7243 
7244 int
xcb_xkb_set_names_values_unpack(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,xcb_xkb_set_names_values_t * _aux)7245 xcb_xkb_set_names_values_unpack (const void                  *_buffer,
7246                                  uint8_t                      nTypes,
7247                                  uint32_t                     indicators,
7248                                  uint16_t                     virtualMods,
7249                                  uint8_t                      groupNames,
7250                                  uint8_t                      nKeys,
7251                                  uint8_t                      nKeyAliases,
7252                                  uint8_t                      nRadioGroups,
7253                                  uint32_t                     which,
7254                                  xcb_xkb_set_names_values_t  *_aux)
7255 {
7256     char *xcb_tmp = (char *)_buffer;
7257     unsigned int xcb_buffer_len = 0;
7258     unsigned int xcb_block_len = 0;
7259     unsigned int xcb_pad = 0;
7260     unsigned int xcb_align_to = 0;
7261     unsigned int xcb_padding_offset = 0;
7262 
7263     int xcb_pre_tmp_1; /* sumof length */
7264     int xcb_pre_tmp_2; /* sumof loop counter */
7265     int64_t xcb_pre_tmp_3; /* sumof sum */
7266     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
7267 
7268     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
7269         /* xcb_xkb_set_names_values_t.keycodesName */
7270         _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
7271         xcb_block_len += sizeof(xcb_atom_t);
7272         xcb_tmp += sizeof(xcb_atom_t);
7273         xcb_align_to = ALIGNOF(xcb_atom_t);
7274     }
7275     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
7276         /* xcb_xkb_set_names_values_t.geometryName */
7277         _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
7278         xcb_block_len += sizeof(xcb_atom_t);
7279         xcb_tmp += sizeof(xcb_atom_t);
7280         xcb_align_to = ALIGNOF(xcb_atom_t);
7281     }
7282     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
7283         /* xcb_xkb_set_names_values_t.symbolsName */
7284         _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
7285         xcb_block_len += sizeof(xcb_atom_t);
7286         xcb_tmp += sizeof(xcb_atom_t);
7287         xcb_align_to = ALIGNOF(xcb_atom_t);
7288     }
7289     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
7290         /* xcb_xkb_set_names_values_t.physSymbolsName */
7291         _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
7292         xcb_block_len += sizeof(xcb_atom_t);
7293         xcb_tmp += sizeof(xcb_atom_t);
7294         xcb_align_to = ALIGNOF(xcb_atom_t);
7295     }
7296     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
7297         /* xcb_xkb_set_names_values_t.typesName */
7298         _aux->typesName = *(xcb_atom_t *)xcb_tmp;
7299         xcb_block_len += sizeof(xcb_atom_t);
7300         xcb_tmp += sizeof(xcb_atom_t);
7301         xcb_align_to = ALIGNOF(xcb_atom_t);
7302     }
7303     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
7304         /* xcb_xkb_set_names_values_t.compatName */
7305         _aux->compatName = *(xcb_atom_t *)xcb_tmp;
7306         xcb_block_len += sizeof(xcb_atom_t);
7307         xcb_tmp += sizeof(xcb_atom_t);
7308         xcb_align_to = ALIGNOF(xcb_atom_t);
7309     }
7310     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
7311         /* insert padding */
7312         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7313         xcb_buffer_len += xcb_block_len + xcb_pad;
7314         if (0 != xcb_pad) {
7315             xcb_tmp += xcb_pad;
7316             xcb_pad = 0;
7317         }
7318         xcb_block_len = 0;
7319         xcb_padding_offset = 0;
7320         /* typeNames */
7321         _aux->typeNames = (xcb_atom_t *)xcb_tmp;
7322         xcb_block_len += nTypes * sizeof(xcb_atom_t);
7323         xcb_tmp += xcb_block_len;
7324         xcb_align_to = ALIGNOF(xcb_atom_t);
7325     }
7326     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
7327         /* insert padding */
7328         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7329         xcb_buffer_len += xcb_block_len + xcb_pad;
7330         if (0 != xcb_pad) {
7331             xcb_tmp += xcb_pad;
7332             xcb_pad = 0;
7333         }
7334         xcb_block_len = 0;
7335         xcb_padding_offset = 0;
7336         /* nLevelsPerType */
7337         _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
7338         xcb_block_len += nTypes * sizeof(uint8_t);
7339         xcb_tmp += xcb_block_len;
7340         xcb_align_to = ALIGNOF(uint8_t);
7341         xcb_align_to = 4;
7342         /* insert padding */
7343         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7344         xcb_buffer_len += xcb_block_len + xcb_pad;
7345         if (0 != xcb_pad) {
7346             xcb_tmp += xcb_pad;
7347             xcb_pad = 0;
7348         }
7349         xcb_block_len = 0;
7350         xcb_padding_offset = 0;
7351         /* insert padding */
7352         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7353         xcb_buffer_len += xcb_block_len + xcb_pad;
7354         if (0 != xcb_pad) {
7355             xcb_tmp += xcb_pad;
7356             xcb_pad = 0;
7357         }
7358         xcb_block_len = 0;
7359         xcb_padding_offset = 0;
7360         /* ktLevelNames */
7361         _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
7362         /* sumof start */
7363         xcb_pre_tmp_1 = nTypes;
7364         xcb_pre_tmp_3 = 0;
7365         xcb_pre_tmp_4 = _aux->nLevelsPerType;
7366         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
7367             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
7368             xcb_pre_tmp_4++;
7369         }
7370         /* sumof end. Result is in xcb_pre_tmp_3 */
7371         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
7372         xcb_tmp += xcb_block_len;
7373         xcb_align_to = ALIGNOF(xcb_atom_t);
7374     }
7375     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
7376         /* insert padding */
7377         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7378         xcb_buffer_len += xcb_block_len + xcb_pad;
7379         if (0 != xcb_pad) {
7380             xcb_tmp += xcb_pad;
7381             xcb_pad = 0;
7382         }
7383         xcb_block_len = 0;
7384         xcb_padding_offset = 0;
7385         /* indicatorNames */
7386         _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
7387         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
7388         xcb_tmp += xcb_block_len;
7389         xcb_align_to = ALIGNOF(xcb_atom_t);
7390     }
7391     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
7392         /* insert padding */
7393         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7394         xcb_buffer_len += xcb_block_len + xcb_pad;
7395         if (0 != xcb_pad) {
7396             xcb_tmp += xcb_pad;
7397             xcb_pad = 0;
7398         }
7399         xcb_block_len = 0;
7400         xcb_padding_offset = 0;
7401         /* virtualModNames */
7402         _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
7403         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
7404         xcb_tmp += xcb_block_len;
7405         xcb_align_to = ALIGNOF(xcb_atom_t);
7406     }
7407     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
7408         /* insert padding */
7409         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7410         xcb_buffer_len += xcb_block_len + xcb_pad;
7411         if (0 != xcb_pad) {
7412             xcb_tmp += xcb_pad;
7413             xcb_pad = 0;
7414         }
7415         xcb_block_len = 0;
7416         xcb_padding_offset = 0;
7417         /* groups */
7418         _aux->groups = (xcb_atom_t *)xcb_tmp;
7419         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
7420         xcb_tmp += xcb_block_len;
7421         xcb_align_to = ALIGNOF(xcb_atom_t);
7422     }
7423     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
7424         /* insert padding */
7425         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7426         xcb_buffer_len += xcb_block_len + xcb_pad;
7427         if (0 != xcb_pad) {
7428             xcb_tmp += xcb_pad;
7429             xcb_pad = 0;
7430         }
7431         xcb_block_len = 0;
7432         xcb_padding_offset = 0;
7433         /* keyNames */
7434         _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
7435         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
7436         xcb_tmp += xcb_block_len;
7437         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
7438     }
7439     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
7440         /* insert padding */
7441         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7442         xcb_buffer_len += xcb_block_len + xcb_pad;
7443         if (0 != xcb_pad) {
7444             xcb_tmp += xcb_pad;
7445             xcb_pad = 0;
7446         }
7447         xcb_block_len = 0;
7448         xcb_padding_offset = 0;
7449         /* keyAliases */
7450         _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
7451         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
7452         xcb_tmp += xcb_block_len;
7453         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
7454     }
7455     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
7456         /* insert padding */
7457         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7458         xcb_buffer_len += xcb_block_len + xcb_pad;
7459         if (0 != xcb_pad) {
7460             xcb_tmp += xcb_pad;
7461             xcb_pad = 0;
7462         }
7463         xcb_block_len = 0;
7464         xcb_padding_offset = 0;
7465         /* radioGroupNames */
7466         _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
7467         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
7468         xcb_tmp += xcb_block_len;
7469         xcb_align_to = ALIGNOF(xcb_atom_t);
7470     }
7471     /* insert padding */
7472     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
7473     xcb_buffer_len += xcb_block_len + xcb_pad;
7474     if (0 != xcb_pad) {
7475         xcb_tmp += xcb_pad;
7476         xcb_pad = 0;
7477     }
7478     xcb_block_len = 0;
7479     xcb_padding_offset = 0;
7480 
7481     return xcb_buffer_len;
7482 }
7483 
7484 int
xcb_xkb_set_names_values_sizeof(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which)7485 xcb_xkb_set_names_values_sizeof (const void  *_buffer,
7486                                  uint8_t      nTypes,
7487                                  uint32_t     indicators,
7488                                  uint16_t     virtualMods,
7489                                  uint8_t      groupNames,
7490                                  uint8_t      nKeys,
7491                                  uint8_t      nKeyAliases,
7492                                  uint8_t      nRadioGroups,
7493                                  uint32_t     which)
7494 {
7495     xcb_xkb_set_names_values_t _aux;
7496     return xcb_xkb_set_names_values_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
7497 }
7498 
7499 int
xcb_xkb_set_names_sizeof(const void * _buffer)7500 xcb_xkb_set_names_sizeof (const void  *_buffer)
7501 {
7502     char *xcb_tmp = (char *)_buffer;
7503     const xcb_xkb_set_names_request_t *_aux = (xcb_xkb_set_names_request_t *)_buffer;
7504     unsigned int xcb_buffer_len = 0;
7505     unsigned int xcb_block_len = 0;
7506     unsigned int xcb_pad = 0;
7507     unsigned int xcb_align_to = 0;
7508 
7509 
7510     xcb_block_len += sizeof(xcb_xkb_set_names_request_t);
7511     xcb_tmp += xcb_block_len;
7512     xcb_buffer_len += xcb_block_len;
7513     xcb_block_len = 0;
7514     /* values */
7515     xcb_block_len += xcb_xkb_set_names_values_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which);
7516     xcb_tmp += xcb_block_len;
7517     xcb_align_to = ALIGNOF(char);
7518     /* insert padding */
7519     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7520     xcb_buffer_len += xcb_block_len + xcb_pad;
7521     if (0 != xcb_pad) {
7522         xcb_tmp += xcb_pad;
7523         xcb_pad = 0;
7524     }
7525     xcb_block_len = 0;
7526 
7527     return xcb_buffer_len;
7528 }
7529 
7530 xcb_void_cookie_t
xcb_xkb_set_names_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t virtualMods,uint32_t which,uint8_t firstType,uint8_t nTypes,uint8_t firstKTLevelt,uint8_t nKTLevels,uint32_t indicators,uint8_t groupNames,uint8_t nRadioGroups,xcb_keycode_t firstKey,uint8_t nKeys,uint8_t nKeyAliases,uint16_t totalKTLevelNames,const void * values)7531 xcb_xkb_set_names_checked (xcb_connection_t      *c,
7532                            xcb_xkb_device_spec_t  deviceSpec,
7533                            uint16_t               virtualMods,
7534                            uint32_t               which,
7535                            uint8_t                firstType,
7536                            uint8_t                nTypes,
7537                            uint8_t                firstKTLevelt,
7538                            uint8_t                nKTLevels,
7539                            uint32_t               indicators,
7540                            uint8_t                groupNames,
7541                            uint8_t                nRadioGroups,
7542                            xcb_keycode_t          firstKey,
7543                            uint8_t                nKeys,
7544                            uint8_t                nKeyAliases,
7545                            uint16_t               totalKTLevelNames,
7546                            const void            *values)
7547 {
7548     static const xcb_protocol_request_t xcb_req = {
7549         .count = 3,
7550         .ext = &xcb_xkb_id,
7551         .opcode = XCB_XKB_SET_NAMES,
7552         .isvoid = 1
7553     };
7554 
7555     struct iovec xcb_parts[5];
7556     xcb_void_cookie_t xcb_ret;
7557     xcb_xkb_set_names_request_t xcb_out;
7558 
7559     xcb_out.deviceSpec = deviceSpec;
7560     xcb_out.virtualMods = virtualMods;
7561     xcb_out.which = which;
7562     xcb_out.firstType = firstType;
7563     xcb_out.nTypes = nTypes;
7564     xcb_out.firstKTLevelt = firstKTLevelt;
7565     xcb_out.nKTLevels = nKTLevels;
7566     xcb_out.indicators = indicators;
7567     xcb_out.groupNames = groupNames;
7568     xcb_out.nRadioGroups = nRadioGroups;
7569     xcb_out.firstKey = firstKey;
7570     xcb_out.nKeys = nKeys;
7571     xcb_out.nKeyAliases = nKeyAliases;
7572     xcb_out.pad0 = 0;
7573     xcb_out.totalKTLevelNames = totalKTLevelNames;
7574 
7575     xcb_parts[2].iov_base = (char *) &xcb_out;
7576     xcb_parts[2].iov_len = sizeof(xcb_out);
7577     xcb_parts[3].iov_base = 0;
7578     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7579     /* xcb_xkb_set_names_values_t values */
7580     xcb_parts[4].iov_base = (char *) values;
7581     xcb_parts[4].iov_len =
7582       xcb_xkb_set_names_values_sizeof (values, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which);
7583 
7584     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7585     return xcb_ret;
7586 }
7587 
7588 xcb_void_cookie_t
xcb_xkb_set_names(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t virtualMods,uint32_t which,uint8_t firstType,uint8_t nTypes,uint8_t firstKTLevelt,uint8_t nKTLevels,uint32_t indicators,uint8_t groupNames,uint8_t nRadioGroups,xcb_keycode_t firstKey,uint8_t nKeys,uint8_t nKeyAliases,uint16_t totalKTLevelNames,const void * values)7589 xcb_xkb_set_names (xcb_connection_t      *c,
7590                    xcb_xkb_device_spec_t  deviceSpec,
7591                    uint16_t               virtualMods,
7592                    uint32_t               which,
7593                    uint8_t                firstType,
7594                    uint8_t                nTypes,
7595                    uint8_t                firstKTLevelt,
7596                    uint8_t                nKTLevels,
7597                    uint32_t               indicators,
7598                    uint8_t                groupNames,
7599                    uint8_t                nRadioGroups,
7600                    xcb_keycode_t          firstKey,
7601                    uint8_t                nKeys,
7602                    uint8_t                nKeyAliases,
7603                    uint16_t               totalKTLevelNames,
7604                    const void            *values)
7605 {
7606     static const xcb_protocol_request_t xcb_req = {
7607         .count = 3,
7608         .ext = &xcb_xkb_id,
7609         .opcode = XCB_XKB_SET_NAMES,
7610         .isvoid = 1
7611     };
7612 
7613     struct iovec xcb_parts[5];
7614     xcb_void_cookie_t xcb_ret;
7615     xcb_xkb_set_names_request_t xcb_out;
7616 
7617     xcb_out.deviceSpec = deviceSpec;
7618     xcb_out.virtualMods = virtualMods;
7619     xcb_out.which = which;
7620     xcb_out.firstType = firstType;
7621     xcb_out.nTypes = nTypes;
7622     xcb_out.firstKTLevelt = firstKTLevelt;
7623     xcb_out.nKTLevels = nKTLevels;
7624     xcb_out.indicators = indicators;
7625     xcb_out.groupNames = groupNames;
7626     xcb_out.nRadioGroups = nRadioGroups;
7627     xcb_out.firstKey = firstKey;
7628     xcb_out.nKeys = nKeys;
7629     xcb_out.nKeyAliases = nKeyAliases;
7630     xcb_out.pad0 = 0;
7631     xcb_out.totalKTLevelNames = totalKTLevelNames;
7632 
7633     xcb_parts[2].iov_base = (char *) &xcb_out;
7634     xcb_parts[2].iov_len = sizeof(xcb_out);
7635     xcb_parts[3].iov_base = 0;
7636     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7637     /* xcb_xkb_set_names_values_t values */
7638     xcb_parts[4].iov_base = (char *) values;
7639     xcb_parts[4].iov_len =
7640       xcb_xkb_set_names_values_sizeof (values, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which);
7641 
7642     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7643     return xcb_ret;
7644 }
7645 
7646 xcb_void_cookie_t
xcb_xkb_set_names_aux_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t virtualMods,uint32_t which,uint8_t firstType,uint8_t nTypes,uint8_t firstKTLevelt,uint8_t nKTLevels,uint32_t indicators,uint8_t groupNames,uint8_t nRadioGroups,xcb_keycode_t firstKey,uint8_t nKeys,uint8_t nKeyAliases,uint16_t totalKTLevelNames,const xcb_xkb_set_names_values_t * values)7647 xcb_xkb_set_names_aux_checked (xcb_connection_t                 *c,
7648                                xcb_xkb_device_spec_t             deviceSpec,
7649                                uint16_t                          virtualMods,
7650                                uint32_t                          which,
7651                                uint8_t                           firstType,
7652                                uint8_t                           nTypes,
7653                                uint8_t                           firstKTLevelt,
7654                                uint8_t                           nKTLevels,
7655                                uint32_t                          indicators,
7656                                uint8_t                           groupNames,
7657                                uint8_t                           nRadioGroups,
7658                                xcb_keycode_t                     firstKey,
7659                                uint8_t                           nKeys,
7660                                uint8_t                           nKeyAliases,
7661                                uint16_t                          totalKTLevelNames,
7662                                const xcb_xkb_set_names_values_t *values)
7663 {
7664     static const xcb_protocol_request_t xcb_req = {
7665         .count = 3,
7666         .ext = &xcb_xkb_id,
7667         .opcode = XCB_XKB_SET_NAMES,
7668         .isvoid = 1
7669     };
7670 
7671     struct iovec xcb_parts[5];
7672     xcb_void_cookie_t xcb_ret;
7673     xcb_xkb_set_names_request_t xcb_out;
7674     void *xcb_aux0 = 0;
7675 
7676     xcb_out.deviceSpec = deviceSpec;
7677     xcb_out.virtualMods = virtualMods;
7678     xcb_out.which = which;
7679     xcb_out.firstType = firstType;
7680     xcb_out.nTypes = nTypes;
7681     xcb_out.firstKTLevelt = firstKTLevelt;
7682     xcb_out.nKTLevels = nKTLevels;
7683     xcb_out.indicators = indicators;
7684     xcb_out.groupNames = groupNames;
7685     xcb_out.nRadioGroups = nRadioGroups;
7686     xcb_out.firstKey = firstKey;
7687     xcb_out.nKeys = nKeys;
7688     xcb_out.nKeyAliases = nKeyAliases;
7689     xcb_out.pad0 = 0;
7690     xcb_out.totalKTLevelNames = totalKTLevelNames;
7691 
7692     xcb_parts[2].iov_base = (char *) &xcb_out;
7693     xcb_parts[2].iov_len = sizeof(xcb_out);
7694     xcb_parts[3].iov_base = 0;
7695     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7696     /* xcb_xkb_set_names_values_t values */
7697     xcb_parts[4].iov_len =
7698       xcb_xkb_set_names_values_serialize (&xcb_aux0, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, values);
7699     xcb_parts[4].iov_base = xcb_aux0;
7700 
7701     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7702     free(xcb_aux0);
7703     return xcb_ret;
7704 }
7705 
7706 xcb_void_cookie_t
xcb_xkb_set_names_aux(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t virtualMods,uint32_t which,uint8_t firstType,uint8_t nTypes,uint8_t firstKTLevelt,uint8_t nKTLevels,uint32_t indicators,uint8_t groupNames,uint8_t nRadioGroups,xcb_keycode_t firstKey,uint8_t nKeys,uint8_t nKeyAliases,uint16_t totalKTLevelNames,const xcb_xkb_set_names_values_t * values)7707 xcb_xkb_set_names_aux (xcb_connection_t                 *c,
7708                        xcb_xkb_device_spec_t             deviceSpec,
7709                        uint16_t                          virtualMods,
7710                        uint32_t                          which,
7711                        uint8_t                           firstType,
7712                        uint8_t                           nTypes,
7713                        uint8_t                           firstKTLevelt,
7714                        uint8_t                           nKTLevels,
7715                        uint32_t                          indicators,
7716                        uint8_t                           groupNames,
7717                        uint8_t                           nRadioGroups,
7718                        xcb_keycode_t                     firstKey,
7719                        uint8_t                           nKeys,
7720                        uint8_t                           nKeyAliases,
7721                        uint16_t                          totalKTLevelNames,
7722                        const xcb_xkb_set_names_values_t *values)
7723 {
7724     static const xcb_protocol_request_t xcb_req = {
7725         .count = 3,
7726         .ext = &xcb_xkb_id,
7727         .opcode = XCB_XKB_SET_NAMES,
7728         .isvoid = 1
7729     };
7730 
7731     struct iovec xcb_parts[5];
7732     xcb_void_cookie_t xcb_ret;
7733     xcb_xkb_set_names_request_t xcb_out;
7734     void *xcb_aux0 = 0;
7735 
7736     xcb_out.deviceSpec = deviceSpec;
7737     xcb_out.virtualMods = virtualMods;
7738     xcb_out.which = which;
7739     xcb_out.firstType = firstType;
7740     xcb_out.nTypes = nTypes;
7741     xcb_out.firstKTLevelt = firstKTLevelt;
7742     xcb_out.nKTLevels = nKTLevels;
7743     xcb_out.indicators = indicators;
7744     xcb_out.groupNames = groupNames;
7745     xcb_out.nRadioGroups = nRadioGroups;
7746     xcb_out.firstKey = firstKey;
7747     xcb_out.nKeys = nKeys;
7748     xcb_out.nKeyAliases = nKeyAliases;
7749     xcb_out.pad0 = 0;
7750     xcb_out.totalKTLevelNames = totalKTLevelNames;
7751 
7752     xcb_parts[2].iov_base = (char *) &xcb_out;
7753     xcb_parts[2].iov_len = sizeof(xcb_out);
7754     xcb_parts[3].iov_base = 0;
7755     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7756     /* xcb_xkb_set_names_values_t values */
7757     xcb_parts[4].iov_len =
7758       xcb_xkb_set_names_values_serialize (&xcb_aux0, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, values);
7759     xcb_parts[4].iov_base = xcb_aux0;
7760 
7761     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7762     free(xcb_aux0);
7763     return xcb_ret;
7764 }
7765 
7766 void *
xcb_xkb_set_names_values(const xcb_xkb_set_names_request_t * R)7767 xcb_xkb_set_names_values (const xcb_xkb_set_names_request_t *R)
7768 {
7769     return (void *) (R + 1);
7770 }
7771 
7772 xcb_xkb_per_client_flags_cookie_t
xcb_xkb_per_client_flags(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t change,uint32_t value,uint32_t ctrlsToChange,uint32_t autoCtrls,uint32_t autoCtrlsValues)7773 xcb_xkb_per_client_flags (xcb_connection_t      *c,
7774                           xcb_xkb_device_spec_t  deviceSpec,
7775                           uint32_t               change,
7776                           uint32_t               value,
7777                           uint32_t               ctrlsToChange,
7778                           uint32_t               autoCtrls,
7779                           uint32_t               autoCtrlsValues)
7780 {
7781     static const xcb_protocol_request_t xcb_req = {
7782         .count = 2,
7783         .ext = &xcb_xkb_id,
7784         .opcode = XCB_XKB_PER_CLIENT_FLAGS,
7785         .isvoid = 0
7786     };
7787 
7788     struct iovec xcb_parts[4];
7789     xcb_xkb_per_client_flags_cookie_t xcb_ret;
7790     xcb_xkb_per_client_flags_request_t xcb_out;
7791 
7792     xcb_out.deviceSpec = deviceSpec;
7793     memset(xcb_out.pad0, 0, 2);
7794     xcb_out.change = change;
7795     xcb_out.value = value;
7796     xcb_out.ctrlsToChange = ctrlsToChange;
7797     xcb_out.autoCtrls = autoCtrls;
7798     xcb_out.autoCtrlsValues = autoCtrlsValues;
7799 
7800     xcb_parts[2].iov_base = (char *) &xcb_out;
7801     xcb_parts[2].iov_len = sizeof(xcb_out);
7802     xcb_parts[3].iov_base = 0;
7803     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7804 
7805     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7806     return xcb_ret;
7807 }
7808 
7809 xcb_xkb_per_client_flags_cookie_t
xcb_xkb_per_client_flags_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint32_t change,uint32_t value,uint32_t ctrlsToChange,uint32_t autoCtrls,uint32_t autoCtrlsValues)7810 xcb_xkb_per_client_flags_unchecked (xcb_connection_t      *c,
7811                                     xcb_xkb_device_spec_t  deviceSpec,
7812                                     uint32_t               change,
7813                                     uint32_t               value,
7814                                     uint32_t               ctrlsToChange,
7815                                     uint32_t               autoCtrls,
7816                                     uint32_t               autoCtrlsValues)
7817 {
7818     static const xcb_protocol_request_t xcb_req = {
7819         .count = 2,
7820         .ext = &xcb_xkb_id,
7821         .opcode = XCB_XKB_PER_CLIENT_FLAGS,
7822         .isvoid = 0
7823     };
7824 
7825     struct iovec xcb_parts[4];
7826     xcb_xkb_per_client_flags_cookie_t xcb_ret;
7827     xcb_xkb_per_client_flags_request_t xcb_out;
7828 
7829     xcb_out.deviceSpec = deviceSpec;
7830     memset(xcb_out.pad0, 0, 2);
7831     xcb_out.change = change;
7832     xcb_out.value = value;
7833     xcb_out.ctrlsToChange = ctrlsToChange;
7834     xcb_out.autoCtrls = autoCtrls;
7835     xcb_out.autoCtrlsValues = autoCtrlsValues;
7836 
7837     xcb_parts[2].iov_base = (char *) &xcb_out;
7838     xcb_parts[2].iov_len = sizeof(xcb_out);
7839     xcb_parts[3].iov_base = 0;
7840     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7841 
7842     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
7843     return xcb_ret;
7844 }
7845 
7846 xcb_xkb_per_client_flags_reply_t *
xcb_xkb_per_client_flags_reply(xcb_connection_t * c,xcb_xkb_per_client_flags_cookie_t cookie,xcb_generic_error_t ** e)7847 xcb_xkb_per_client_flags_reply (xcb_connection_t                   *c,
7848                                 xcb_xkb_per_client_flags_cookie_t   cookie  /**< */,
7849                                 xcb_generic_error_t               **e)
7850 {
7851     return (xcb_xkb_per_client_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
7852 }
7853 
7854 int
xcb_xkb_list_components_sizeof(const void * _buffer)7855 xcb_xkb_list_components_sizeof (const void  *_buffer)
7856 {
7857     char *xcb_tmp = (char *)_buffer;
7858     const xcb_xkb_list_components_reply_t *_aux = (xcb_xkb_list_components_reply_t *)_buffer;
7859     unsigned int xcb_buffer_len = 0;
7860     unsigned int xcb_block_len = 0;
7861     unsigned int xcb_pad = 0;
7862     unsigned int xcb_align_to = 0;
7863 
7864     unsigned int i;
7865     unsigned int xcb_tmp_len;
7866 
7867     xcb_block_len += sizeof(xcb_xkb_list_components_reply_t);
7868     xcb_tmp += xcb_block_len;
7869     xcb_buffer_len += xcb_block_len;
7870     xcb_block_len = 0;
7871     /* keymaps */
7872     for(i=0; i<_aux->nKeymaps; i++) {
7873         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7874         xcb_block_len += xcb_tmp_len;
7875         xcb_tmp += xcb_tmp_len;
7876     }
7877     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7878     /* insert padding */
7879     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7880     xcb_buffer_len += xcb_block_len + xcb_pad;
7881     if (0 != xcb_pad) {
7882         xcb_tmp += xcb_pad;
7883         xcb_pad = 0;
7884     }
7885     xcb_block_len = 0;
7886     /* keycodes */
7887     for(i=0; i<_aux->nKeycodes; i++) {
7888         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7889         xcb_block_len += xcb_tmp_len;
7890         xcb_tmp += xcb_tmp_len;
7891     }
7892     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7893     /* insert padding */
7894     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7895     xcb_buffer_len += xcb_block_len + xcb_pad;
7896     if (0 != xcb_pad) {
7897         xcb_tmp += xcb_pad;
7898         xcb_pad = 0;
7899     }
7900     xcb_block_len = 0;
7901     /* types */
7902     for(i=0; i<_aux->nTypes; i++) {
7903         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7904         xcb_block_len += xcb_tmp_len;
7905         xcb_tmp += xcb_tmp_len;
7906     }
7907     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7908     /* insert padding */
7909     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7910     xcb_buffer_len += xcb_block_len + xcb_pad;
7911     if (0 != xcb_pad) {
7912         xcb_tmp += xcb_pad;
7913         xcb_pad = 0;
7914     }
7915     xcb_block_len = 0;
7916     /* compatMaps */
7917     for(i=0; i<_aux->nCompatMaps; i++) {
7918         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7919         xcb_block_len += xcb_tmp_len;
7920         xcb_tmp += xcb_tmp_len;
7921     }
7922     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7923     /* insert padding */
7924     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7925     xcb_buffer_len += xcb_block_len + xcb_pad;
7926     if (0 != xcb_pad) {
7927         xcb_tmp += xcb_pad;
7928         xcb_pad = 0;
7929     }
7930     xcb_block_len = 0;
7931     /* symbols */
7932     for(i=0; i<_aux->nSymbols; i++) {
7933         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7934         xcb_block_len += xcb_tmp_len;
7935         xcb_tmp += xcb_tmp_len;
7936     }
7937     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7938     /* insert padding */
7939     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7940     xcb_buffer_len += xcb_block_len + xcb_pad;
7941     if (0 != xcb_pad) {
7942         xcb_tmp += xcb_pad;
7943         xcb_pad = 0;
7944     }
7945     xcb_block_len = 0;
7946     /* geometries */
7947     for(i=0; i<_aux->nGeometries; i++) {
7948         xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
7949         xcb_block_len += xcb_tmp_len;
7950         xcb_tmp += xcb_tmp_len;
7951     }
7952     xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
7953     /* insert padding */
7954     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
7955     xcb_buffer_len += xcb_block_len + xcb_pad;
7956     if (0 != xcb_pad) {
7957         xcb_tmp += xcb_pad;
7958         xcb_pad = 0;
7959     }
7960     xcb_block_len = 0;
7961 
7962     return xcb_buffer_len;
7963 }
7964 
7965 xcb_xkb_list_components_cookie_t
xcb_xkb_list_components(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t maxNames)7966 xcb_xkb_list_components (xcb_connection_t      *c,
7967                          xcb_xkb_device_spec_t  deviceSpec,
7968                          uint16_t               maxNames)
7969 {
7970     static const xcb_protocol_request_t xcb_req = {
7971         .count = 2,
7972         .ext = &xcb_xkb_id,
7973         .opcode = XCB_XKB_LIST_COMPONENTS,
7974         .isvoid = 0
7975     };
7976 
7977     struct iovec xcb_parts[4];
7978     xcb_xkb_list_components_cookie_t xcb_ret;
7979     xcb_xkb_list_components_request_t xcb_out;
7980 
7981     xcb_out.deviceSpec = deviceSpec;
7982     xcb_out.maxNames = maxNames;
7983 
7984     xcb_parts[2].iov_base = (char *) &xcb_out;
7985     xcb_parts[2].iov_len = sizeof(xcb_out);
7986     xcb_parts[3].iov_base = 0;
7987     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
7988 
7989     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
7990     return xcb_ret;
7991 }
7992 
7993 xcb_xkb_list_components_cookie_t
xcb_xkb_list_components_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t maxNames)7994 xcb_xkb_list_components_unchecked (xcb_connection_t      *c,
7995                                    xcb_xkb_device_spec_t  deviceSpec,
7996                                    uint16_t               maxNames)
7997 {
7998     static const xcb_protocol_request_t xcb_req = {
7999         .count = 2,
8000         .ext = &xcb_xkb_id,
8001         .opcode = XCB_XKB_LIST_COMPONENTS,
8002         .isvoid = 0
8003     };
8004 
8005     struct iovec xcb_parts[4];
8006     xcb_xkb_list_components_cookie_t xcb_ret;
8007     xcb_xkb_list_components_request_t xcb_out;
8008 
8009     xcb_out.deviceSpec = deviceSpec;
8010     xcb_out.maxNames = maxNames;
8011 
8012     xcb_parts[2].iov_base = (char *) &xcb_out;
8013     xcb_parts[2].iov_len = sizeof(xcb_out);
8014     xcb_parts[3].iov_base = 0;
8015     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
8016 
8017     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
8018     return xcb_ret;
8019 }
8020 
8021 int
xcb_xkb_list_components_keymaps_length(const xcb_xkb_list_components_reply_t * R)8022 xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R)
8023 {
8024     return R->nKeymaps;
8025 }
8026 
8027 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_keymaps_iterator(const xcb_xkb_list_components_reply_t * R)8028 xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R)
8029 {
8030     xcb_xkb_listing_iterator_t i;
8031     i.data = (xcb_xkb_listing_t *) (R + 1);
8032     i.rem = R->nKeymaps;
8033     i.index = (char *) i.data - (char *) R;
8034     return i;
8035 }
8036 
8037 int
xcb_xkb_list_components_keycodes_length(const xcb_xkb_list_components_reply_t * R)8038 xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R)
8039 {
8040     return R->nKeycodes;
8041 }
8042 
8043 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_keycodes_iterator(const xcb_xkb_list_components_reply_t * R)8044 xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R)
8045 {
8046     xcb_xkb_listing_iterator_t i;
8047     xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keymaps_iterator(R));
8048     i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
8049     i.rem = R->nKeycodes;
8050     i.index = (char *) i.data - (char *) R;
8051     return i;
8052 }
8053 
8054 int
xcb_xkb_list_components_types_length(const xcb_xkb_list_components_reply_t * R)8055 xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R)
8056 {
8057     return R->nTypes;
8058 }
8059 
8060 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_types_iterator(const xcb_xkb_list_components_reply_t * R)8061 xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R)
8062 {
8063     xcb_xkb_listing_iterator_t i;
8064     xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keycodes_iterator(R));
8065     i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
8066     i.rem = R->nTypes;
8067     i.index = (char *) i.data - (char *) R;
8068     return i;
8069 }
8070 
8071 int
xcb_xkb_list_components_compat_maps_length(const xcb_xkb_list_components_reply_t * R)8072 xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R)
8073 {
8074     return R->nCompatMaps;
8075 }
8076 
8077 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_compat_maps_iterator(const xcb_xkb_list_components_reply_t * R)8078 xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R)
8079 {
8080     xcb_xkb_listing_iterator_t i;
8081     xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_types_iterator(R));
8082     i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
8083     i.rem = R->nCompatMaps;
8084     i.index = (char *) i.data - (char *) R;
8085     return i;
8086 }
8087 
8088 int
xcb_xkb_list_components_symbols_length(const xcb_xkb_list_components_reply_t * R)8089 xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R)
8090 {
8091     return R->nSymbols;
8092 }
8093 
8094 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_symbols_iterator(const xcb_xkb_list_components_reply_t * R)8095 xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R)
8096 {
8097     xcb_xkb_listing_iterator_t i;
8098     xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_compat_maps_iterator(R));
8099     i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
8100     i.rem = R->nSymbols;
8101     i.index = (char *) i.data - (char *) R;
8102     return i;
8103 }
8104 
8105 int
xcb_xkb_list_components_geometries_length(const xcb_xkb_list_components_reply_t * R)8106 xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R)
8107 {
8108     return R->nGeometries;
8109 }
8110 
8111 xcb_xkb_listing_iterator_t
xcb_xkb_list_components_geometries_iterator(const xcb_xkb_list_components_reply_t * R)8112 xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R)
8113 {
8114     xcb_xkb_listing_iterator_t i;
8115     xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_symbols_iterator(R));
8116     i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
8117     i.rem = R->nGeometries;
8118     i.index = (char *) i.data - (char *) R;
8119     return i;
8120 }
8121 
8122 xcb_xkb_list_components_reply_t *
xcb_xkb_list_components_reply(xcb_connection_t * c,xcb_xkb_list_components_cookie_t cookie,xcb_generic_error_t ** e)8123 xcb_xkb_list_components_reply (xcb_connection_t                  *c,
8124                                xcb_xkb_list_components_cookie_t   cookie  /**< */,
8125                                xcb_generic_error_t              **e)
8126 {
8127     return (xcb_xkb_list_components_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
8128 }
8129 
8130 int
xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8131 xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8132                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
8133 {
8134     return S->types.nTypes;
8135 }
8136 
8137 xcb_xkb_key_type_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8138 xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8139                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
8140 {
8141     xcb_xkb_key_type_iterator_t i;
8142     i.data = S->types.map.types_rtrn;
8143     i.rem = S->types.nTypes;
8144     i.index = (char *) i.data - (char *) S;
8145     return i;
8146 }
8147 
8148 int
xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8149 xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8150                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
8151 {
8152     return S->types.nKeySyms;
8153 }
8154 
8155 xcb_xkb_key_sym_map_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8156 xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8157                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
8158 {
8159     xcb_xkb_key_sym_map_iterator_t i;
8160     i.data = S->types.map.syms_rtrn;
8161     i.rem = S->types.nKeySyms;
8162     i.index = (char *) i.data - (char *) S;
8163     return i;
8164 }
8165 
8166 uint8_t *
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count(const xcb_xkb_get_kbd_by_name_replies_t * S)8167 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S)
8168 {
8169     return S->types.map.acts_rtrn_count;
8170 }
8171 
8172 int
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8173 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8174                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S)
8175 {
8176     return S->types.nKeyActions;
8177 }
8178 
8179 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8180 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8181                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
8182 {
8183     xcb_generic_iterator_t i;
8184     i.data = S->types.map.acts_rtrn_count + S->types.nKeyActions;
8185     i.rem = 0;
8186     i.index = (char *) i.data - (char *) S;
8187     return i;
8188 }
8189 
8190 xcb_xkb_action_t *
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts(const xcb_xkb_get_kbd_by_name_replies_t * S)8191 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S)
8192 {
8193     return S->types.map.acts_rtrn_acts;
8194 }
8195 
8196 int
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8197 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8198                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
8199 {
8200     return S->types.totalActions;
8201 }
8202 
8203 xcb_xkb_action_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8204 xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8205                                                                    const xcb_xkb_get_kbd_by_name_replies_t *S)
8206 {
8207     xcb_xkb_action_iterator_t i;
8208     i.data = S->types.map.acts_rtrn_acts;
8209     i.rem = S->types.totalActions;
8210     i.index = (char *) i.data - (char *) S;
8211     return i;
8212 }
8213 
8214 xcb_xkb_set_behavior_t *
xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)8215 xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
8216 {
8217     return S->types.map.behaviors_rtrn;
8218 }
8219 
8220 int
xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8221 xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8222                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
8223 {
8224     return S->types.totalKeyBehaviors;
8225 }
8226 
8227 xcb_xkb_set_behavior_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8228 xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8229                                                                    const xcb_xkb_get_kbd_by_name_replies_t *S)
8230 {
8231     xcb_xkb_set_behavior_iterator_t i;
8232     i.data = S->types.map.behaviors_rtrn;
8233     i.rem = S->types.totalKeyBehaviors;
8234     i.index = (char *) i.data - (char *) S;
8235     return i;
8236 }
8237 
8238 uint8_t *
xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)8239 xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
8240 {
8241     return S->types.map.vmods_rtrn;
8242 }
8243 
8244 int
xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8245 xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8246                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
8247 {
8248     return xcb_popcount(S->types.virtualMods);
8249 }
8250 
8251 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8252 xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8253                                                           const xcb_xkb_get_kbd_by_name_replies_t *S)
8254 {
8255     xcb_generic_iterator_t i;
8256     i.data = S->types.map.vmods_rtrn + xcb_popcount(S->types.virtualMods);
8257     i.rem = 0;
8258     i.index = (char *) i.data - (char *) S;
8259     return i;
8260 }
8261 
8262 xcb_xkb_set_explicit_t *
xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)8263 xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
8264 {
8265     return S->types.map.explicit_rtrn;
8266 }
8267 
8268 int
xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8269 xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8270                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
8271 {
8272     return S->types.totalKeyExplicit;
8273 }
8274 
8275 xcb_xkb_set_explicit_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8276 xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8277                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S)
8278 {
8279     xcb_xkb_set_explicit_iterator_t i;
8280     i.data = S->types.map.explicit_rtrn;
8281     i.rem = S->types.totalKeyExplicit;
8282     i.index = (char *) i.data - (char *) S;
8283     return i;
8284 }
8285 
8286 xcb_xkb_key_mod_map_t *
xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)8287 xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
8288 {
8289     return S->types.map.modmap_rtrn;
8290 }
8291 
8292 int
xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8293 xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8294                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
8295 {
8296     return S->types.totalModMapKeys;
8297 }
8298 
8299 xcb_xkb_key_mod_map_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8300 xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8301                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
8302 {
8303     xcb_xkb_key_mod_map_iterator_t i;
8304     i.data = S->types.map.modmap_rtrn;
8305     i.rem = S->types.totalModMapKeys;
8306     i.index = (char *) i.data - (char *) S;
8307     return i;
8308 }
8309 
8310 xcb_xkb_key_v_mod_map_t *
xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)8311 xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
8312 {
8313     return S->types.map.vmodmap_rtrn;
8314 }
8315 
8316 int
xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8317 xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8318                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
8319 {
8320     return S->types.totalVModMapKeys;
8321 }
8322 
8323 xcb_xkb_key_v_mod_map_iterator_t
xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8324 xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
8325                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
8326 {
8327     xcb_xkb_key_v_mod_map_iterator_t i;
8328     i.data = S->types.map.vmodmap_rtrn;
8329     i.rem = S->types.totalVModMapKeys;
8330     i.index = (char *) i.data - (char *) S;
8331     return i;
8332 }
8333 
8334 int
xcb_xkb_get_kbd_by_name_replies_types_map_serialize(void ** _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,const xcb_xkb_get_kbd_by_name_replies_types_map_t * _aux)8335 xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void                                              **_buffer,
8336                                                      uint8_t                                             nTypes,
8337                                                      uint8_t                                             nKeySyms,
8338                                                      uint8_t                                             nKeyActions,
8339                                                      uint16_t                                            totalActions,
8340                                                      uint8_t                                             totalKeyBehaviors,
8341                                                      uint16_t                                            virtualMods,
8342                                                      uint8_t                                             totalKeyExplicit,
8343                                                      uint8_t                                             totalModMapKeys,
8344                                                      uint8_t                                             totalVModMapKeys,
8345                                                      uint16_t                                            present,
8346                                                      const xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux)
8347 {
8348     char *xcb_out = *_buffer;
8349     unsigned int xcb_buffer_len = 0;
8350     unsigned int xcb_align_to = 0;
8351     unsigned int xcb_padding_offset = 0;
8352 
8353     unsigned int xcb_pad = 0;
8354     char xcb_pad0[3] = {0, 0, 0};
8355     struct iovec xcb_parts[23];
8356     unsigned int xcb_parts_idx = 0;
8357     unsigned int xcb_block_len = 0;
8358     unsigned int i;
8359     char *xcb_tmp;
8360 
8361     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
8362         /* insert padding */
8363         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8364         xcb_buffer_len += xcb_block_len + xcb_pad;
8365         if (0 != xcb_pad) {
8366             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8367             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8368             xcb_parts_idx++;
8369             xcb_pad = 0;
8370         }
8371         xcb_block_len = 0;
8372         xcb_padding_offset = 0;
8373         /* types_rtrn */
8374         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn;
8375         xcb_parts[xcb_parts_idx].iov_len = 0;
8376         xcb_tmp = (char *) _aux->types_rtrn;
8377         for(i=0; i<nTypes; i++) {
8378             xcb_block_len = xcb_xkb_key_type_sizeof(xcb_tmp);
8379             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
8380         }
8381         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
8382         xcb_parts_idx++;
8383         xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
8384     }
8385     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
8386         /* insert padding */
8387         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8388         xcb_buffer_len += xcb_block_len + xcb_pad;
8389         if (0 != xcb_pad) {
8390             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8391             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8392             xcb_parts_idx++;
8393             xcb_pad = 0;
8394         }
8395         xcb_block_len = 0;
8396         xcb_padding_offset = 0;
8397         /* syms_rtrn */
8398         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn;
8399         xcb_parts[xcb_parts_idx].iov_len = 0;
8400         xcb_tmp = (char *) _aux->syms_rtrn;
8401         for(i=0; i<nKeySyms; i++) {
8402             xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
8403             xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
8404         }
8405         xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
8406         xcb_parts_idx++;
8407         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
8408     }
8409     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
8410         /* insert padding */
8411         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8412         xcb_buffer_len += xcb_block_len + xcb_pad;
8413         if (0 != xcb_pad) {
8414             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8415             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8416             xcb_parts_idx++;
8417             xcb_pad = 0;
8418         }
8419         xcb_block_len = 0;
8420         xcb_padding_offset = 0;
8421         /* acts_rtrn_count */
8422         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count;
8423         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
8424         xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
8425         xcb_parts_idx++;
8426         xcb_align_to = ALIGNOF(uint8_t);
8427         xcb_align_to = 4;
8428         /* insert padding */
8429         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8430         xcb_buffer_len += xcb_block_len + xcb_pad;
8431         if (0 != xcb_pad) {
8432             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8433             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8434             xcb_parts_idx++;
8435             xcb_pad = 0;
8436         }
8437         xcb_block_len = 0;
8438         xcb_padding_offset = 0;
8439         /* insert padding */
8440         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8441         xcb_buffer_len += xcb_block_len + xcb_pad;
8442         if (0 != xcb_pad) {
8443             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8444             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8445             xcb_parts_idx++;
8446             xcb_pad = 0;
8447         }
8448         xcb_block_len = 0;
8449         xcb_padding_offset = 0;
8450         /* acts_rtrn_acts */
8451         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts;
8452         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
8453         xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
8454         xcb_parts_idx++;
8455         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
8456     }
8457     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
8458         /* insert padding */
8459         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8460         xcb_buffer_len += xcb_block_len + xcb_pad;
8461         if (0 != xcb_pad) {
8462             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8463             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8464             xcb_parts_idx++;
8465             xcb_pad = 0;
8466         }
8467         xcb_block_len = 0;
8468         xcb_padding_offset = 0;
8469         /* behaviors_rtrn */
8470         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn;
8471         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
8472         xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
8473         xcb_parts_idx++;
8474         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
8475     }
8476     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
8477         /* insert padding */
8478         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8479         xcb_buffer_len += xcb_block_len + xcb_pad;
8480         if (0 != xcb_pad) {
8481             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8482             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8483             xcb_parts_idx++;
8484             xcb_pad = 0;
8485         }
8486         xcb_block_len = 0;
8487         xcb_padding_offset = 0;
8488         /* vmods_rtrn */
8489         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn;
8490         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
8491         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
8492         xcb_parts_idx++;
8493         xcb_align_to = ALIGNOF(uint8_t);
8494         xcb_align_to = 4;
8495         /* insert padding */
8496         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8497         xcb_buffer_len += xcb_block_len + xcb_pad;
8498         if (0 != xcb_pad) {
8499             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8500             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8501             xcb_parts_idx++;
8502             xcb_pad = 0;
8503         }
8504         xcb_block_len = 0;
8505         xcb_padding_offset = 0;
8506     }
8507     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
8508         /* insert padding */
8509         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8510         xcb_buffer_len += xcb_block_len + xcb_pad;
8511         if (0 != xcb_pad) {
8512             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8513             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8514             xcb_parts_idx++;
8515             xcb_pad = 0;
8516         }
8517         xcb_block_len = 0;
8518         xcb_padding_offset = 0;
8519         /* explicit_rtrn */
8520         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn;
8521         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
8522         xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
8523         xcb_parts_idx++;
8524         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
8525         xcb_align_to = 4;
8526         /* insert padding */
8527         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8528         xcb_buffer_len += xcb_block_len + xcb_pad;
8529         if (0 != xcb_pad) {
8530             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8531             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8532             xcb_parts_idx++;
8533             xcb_pad = 0;
8534         }
8535         xcb_block_len = 0;
8536         xcb_padding_offset = 0;
8537     }
8538     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
8539         /* insert padding */
8540         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8541         xcb_buffer_len += xcb_block_len + xcb_pad;
8542         if (0 != xcb_pad) {
8543             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8544             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8545             xcb_parts_idx++;
8546             xcb_pad = 0;
8547         }
8548         xcb_block_len = 0;
8549         xcb_padding_offset = 0;
8550         /* modmap_rtrn */
8551         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn;
8552         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
8553         xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
8554         xcb_parts_idx++;
8555         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
8556         xcb_align_to = 4;
8557         /* insert padding */
8558         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8559         xcb_buffer_len += xcb_block_len + xcb_pad;
8560         if (0 != xcb_pad) {
8561             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8562             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8563             xcb_parts_idx++;
8564             xcb_pad = 0;
8565         }
8566         xcb_block_len = 0;
8567         xcb_padding_offset = 0;
8568     }
8569     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
8570         /* insert padding */
8571         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8572         xcb_buffer_len += xcb_block_len + xcb_pad;
8573         if (0 != xcb_pad) {
8574             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8575             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8576             xcb_parts_idx++;
8577             xcb_pad = 0;
8578         }
8579         xcb_block_len = 0;
8580         xcb_padding_offset = 0;
8581         /* vmodmap_rtrn */
8582         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn;
8583         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
8584         xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
8585         xcb_parts_idx++;
8586         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
8587     }
8588     /* insert padding */
8589     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8590     xcb_buffer_len += xcb_block_len + xcb_pad;
8591     if (0 != xcb_pad) {
8592         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
8593         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
8594         xcb_parts_idx++;
8595         xcb_pad = 0;
8596     }
8597     xcb_block_len = 0;
8598     xcb_padding_offset = 0;
8599 
8600     if (NULL == xcb_out) {
8601         /* allocate memory */
8602         xcb_out = malloc(xcb_buffer_len);
8603         *_buffer = xcb_out;
8604     }
8605 
8606     xcb_tmp = xcb_out;
8607     for(i=0; i<xcb_parts_idx; i++) {
8608         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
8609             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
8610         if (0 != xcb_parts[i].iov_len)
8611             xcb_tmp += xcb_parts[i].iov_len;
8612     }
8613 
8614     return xcb_buffer_len;
8615 }
8616 
8617 int
xcb_xkb_get_kbd_by_name_replies_types_map_unpack(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present,xcb_xkb_get_kbd_by_name_replies_types_map_t * _aux)8618 xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void                                   *_buffer,
8619                                                   uint8_t                                       nTypes,
8620                                                   uint8_t                                       nKeySyms,
8621                                                   uint8_t                                       nKeyActions,
8622                                                   uint16_t                                      totalActions,
8623                                                   uint8_t                                       totalKeyBehaviors,
8624                                                   uint16_t                                      virtualMods,
8625                                                   uint8_t                                       totalKeyExplicit,
8626                                                   uint8_t                                       totalModMapKeys,
8627                                                   uint8_t                                       totalVModMapKeys,
8628                                                   uint16_t                                      present,
8629                                                   xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux)
8630 {
8631     char *xcb_tmp = (char *)_buffer;
8632     unsigned int xcb_buffer_len = 0;
8633     unsigned int xcb_block_len = 0;
8634     unsigned int xcb_pad = 0;
8635     unsigned int xcb_align_to = 0;
8636     unsigned int xcb_padding_offset = 0;
8637 
8638     unsigned int i;
8639     unsigned int xcb_tmp_len;
8640 
8641     if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
8642         /* insert padding */
8643         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8644         xcb_buffer_len += xcb_block_len + xcb_pad;
8645         if (0 != xcb_pad) {
8646             xcb_tmp += xcb_pad;
8647             xcb_pad = 0;
8648         }
8649         xcb_block_len = 0;
8650         xcb_padding_offset = 0;
8651         /* types_rtrn */
8652         _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp;
8653         for(i=0; i<nTypes; i++) {
8654             xcb_tmp_len = xcb_xkb_key_type_sizeof(xcb_tmp);
8655             xcb_block_len += xcb_tmp_len;
8656             xcb_tmp += xcb_tmp_len;
8657         }
8658         xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
8659     }
8660     if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
8661         /* insert padding */
8662         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8663         xcb_buffer_len += xcb_block_len + xcb_pad;
8664         if (0 != xcb_pad) {
8665             xcb_tmp += xcb_pad;
8666             xcb_pad = 0;
8667         }
8668         xcb_block_len = 0;
8669         xcb_padding_offset = 0;
8670         /* syms_rtrn */
8671         _aux->syms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp;
8672         for(i=0; i<nKeySyms; i++) {
8673             xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
8674             xcb_block_len += xcb_tmp_len;
8675             xcb_tmp += xcb_tmp_len;
8676         }
8677         xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
8678     }
8679     if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
8680         /* insert padding */
8681         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8682         xcb_buffer_len += xcb_block_len + xcb_pad;
8683         if (0 != xcb_pad) {
8684             xcb_tmp += xcb_pad;
8685             xcb_pad = 0;
8686         }
8687         xcb_block_len = 0;
8688         xcb_padding_offset = 0;
8689         /* acts_rtrn_count */
8690         _aux->acts_rtrn_count = (uint8_t *)xcb_tmp;
8691         xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
8692         xcb_tmp += xcb_block_len;
8693         xcb_align_to = ALIGNOF(uint8_t);
8694         xcb_align_to = 4;
8695         /* insert padding */
8696         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8697         xcb_buffer_len += xcb_block_len + xcb_pad;
8698         if (0 != xcb_pad) {
8699             xcb_tmp += xcb_pad;
8700             xcb_pad = 0;
8701         }
8702         xcb_block_len = 0;
8703         xcb_padding_offset = 0;
8704         /* insert padding */
8705         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8706         xcb_buffer_len += xcb_block_len + xcb_pad;
8707         if (0 != xcb_pad) {
8708             xcb_tmp += xcb_pad;
8709             xcb_pad = 0;
8710         }
8711         xcb_block_len = 0;
8712         xcb_padding_offset = 0;
8713         /* acts_rtrn_acts */
8714         _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp;
8715         xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
8716         xcb_tmp += xcb_block_len;
8717         xcb_align_to = ALIGNOF(xcb_xkb_action_t);
8718     }
8719     if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
8720         /* insert padding */
8721         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8722         xcb_buffer_len += xcb_block_len + xcb_pad;
8723         if (0 != xcb_pad) {
8724             xcb_tmp += xcb_pad;
8725             xcb_pad = 0;
8726         }
8727         xcb_block_len = 0;
8728         xcb_padding_offset = 0;
8729         /* behaviors_rtrn */
8730         _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp;
8731         xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
8732         xcb_tmp += xcb_block_len;
8733         xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
8734     }
8735     if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
8736         /* insert padding */
8737         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8738         xcb_buffer_len += xcb_block_len + xcb_pad;
8739         if (0 != xcb_pad) {
8740             xcb_tmp += xcb_pad;
8741             xcb_pad = 0;
8742         }
8743         xcb_block_len = 0;
8744         xcb_padding_offset = 0;
8745         /* vmods_rtrn */
8746         _aux->vmods_rtrn = (uint8_t *)xcb_tmp;
8747         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
8748         xcb_tmp += xcb_block_len;
8749         xcb_align_to = ALIGNOF(uint8_t);
8750         xcb_align_to = 4;
8751         /* insert padding */
8752         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8753         xcb_buffer_len += xcb_block_len + xcb_pad;
8754         if (0 != xcb_pad) {
8755             xcb_tmp += xcb_pad;
8756             xcb_pad = 0;
8757         }
8758         xcb_block_len = 0;
8759         xcb_padding_offset = 0;
8760     }
8761     if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
8762         /* insert padding */
8763         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8764         xcb_buffer_len += xcb_block_len + xcb_pad;
8765         if (0 != xcb_pad) {
8766             xcb_tmp += xcb_pad;
8767             xcb_pad = 0;
8768         }
8769         xcb_block_len = 0;
8770         xcb_padding_offset = 0;
8771         /* explicit_rtrn */
8772         _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp;
8773         xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
8774         xcb_tmp += xcb_block_len;
8775         xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
8776         xcb_align_to = 4;
8777         /* insert padding */
8778         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8779         xcb_buffer_len += xcb_block_len + xcb_pad;
8780         if (0 != xcb_pad) {
8781             xcb_tmp += xcb_pad;
8782             xcb_pad = 0;
8783         }
8784         xcb_block_len = 0;
8785         xcb_padding_offset = 0;
8786     }
8787     if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
8788         /* insert padding */
8789         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8790         xcb_buffer_len += xcb_block_len + xcb_pad;
8791         if (0 != xcb_pad) {
8792             xcb_tmp += xcb_pad;
8793             xcb_pad = 0;
8794         }
8795         xcb_block_len = 0;
8796         xcb_padding_offset = 0;
8797         /* modmap_rtrn */
8798         _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp;
8799         xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
8800         xcb_tmp += xcb_block_len;
8801         xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
8802         xcb_align_to = 4;
8803         /* insert padding */
8804         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8805         xcb_buffer_len += xcb_block_len + xcb_pad;
8806         if (0 != xcb_pad) {
8807             xcb_tmp += xcb_pad;
8808             xcb_pad = 0;
8809         }
8810         xcb_block_len = 0;
8811         xcb_padding_offset = 0;
8812     }
8813     if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
8814         /* insert padding */
8815         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8816         xcb_buffer_len += xcb_block_len + xcb_pad;
8817         if (0 != xcb_pad) {
8818             xcb_tmp += xcb_pad;
8819             xcb_pad = 0;
8820         }
8821         xcb_block_len = 0;
8822         xcb_padding_offset = 0;
8823         /* vmodmap_rtrn */
8824         _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
8825         xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
8826         xcb_tmp += xcb_block_len;
8827         xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
8828     }
8829     /* insert padding */
8830     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
8831     xcb_buffer_len += xcb_block_len + xcb_pad;
8832     if (0 != xcb_pad) {
8833         xcb_tmp += xcb_pad;
8834         xcb_pad = 0;
8835     }
8836     xcb_block_len = 0;
8837     xcb_padding_offset = 0;
8838 
8839     return xcb_buffer_len;
8840 }
8841 
8842 int
xcb_xkb_get_kbd_by_name_replies_types_map_sizeof(const void * _buffer,uint8_t nTypes,uint8_t nKeySyms,uint8_t nKeyActions,uint16_t totalActions,uint8_t totalKeyBehaviors,uint16_t virtualMods,uint8_t totalKeyExplicit,uint8_t totalModMapKeys,uint8_t totalVModMapKeys,uint16_t present)8843 xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void  *_buffer,
8844                                                   uint8_t      nTypes,
8845                                                   uint8_t      nKeySyms,
8846                                                   uint8_t      nKeyActions,
8847                                                   uint16_t     totalActions,
8848                                                   uint8_t      totalKeyBehaviors,
8849                                                   uint16_t     virtualMods,
8850                                                   uint8_t      totalKeyExplicit,
8851                                                   uint8_t      totalModMapKeys,
8852                                                   uint8_t      totalVModMapKeys,
8853                                                   uint16_t     present)
8854 {
8855     xcb_xkb_get_kbd_by_name_replies_types_map_t _aux;
8856     return xcb_xkb_get_kbd_by_name_replies_types_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
8857 }
8858 
8859 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names(const xcb_xkb_get_kbd_by_name_replies_t * S)8860 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
8861 {
8862     return S->key_names.valueList.typeNames;
8863 }
8864 
8865 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8866 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8867                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S)
8868 {
8869     return S->key_names.nTypes;
8870 }
8871 
8872 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8873 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8874                                                                      const xcb_xkb_get_kbd_by_name_replies_t *S)
8875 {
8876     xcb_generic_iterator_t i;
8877     i.data = S->key_names.valueList.typeNames + S->key_names.nTypes;
8878     i.rem = 0;
8879     i.index = (char *) i.data - (char *) S;
8880     return i;
8881 }
8882 
8883 uint8_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type(const xcb_xkb_get_kbd_by_name_replies_t * S)8884 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S)
8885 {
8886     return S->key_names.valueList.nLevelsPerType;
8887 }
8888 
8889 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8890 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8891                                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
8892 {
8893     return S->key_names.nTypes;
8894 }
8895 
8896 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8897 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8898                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
8899 {
8900     xcb_generic_iterator_t i;
8901     i.data = S->key_names.valueList.nLevelsPerType + S->key_names.nTypes;
8902     i.rem = 0;
8903     i.index = (char *) i.data - (char *) S;
8904     return i;
8905 }
8906 
8907 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names(const xcb_xkb_get_kbd_by_name_replies_t * S)8908 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
8909 {
8910     return S->key_names.valueList.ktLevelNames;
8911 }
8912 
8913 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8914 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8915                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
8916 {
8917     int xcb_pre_tmp_1; /* sumof length */
8918     int xcb_pre_tmp_2; /* sumof loop counter */
8919     int64_t xcb_pre_tmp_3; /* sumof sum */
8920     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
8921     /* sumof start */
8922     xcb_pre_tmp_1 = S->key_names.nTypes;
8923     xcb_pre_tmp_3 = 0;
8924     xcb_pre_tmp_4 = S->key_names.valueList.nLevelsPerType;
8925     for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
8926         xcb_pre_tmp_3 += *xcb_pre_tmp_4;
8927         xcb_pre_tmp_4++;
8928     }
8929     /* sumof end. Result is in xcb_pre_tmp_3 */
8930     return xcb_pre_tmp_3;
8931 }
8932 
8933 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8934 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8935                                                                          const xcb_xkb_get_kbd_by_name_replies_t *S)
8936 {
8937     xcb_generic_iterator_t i;
8938     int xcb_pre_tmp_5; /* sumof length */
8939     int xcb_pre_tmp_6; /* sumof loop counter */
8940     int64_t xcb_pre_tmp_7; /* sumof sum */
8941     const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
8942     /* sumof start */
8943     xcb_pre_tmp_5 = S->key_names.nTypes;
8944     xcb_pre_tmp_7 = 0;
8945     xcb_pre_tmp_8 = S->key_names.valueList.nLevelsPerType;
8946     for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
8947         xcb_pre_tmp_7 += *xcb_pre_tmp_8;
8948         xcb_pre_tmp_8++;
8949     }
8950     /* sumof end. Result is in xcb_pre_tmp_7 */
8951     i.data = S->key_names.valueList.ktLevelNames + xcb_pre_tmp_7;
8952     i.rem = 0;
8953     i.index = (char *) i.data - (char *) S;
8954     return i;
8955 }
8956 
8957 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names(const xcb_xkb_get_kbd_by_name_replies_t * S)8958 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
8959 {
8960     return S->key_names.valueList.indicatorNames;
8961 }
8962 
8963 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8964 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8965                                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
8966 {
8967     return xcb_popcount(S->key_names.indicators);
8968 }
8969 
8970 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8971 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8972                                                                           const xcb_xkb_get_kbd_by_name_replies_t *S)
8973 {
8974     xcb_generic_iterator_t i;
8975     i.data = S->key_names.valueList.indicatorNames + xcb_popcount(S->key_names.indicators);
8976     i.rem = 0;
8977     i.index = (char *) i.data - (char *) S;
8978     return i;
8979 }
8980 
8981 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names(const xcb_xkb_get_kbd_by_name_replies_t * S)8982 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
8983 {
8984     return S->key_names.valueList.virtualModNames;
8985 }
8986 
8987 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8988 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
8989                                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
8990 {
8991     return xcb_popcount(S->key_names.virtualMods);
8992 }
8993 
8994 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)8995 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
8996                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
8997 {
8998     xcb_generic_iterator_t i;
8999     i.data = S->key_names.valueList.virtualModNames + xcb_popcount(S->key_names.virtualMods);
9000     i.rem = 0;
9001     i.index = (char *) i.data - (char *) S;
9002     return i;
9003 }
9004 
9005 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups(const xcb_xkb_get_kbd_by_name_replies_t * S)9006 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S)
9007 {
9008     return S->key_names.valueList.groups;
9009 }
9010 
9011 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9012 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9013                                                                     const xcb_xkb_get_kbd_by_name_replies_t *S)
9014 {
9015     return xcb_popcount(S->key_names.groupNames);
9016 }
9017 
9018 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9019 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
9020                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
9021 {
9022     xcb_generic_iterator_t i;
9023     i.data = S->key_names.valueList.groups + xcb_popcount(S->key_names.groupNames);
9024     i.rem = 0;
9025     i.index = (char *) i.data - (char *) S;
9026     return i;
9027 }
9028 
9029 xcb_xkb_key_name_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names(const xcb_xkb_get_kbd_by_name_replies_t * S)9030 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
9031 {
9032     return S->key_names.valueList.keyNames;
9033 }
9034 
9035 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9036 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9037                                                                        const xcb_xkb_get_kbd_by_name_replies_t *S)
9038 {
9039     return S->key_names.nKeys;
9040 }
9041 
9042 xcb_xkb_key_name_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9043 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
9044                                                                          const xcb_xkb_get_kbd_by_name_replies_t *S)
9045 {
9046     xcb_xkb_key_name_iterator_t i;
9047     i.data = S->key_names.valueList.keyNames;
9048     i.rem = S->key_names.nKeys;
9049     i.index = (char *) i.data - (char *) S;
9050     return i;
9051 }
9052 
9053 xcb_xkb_key_alias_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases(const xcb_xkb_get_kbd_by_name_replies_t * S)9054 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S)
9055 {
9056     return S->key_names.valueList.keyAliases;
9057 }
9058 
9059 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9060 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9061                                                                          const xcb_xkb_get_kbd_by_name_replies_t *S)
9062 {
9063     return S->key_names.nKeyAliases;
9064 }
9065 
9066 xcb_xkb_key_alias_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9067 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
9068                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
9069 {
9070     xcb_xkb_key_alias_iterator_t i;
9071     i.data = S->key_names.valueList.keyAliases;
9072     i.rem = S->key_names.nKeyAliases;
9073     i.index = (char *) i.data - (char *) S;
9074     return i;
9075 }
9076 
9077 xcb_atom_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names(const xcb_xkb_get_kbd_by_name_replies_t * S)9078 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
9079 {
9080     return S->key_names.valueList.radioGroupNames;
9081 }
9082 
9083 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9084 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9085                                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
9086 {
9087     return S->key_names.nRadioGroups;
9088 }
9089 
9090 xcb_generic_iterator_t
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9091 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
9092                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
9093 {
9094     xcb_generic_iterator_t i;
9095     i.data = S->key_names.valueList.radioGroupNames + S->key_names.nRadioGroups;
9096     i.rem = 0;
9097     i.index = (char *) i.data - (char *) S;
9098     return i;
9099 }
9100 
9101 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(void ** _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t * _aux)9102 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void                                                         **_buffer,
9103                                                                 uint8_t                                                        nTypes,
9104                                                                 uint32_t                                                       indicators,
9105                                                                 uint16_t                                                       virtualMods,
9106                                                                 uint8_t                                                        groupNames,
9107                                                                 uint8_t                                                        nKeys,
9108                                                                 uint8_t                                                        nKeyAliases,
9109                                                                 uint8_t                                                        nRadioGroups,
9110                                                                 uint32_t                                                       which,
9111                                                                 const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux)
9112 {
9113     char *xcb_out = *_buffer;
9114     unsigned int xcb_buffer_len = 0;
9115     unsigned int xcb_align_to = 0;
9116     unsigned int xcb_padding_offset = 0;
9117 
9118     int xcb_pre_tmp_1; /* sumof length */
9119     int xcb_pre_tmp_2; /* sumof loop counter */
9120     int64_t xcb_pre_tmp_3; /* sumof sum */
9121     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
9122     unsigned int xcb_pad = 0;
9123     char xcb_pad0[3] = {0, 0, 0};
9124     struct iovec xcb_parts[26];
9125     unsigned int xcb_parts_idx = 0;
9126     unsigned int xcb_block_len = 0;
9127     unsigned int i;
9128     char *xcb_tmp;
9129 
9130     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
9131         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.keycodesName */
9132         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
9133         xcb_block_len += sizeof(xcb_atom_t);
9134         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9135         xcb_parts_idx++;
9136         xcb_align_to = ALIGNOF(xcb_atom_t);
9137     }
9138     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
9139         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.geometryName */
9140         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
9141         xcb_block_len += sizeof(xcb_atom_t);
9142         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9143         xcb_parts_idx++;
9144         xcb_align_to = ALIGNOF(xcb_atom_t);
9145     }
9146     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
9147         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.symbolsName */
9148         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
9149         xcb_block_len += sizeof(xcb_atom_t);
9150         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9151         xcb_parts_idx++;
9152         xcb_align_to = ALIGNOF(xcb_atom_t);
9153     }
9154     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
9155         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.physSymbolsName */
9156         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
9157         xcb_block_len += sizeof(xcb_atom_t);
9158         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9159         xcb_parts_idx++;
9160         xcb_align_to = ALIGNOF(xcb_atom_t);
9161     }
9162     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
9163         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.typesName */
9164         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
9165         xcb_block_len += sizeof(xcb_atom_t);
9166         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9167         xcb_parts_idx++;
9168         xcb_align_to = ALIGNOF(xcb_atom_t);
9169     }
9170     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
9171         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.compatName */
9172         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
9173         xcb_block_len += sizeof(xcb_atom_t);
9174         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
9175         xcb_parts_idx++;
9176         xcb_align_to = ALIGNOF(xcb_atom_t);
9177     }
9178     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
9179         /* insert padding */
9180         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9181         xcb_buffer_len += xcb_block_len + xcb_pad;
9182         if (0 != xcb_pad) {
9183             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9184             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9185             xcb_parts_idx++;
9186             xcb_pad = 0;
9187         }
9188         xcb_block_len = 0;
9189         xcb_padding_offset = 0;
9190         /* typeNames */
9191         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
9192         xcb_block_len += nTypes * sizeof(xcb_atom_t);
9193         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
9194         xcb_parts_idx++;
9195         xcb_align_to = ALIGNOF(xcb_atom_t);
9196     }
9197     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
9198         /* insert padding */
9199         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9200         xcb_buffer_len += xcb_block_len + xcb_pad;
9201         if (0 != xcb_pad) {
9202             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9203             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9204             xcb_parts_idx++;
9205             xcb_pad = 0;
9206         }
9207         xcb_block_len = 0;
9208         xcb_padding_offset = 0;
9209         /* nLevelsPerType */
9210         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
9211         xcb_block_len += nTypes * sizeof(uint8_t);
9212         xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
9213         xcb_parts_idx++;
9214         xcb_align_to = ALIGNOF(uint8_t);
9215         xcb_align_to = 4;
9216         /* insert padding */
9217         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9218         xcb_buffer_len += xcb_block_len + xcb_pad;
9219         if (0 != xcb_pad) {
9220             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9221             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9222             xcb_parts_idx++;
9223             xcb_pad = 0;
9224         }
9225         xcb_block_len = 0;
9226         xcb_padding_offset = 0;
9227         /* insert padding */
9228         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9229         xcb_buffer_len += xcb_block_len + xcb_pad;
9230         if (0 != xcb_pad) {
9231             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9232             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9233             xcb_parts_idx++;
9234             xcb_pad = 0;
9235         }
9236         xcb_block_len = 0;
9237         xcb_padding_offset = 0;
9238         /* ktLevelNames */
9239         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
9240         /* sumof start */
9241         xcb_pre_tmp_1 = nTypes;
9242         xcb_pre_tmp_3 = 0;
9243         xcb_pre_tmp_4 = _aux->nLevelsPerType;
9244         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
9245             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
9246             xcb_pre_tmp_4++;
9247         }
9248         /* sumof end. Result is in xcb_pre_tmp_3 */
9249         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
9250         xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
9251         xcb_parts_idx++;
9252         xcb_align_to = ALIGNOF(xcb_atom_t);
9253     }
9254     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
9255         /* insert padding */
9256         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9257         xcb_buffer_len += xcb_block_len + xcb_pad;
9258         if (0 != xcb_pad) {
9259             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9260             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9261             xcb_parts_idx++;
9262             xcb_pad = 0;
9263         }
9264         xcb_block_len = 0;
9265         xcb_padding_offset = 0;
9266         /* indicatorNames */
9267         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
9268         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
9269         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
9270         xcb_parts_idx++;
9271         xcb_align_to = ALIGNOF(xcb_atom_t);
9272     }
9273     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
9274         /* insert padding */
9275         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9276         xcb_buffer_len += xcb_block_len + xcb_pad;
9277         if (0 != xcb_pad) {
9278             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9279             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9280             xcb_parts_idx++;
9281             xcb_pad = 0;
9282         }
9283         xcb_block_len = 0;
9284         xcb_padding_offset = 0;
9285         /* virtualModNames */
9286         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
9287         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
9288         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
9289         xcb_parts_idx++;
9290         xcb_align_to = ALIGNOF(xcb_atom_t);
9291     }
9292     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
9293         /* insert padding */
9294         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9295         xcb_buffer_len += xcb_block_len + xcb_pad;
9296         if (0 != xcb_pad) {
9297             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9298             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9299             xcb_parts_idx++;
9300             xcb_pad = 0;
9301         }
9302         xcb_block_len = 0;
9303         xcb_padding_offset = 0;
9304         /* groups */
9305         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
9306         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
9307         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
9308         xcb_parts_idx++;
9309         xcb_align_to = ALIGNOF(xcb_atom_t);
9310     }
9311     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
9312         /* insert padding */
9313         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9314         xcb_buffer_len += xcb_block_len + xcb_pad;
9315         if (0 != xcb_pad) {
9316             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9317             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9318             xcb_parts_idx++;
9319             xcb_pad = 0;
9320         }
9321         xcb_block_len = 0;
9322         xcb_padding_offset = 0;
9323         /* keyNames */
9324         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
9325         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
9326         xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
9327         xcb_parts_idx++;
9328         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
9329     }
9330     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
9331         /* insert padding */
9332         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9333         xcb_buffer_len += xcb_block_len + xcb_pad;
9334         if (0 != xcb_pad) {
9335             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9336             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9337             xcb_parts_idx++;
9338             xcb_pad = 0;
9339         }
9340         xcb_block_len = 0;
9341         xcb_padding_offset = 0;
9342         /* keyAliases */
9343         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
9344         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
9345         xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
9346         xcb_parts_idx++;
9347         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
9348     }
9349     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
9350         /* insert padding */
9351         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9352         xcb_buffer_len += xcb_block_len + xcb_pad;
9353         if (0 != xcb_pad) {
9354             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9355             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9356             xcb_parts_idx++;
9357             xcb_pad = 0;
9358         }
9359         xcb_block_len = 0;
9360         xcb_padding_offset = 0;
9361         /* radioGroupNames */
9362         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
9363         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
9364         xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
9365         xcb_parts_idx++;
9366         xcb_align_to = ALIGNOF(xcb_atom_t);
9367     }
9368     /* insert padding */
9369     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9370     xcb_buffer_len += xcb_block_len + xcb_pad;
9371     if (0 != xcb_pad) {
9372         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9373         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9374         xcb_parts_idx++;
9375         xcb_pad = 0;
9376     }
9377     xcb_block_len = 0;
9378     xcb_padding_offset = 0;
9379 
9380     if (NULL == xcb_out) {
9381         /* allocate memory */
9382         xcb_out = malloc(xcb_buffer_len);
9383         *_buffer = xcb_out;
9384     }
9385 
9386     xcb_tmp = xcb_out;
9387     for(i=0; i<xcb_parts_idx; i++) {
9388         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
9389             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
9390         if (0 != xcb_parts[i].iov_len)
9391             xcb_tmp += xcb_parts[i].iov_len;
9392     }
9393 
9394     return xcb_buffer_len;
9395 }
9396 
9397 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which,xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t * _aux)9398 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void                                              *_buffer,
9399                                                              uint8_t                                                  nTypes,
9400                                                              uint32_t                                                 indicators,
9401                                                              uint16_t                                                 virtualMods,
9402                                                              uint8_t                                                  groupNames,
9403                                                              uint8_t                                                  nKeys,
9404                                                              uint8_t                                                  nKeyAliases,
9405                                                              uint8_t                                                  nRadioGroups,
9406                                                              uint32_t                                                 which,
9407                                                              xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux)
9408 {
9409     char *xcb_tmp = (char *)_buffer;
9410     unsigned int xcb_buffer_len = 0;
9411     unsigned int xcb_block_len = 0;
9412     unsigned int xcb_pad = 0;
9413     unsigned int xcb_align_to = 0;
9414     unsigned int xcb_padding_offset = 0;
9415 
9416     int xcb_pre_tmp_1; /* sumof length */
9417     int xcb_pre_tmp_2; /* sumof loop counter */
9418     int64_t xcb_pre_tmp_3; /* sumof sum */
9419     const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
9420 
9421     if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
9422         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.keycodesName */
9423         _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
9424         xcb_block_len += sizeof(xcb_atom_t);
9425         xcb_tmp += sizeof(xcb_atom_t);
9426         xcb_align_to = ALIGNOF(xcb_atom_t);
9427     }
9428     if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
9429         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.geometryName */
9430         _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
9431         xcb_block_len += sizeof(xcb_atom_t);
9432         xcb_tmp += sizeof(xcb_atom_t);
9433         xcb_align_to = ALIGNOF(xcb_atom_t);
9434     }
9435     if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
9436         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.symbolsName */
9437         _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
9438         xcb_block_len += sizeof(xcb_atom_t);
9439         xcb_tmp += sizeof(xcb_atom_t);
9440         xcb_align_to = ALIGNOF(xcb_atom_t);
9441     }
9442     if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
9443         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.physSymbolsName */
9444         _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
9445         xcb_block_len += sizeof(xcb_atom_t);
9446         xcb_tmp += sizeof(xcb_atom_t);
9447         xcb_align_to = ALIGNOF(xcb_atom_t);
9448     }
9449     if(which & XCB_XKB_NAME_DETAIL_TYPES) {
9450         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.typesName */
9451         _aux->typesName = *(xcb_atom_t *)xcb_tmp;
9452         xcb_block_len += sizeof(xcb_atom_t);
9453         xcb_tmp += sizeof(xcb_atom_t);
9454         xcb_align_to = ALIGNOF(xcb_atom_t);
9455     }
9456     if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
9457         /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.compatName */
9458         _aux->compatName = *(xcb_atom_t *)xcb_tmp;
9459         xcb_block_len += sizeof(xcb_atom_t);
9460         xcb_tmp += sizeof(xcb_atom_t);
9461         xcb_align_to = ALIGNOF(xcb_atom_t);
9462     }
9463     if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
9464         /* insert padding */
9465         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9466         xcb_buffer_len += xcb_block_len + xcb_pad;
9467         if (0 != xcb_pad) {
9468             xcb_tmp += xcb_pad;
9469             xcb_pad = 0;
9470         }
9471         xcb_block_len = 0;
9472         xcb_padding_offset = 0;
9473         /* typeNames */
9474         _aux->typeNames = (xcb_atom_t *)xcb_tmp;
9475         xcb_block_len += nTypes * sizeof(xcb_atom_t);
9476         xcb_tmp += xcb_block_len;
9477         xcb_align_to = ALIGNOF(xcb_atom_t);
9478     }
9479     if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
9480         /* insert padding */
9481         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9482         xcb_buffer_len += xcb_block_len + xcb_pad;
9483         if (0 != xcb_pad) {
9484             xcb_tmp += xcb_pad;
9485             xcb_pad = 0;
9486         }
9487         xcb_block_len = 0;
9488         xcb_padding_offset = 0;
9489         /* nLevelsPerType */
9490         _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
9491         xcb_block_len += nTypes * sizeof(uint8_t);
9492         xcb_tmp += xcb_block_len;
9493         xcb_align_to = ALIGNOF(uint8_t);
9494         xcb_align_to = 4;
9495         /* insert padding */
9496         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9497         xcb_buffer_len += xcb_block_len + xcb_pad;
9498         if (0 != xcb_pad) {
9499             xcb_tmp += xcb_pad;
9500             xcb_pad = 0;
9501         }
9502         xcb_block_len = 0;
9503         xcb_padding_offset = 0;
9504         /* insert padding */
9505         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9506         xcb_buffer_len += xcb_block_len + xcb_pad;
9507         if (0 != xcb_pad) {
9508             xcb_tmp += xcb_pad;
9509             xcb_pad = 0;
9510         }
9511         xcb_block_len = 0;
9512         xcb_padding_offset = 0;
9513         /* ktLevelNames */
9514         _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
9515         /* sumof start */
9516         xcb_pre_tmp_1 = nTypes;
9517         xcb_pre_tmp_3 = 0;
9518         xcb_pre_tmp_4 = _aux->nLevelsPerType;
9519         for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
9520             xcb_pre_tmp_3 += *xcb_pre_tmp_4;
9521             xcb_pre_tmp_4++;
9522         }
9523         /* sumof end. Result is in xcb_pre_tmp_3 */
9524         xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
9525         xcb_tmp += xcb_block_len;
9526         xcb_align_to = ALIGNOF(xcb_atom_t);
9527     }
9528     if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
9529         /* insert padding */
9530         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9531         xcb_buffer_len += xcb_block_len + xcb_pad;
9532         if (0 != xcb_pad) {
9533             xcb_tmp += xcb_pad;
9534             xcb_pad = 0;
9535         }
9536         xcb_block_len = 0;
9537         xcb_padding_offset = 0;
9538         /* indicatorNames */
9539         _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
9540         xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
9541         xcb_tmp += xcb_block_len;
9542         xcb_align_to = ALIGNOF(xcb_atom_t);
9543     }
9544     if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
9545         /* insert padding */
9546         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9547         xcb_buffer_len += xcb_block_len + xcb_pad;
9548         if (0 != xcb_pad) {
9549             xcb_tmp += xcb_pad;
9550             xcb_pad = 0;
9551         }
9552         xcb_block_len = 0;
9553         xcb_padding_offset = 0;
9554         /* virtualModNames */
9555         _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
9556         xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
9557         xcb_tmp += xcb_block_len;
9558         xcb_align_to = ALIGNOF(xcb_atom_t);
9559     }
9560     if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
9561         /* insert padding */
9562         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9563         xcb_buffer_len += xcb_block_len + xcb_pad;
9564         if (0 != xcb_pad) {
9565             xcb_tmp += xcb_pad;
9566             xcb_pad = 0;
9567         }
9568         xcb_block_len = 0;
9569         xcb_padding_offset = 0;
9570         /* groups */
9571         _aux->groups = (xcb_atom_t *)xcb_tmp;
9572         xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
9573         xcb_tmp += xcb_block_len;
9574         xcb_align_to = ALIGNOF(xcb_atom_t);
9575     }
9576     if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
9577         /* insert padding */
9578         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9579         xcb_buffer_len += xcb_block_len + xcb_pad;
9580         if (0 != xcb_pad) {
9581             xcb_tmp += xcb_pad;
9582             xcb_pad = 0;
9583         }
9584         xcb_block_len = 0;
9585         xcb_padding_offset = 0;
9586         /* keyNames */
9587         _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
9588         xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
9589         xcb_tmp += xcb_block_len;
9590         xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
9591     }
9592     if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
9593         /* insert padding */
9594         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9595         xcb_buffer_len += xcb_block_len + xcb_pad;
9596         if (0 != xcb_pad) {
9597             xcb_tmp += xcb_pad;
9598             xcb_pad = 0;
9599         }
9600         xcb_block_len = 0;
9601         xcb_padding_offset = 0;
9602         /* keyAliases */
9603         _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
9604         xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
9605         xcb_tmp += xcb_block_len;
9606         xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
9607     }
9608     if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
9609         /* insert padding */
9610         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9611         xcb_buffer_len += xcb_block_len + xcb_pad;
9612         if (0 != xcb_pad) {
9613             xcb_tmp += xcb_pad;
9614             xcb_pad = 0;
9615         }
9616         xcb_block_len = 0;
9617         xcb_padding_offset = 0;
9618         /* radioGroupNames */
9619         _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
9620         xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
9621         xcb_tmp += xcb_block_len;
9622         xcb_align_to = ALIGNOF(xcb_atom_t);
9623     }
9624     /* insert padding */
9625     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9626     xcb_buffer_len += xcb_block_len + xcb_pad;
9627     if (0 != xcb_pad) {
9628         xcb_tmp += xcb_pad;
9629         xcb_pad = 0;
9630     }
9631     xcb_block_len = 0;
9632     xcb_padding_offset = 0;
9633 
9634     return xcb_buffer_len;
9635 }
9636 
9637 int
xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof(const void * _buffer,uint8_t nTypes,uint32_t indicators,uint16_t virtualMods,uint8_t groupNames,uint8_t nKeys,uint8_t nKeyAliases,uint8_t nRadioGroups,uint32_t which)9638 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void  *_buffer,
9639                                                              uint8_t      nTypes,
9640                                                              uint32_t     indicators,
9641                                                              uint16_t     virtualMods,
9642                                                              uint8_t      groupNames,
9643                                                              uint8_t      nKeys,
9644                                                              uint8_t      nKeyAliases,
9645                                                              uint8_t      nRadioGroups,
9646                                                              uint32_t     which)
9647 {
9648     xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t _aux;
9649     return xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
9650 }
9651 
9652 xcb_xkb_get_kbd_by_name_replies_types_map_t *
xcb_xkb_get_kbd_by_name_replies_types_map(const xcb_xkb_get_kbd_by_name_replies_t * R)9653 xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R)
9654 {
9655     return (xcb_xkb_get_kbd_by_name_replies_types_map_t *) (R + 1);
9656 }
9657 
9658 xcb_xkb_sym_interpret_t *
xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)9659 xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
9660 {
9661     return S->compat_map.si_rtrn;
9662 }
9663 
9664 int
xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9665 xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9666                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
9667 {
9668     return S->compat_map.nSIRtrn;
9669 }
9670 
9671 xcb_xkb_sym_interpret_iterator_t
xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9672 xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
9673                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
9674 {
9675     xcb_xkb_sym_interpret_iterator_t i;
9676     i.data = S->compat_map.si_rtrn;
9677     i.rem = S->compat_map.nSIRtrn;
9678     i.index = (char *) i.data - (char *) S;
9679     return i;
9680 }
9681 
9682 xcb_xkb_mod_def_t *
xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn(const xcb_xkb_get_kbd_by_name_replies_t * S)9683 xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
9684 {
9685     return S->compat_map.group_rtrn;
9686 }
9687 
9688 int
xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9689 xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9690                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
9691 {
9692     return xcb_popcount(S->compat_map.groupsRtrn);
9693 }
9694 
9695 xcb_xkb_mod_def_iterator_t
xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9696 xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
9697                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
9698 {
9699     xcb_xkb_mod_def_iterator_t i;
9700     i.data = S->compat_map.group_rtrn;
9701     i.rem = xcb_popcount(S->compat_map.groupsRtrn);
9702     i.index = (char *) i.data - (char *) S;
9703     return i;
9704 }
9705 
9706 xcb_xkb_indicator_map_t *
xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps(const xcb_xkb_get_kbd_by_name_replies_t * S)9707 xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S)
9708 {
9709     return S->indicator_maps.maps;
9710 }
9711 
9712 int
xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9713 xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
9714                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
9715 {
9716     return S->indicator_maps.nIndicators;
9717 }
9718 
9719 xcb_xkb_indicator_map_iterator_t
xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator(const xcb_xkb_get_kbd_by_name_reply_t * R,const xcb_xkb_get_kbd_by_name_replies_t * S)9720 xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
9721                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
9722 {
9723     xcb_xkb_indicator_map_iterator_t i;
9724     i.data = S->indicator_maps.maps;
9725     i.rem = S->indicator_maps.nIndicators;
9726     i.index = (char *) i.data - (char *) S;
9727     return i;
9728 }
9729 
9730 xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *
xcb_xkb_get_kbd_by_name_replies_key_names_value_list(const xcb_xkb_get_kbd_by_name_replies_t * R)9731 xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R)
9732 {
9733     return (xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *) (R + 1);
9734 }
9735 
9736 xcb_xkb_counted_string_16_t *
xcb_xkb_get_kbd_by_name_replies_geometry_label_font(const xcb_xkb_get_kbd_by_name_replies_t * R)9737 xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R)
9738 {
9739     return (xcb_xkb_counted_string_16_t *) (R + 1);
9740 }
9741 
9742 int
xcb_xkb_get_kbd_by_name_replies_serialize(void ** _buffer,uint16_t reported,const xcb_xkb_get_kbd_by_name_replies_t * _aux)9743 xcb_xkb_get_kbd_by_name_replies_serialize (void                                    **_buffer,
9744                                            uint16_t                                  reported,
9745                                            const xcb_xkb_get_kbd_by_name_replies_t  *_aux)
9746 {
9747     char *xcb_out = *_buffer;
9748     unsigned int xcb_buffer_len = 0;
9749     unsigned int xcb_align_to = 0;
9750     unsigned int xcb_padding_offset = 0;
9751 
9752     unsigned int xcb_pad = 0;
9753     char xcb_pad0[3] = {0, 0, 0};
9754     struct iovec xcb_parts[96];
9755     unsigned int xcb_parts_idx = 0;
9756     unsigned int xcb_block_len = 0;
9757     unsigned int i;
9758     char *xcb_tmp;
9759 
9760     if((reported & XCB_XKB_GBN_DETAIL_TYPES) ||
9761        (reported & XCB_XKB_GBN_DETAIL_CLIENT_SYMBOLS) ||
9762        (reported & XCB_XKB_GBN_DETAIL_SERVER_SYMBOLS)) {
9763         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_type */
9764         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_type;
9765         xcb_block_len += sizeof(uint8_t);
9766         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9767         xcb_parts_idx++;
9768         xcb_align_to = ALIGNOF(uint8_t);
9769         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeDeviceID */
9770         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeDeviceID;
9771         xcb_block_len += sizeof(uint8_t);
9772         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9773         xcb_parts_idx++;
9774         xcb_align_to = ALIGNOF(uint8_t);
9775         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_sequence */
9776         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_sequence;
9777         xcb_block_len += sizeof(uint16_t);
9778         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9779         xcb_parts_idx++;
9780         xcb_align_to = ALIGNOF(uint16_t);
9781         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_length */
9782         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_length;
9783         xcb_block_len += sizeof(uint32_t);
9784         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
9785         xcb_parts_idx++;
9786         xcb_align_to = ALIGNOF(uint32_t);
9787         /* xcb_xkb_get_kbd_by_name_replies_t.types.pad1 */
9788         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9789         xcb_block_len += sizeof(uint8_t)*2;
9790         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
9791         xcb_parts_idx++;
9792         xcb_align_to = ALIGNOF(uint8_t);
9793         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMinKeyCode */
9794         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeMinKeyCode;
9795         xcb_block_len += sizeof(xcb_keycode_t);
9796         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9797         xcb_parts_idx++;
9798         xcb_align_to = ALIGNOF(xcb_keycode_t);
9799         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMaxKeyCode */
9800         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeMaxKeyCode;
9801         xcb_block_len += sizeof(xcb_keycode_t);
9802         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9803         xcb_parts_idx++;
9804         xcb_align_to = ALIGNOF(xcb_keycode_t);
9805         /* xcb_xkb_get_kbd_by_name_replies_t.types.present */
9806         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.present;
9807         xcb_block_len += sizeof(uint16_t);
9808         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9809         xcb_parts_idx++;
9810         xcb_align_to = ALIGNOF(uint16_t);
9811         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstType */
9812         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstType;
9813         xcb_block_len += sizeof(uint8_t);
9814         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9815         xcb_parts_idx++;
9816         xcb_align_to = ALIGNOF(uint8_t);
9817         /* xcb_xkb_get_kbd_by_name_replies_t.types.nTypes */
9818         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nTypes;
9819         xcb_block_len += sizeof(uint8_t);
9820         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9821         xcb_parts_idx++;
9822         xcb_align_to = ALIGNOF(uint8_t);
9823         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalTypes */
9824         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalTypes;
9825         xcb_block_len += sizeof(uint8_t);
9826         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9827         xcb_parts_idx++;
9828         xcb_align_to = ALIGNOF(uint8_t);
9829         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeySym */
9830         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeySym;
9831         xcb_block_len += sizeof(xcb_keycode_t);
9832         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9833         xcb_parts_idx++;
9834         xcb_align_to = ALIGNOF(xcb_keycode_t);
9835         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalSyms */
9836         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalSyms;
9837         xcb_block_len += sizeof(uint16_t);
9838         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9839         xcb_parts_idx++;
9840         xcb_align_to = ALIGNOF(uint16_t);
9841         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeySyms */
9842         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeySyms;
9843         xcb_block_len += sizeof(uint8_t);
9844         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9845         xcb_parts_idx++;
9846         xcb_align_to = ALIGNOF(uint8_t);
9847         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyAction */
9848         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyAction;
9849         xcb_block_len += sizeof(xcb_keycode_t);
9850         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9851         xcb_parts_idx++;
9852         xcb_align_to = ALIGNOF(xcb_keycode_t);
9853         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalActions */
9854         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalActions;
9855         xcb_block_len += sizeof(uint16_t);
9856         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9857         xcb_parts_idx++;
9858         xcb_align_to = ALIGNOF(uint16_t);
9859         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyActions */
9860         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyActions;
9861         xcb_block_len += sizeof(uint8_t);
9862         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9863         xcb_parts_idx++;
9864         xcb_align_to = ALIGNOF(uint8_t);
9865         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyBehavior */
9866         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyBehavior;
9867         xcb_block_len += sizeof(xcb_keycode_t);
9868         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9869         xcb_parts_idx++;
9870         xcb_align_to = ALIGNOF(xcb_keycode_t);
9871         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyBehaviors */
9872         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyBehaviors;
9873         xcb_block_len += sizeof(uint8_t);
9874         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9875         xcb_parts_idx++;
9876         xcb_align_to = ALIGNOF(uint8_t);
9877         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyBehaviors */
9878         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalKeyBehaviors;
9879         xcb_block_len += sizeof(uint8_t);
9880         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9881         xcb_parts_idx++;
9882         xcb_align_to = ALIGNOF(uint8_t);
9883         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyExplicit */
9884         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyExplicit;
9885         xcb_block_len += sizeof(xcb_keycode_t);
9886         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9887         xcb_parts_idx++;
9888         xcb_align_to = ALIGNOF(xcb_keycode_t);
9889         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyExplicit */
9890         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyExplicit;
9891         xcb_block_len += sizeof(uint8_t);
9892         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9893         xcb_parts_idx++;
9894         xcb_align_to = ALIGNOF(uint8_t);
9895         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyExplicit */
9896         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalKeyExplicit;
9897         xcb_block_len += sizeof(uint8_t);
9898         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9899         xcb_parts_idx++;
9900         xcb_align_to = ALIGNOF(uint8_t);
9901         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstModMapKey */
9902         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstModMapKey;
9903         xcb_block_len += sizeof(xcb_keycode_t);
9904         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9905         xcb_parts_idx++;
9906         xcb_align_to = ALIGNOF(xcb_keycode_t);
9907         /* xcb_xkb_get_kbd_by_name_replies_t.types.nModMapKeys */
9908         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nModMapKeys;
9909         xcb_block_len += sizeof(uint8_t);
9910         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9911         xcb_parts_idx++;
9912         xcb_align_to = ALIGNOF(uint8_t);
9913         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalModMapKeys */
9914         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalModMapKeys;
9915         xcb_block_len += sizeof(uint8_t);
9916         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9917         xcb_parts_idx++;
9918         xcb_align_to = ALIGNOF(uint8_t);
9919         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstVModMapKey */
9920         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstVModMapKey;
9921         xcb_block_len += sizeof(xcb_keycode_t);
9922         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
9923         xcb_parts_idx++;
9924         xcb_align_to = ALIGNOF(xcb_keycode_t);
9925         /* xcb_xkb_get_kbd_by_name_replies_t.types.nVModMapKeys */
9926         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nVModMapKeys;
9927         xcb_block_len += sizeof(uint8_t);
9928         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9929         xcb_parts_idx++;
9930         xcb_align_to = ALIGNOF(uint8_t);
9931         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalVModMapKeys */
9932         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalVModMapKeys;
9933         xcb_block_len += sizeof(uint8_t);
9934         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9935         xcb_parts_idx++;
9936         xcb_align_to = ALIGNOF(uint8_t);
9937         /* xcb_xkb_get_kbd_by_name_replies_t.types.pad2 */
9938         xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
9939         xcb_block_len += sizeof(uint8_t);
9940         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9941         xcb_parts_idx++;
9942         xcb_align_to = ALIGNOF(uint8_t);
9943         /* xcb_xkb_get_kbd_by_name_replies_t.types.virtualMods */
9944         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.virtualMods;
9945         xcb_block_len += sizeof(uint16_t);
9946         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9947         xcb_parts_idx++;
9948         xcb_align_to = ALIGNOF(uint16_t);
9949         /* insert padding */
9950         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
9951         xcb_buffer_len += xcb_block_len + xcb_pad;
9952         if (0 != xcb_pad) {
9953             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
9954             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
9955             xcb_parts_idx++;
9956             xcb_pad = 0;
9957         }
9958         xcb_block_len = 0;
9959         xcb_padding_offset = 0;
9960         /* map */
9961         xcb_parts[xcb_parts_idx].iov_base = (char *)0;
9962         xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
9963         xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
9964         xcb_parts_idx++;
9965         xcb_align_to = ALIGNOF(char);
9966     }
9967     if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) {
9968         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */
9969         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_type;
9970         xcb_block_len += sizeof(uint8_t);
9971         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9972         xcb_parts_idx++;
9973         xcb_align_to = ALIGNOF(uint8_t);
9974         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatDeviceID */
9975         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatDeviceID;
9976         xcb_block_len += sizeof(uint8_t);
9977         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9978         xcb_parts_idx++;
9979         xcb_align_to = ALIGNOF(uint8_t);
9980         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_sequence */
9981         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_sequence;
9982         xcb_block_len += sizeof(uint16_t);
9983         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
9984         xcb_parts_idx++;
9985         xcb_align_to = ALIGNOF(uint16_t);
9986         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_length */
9987         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_length;
9988         xcb_block_len += sizeof(uint32_t);
9989         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
9990         xcb_parts_idx++;
9991         xcb_align_to = ALIGNOF(uint32_t);
9992         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.groupsRtrn */
9993         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.groupsRtrn;
9994         xcb_block_len += sizeof(uint8_t);
9995         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
9996         xcb_parts_idx++;
9997         xcb_align_to = ALIGNOF(uint8_t);
9998         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */
9999         xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
10000         xcb_block_len += sizeof(uint8_t);
10001         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10002         xcb_parts_idx++;
10003         xcb_align_to = ALIGNOF(uint8_t);
10004         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.firstSIRtrn */
10005         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.firstSIRtrn;
10006         xcb_block_len += sizeof(uint16_t);
10007         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10008         xcb_parts_idx++;
10009         xcb_align_to = ALIGNOF(uint16_t);
10010         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nSIRtrn */
10011         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.nSIRtrn;
10012         xcb_block_len += sizeof(uint16_t);
10013         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10014         xcb_parts_idx++;
10015         xcb_align_to = ALIGNOF(uint16_t);
10016         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nTotalSI */
10017         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.nTotalSI;
10018         xcb_block_len += sizeof(uint16_t);
10019         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10020         xcb_parts_idx++;
10021         xcb_align_to = ALIGNOF(uint16_t);
10022         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */
10023         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10024         xcb_block_len += sizeof(uint8_t)*16;
10025         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*16;
10026         xcb_parts_idx++;
10027         xcb_align_to = ALIGNOF(uint8_t);
10028         /* insert padding */
10029         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10030         xcb_buffer_len += xcb_block_len + xcb_pad;
10031         if (0 != xcb_pad) {
10032             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10033             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10034             xcb_parts_idx++;
10035             xcb_pad = 0;
10036         }
10037         xcb_block_len = 0;
10038         xcb_padding_offset = 0;
10039         /* si_rtrn */
10040         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.si_rtrn;
10041         xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
10042         xcb_parts[xcb_parts_idx].iov_len = _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
10043         xcb_parts_idx++;
10044         xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
10045         /* insert padding */
10046         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10047         xcb_buffer_len += xcb_block_len + xcb_pad;
10048         if (0 != xcb_pad) {
10049             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10050             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10051             xcb_parts_idx++;
10052             xcb_pad = 0;
10053         }
10054         xcb_block_len = 0;
10055         xcb_padding_offset = 0;
10056         /* group_rtrn */
10057         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.group_rtrn;
10058         xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
10059         xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
10060         xcb_parts_idx++;
10061         xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
10062     }
10063     if(reported & XCB_XKB_GBN_DETAIL_INDICATOR_MAPS) {
10064         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_type */
10065         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_type;
10066         xcb_block_len += sizeof(uint8_t);
10067         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10068         xcb_parts_idx++;
10069         xcb_align_to = ALIGNOF(uint8_t);
10070         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatorDeviceID */
10071         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatorDeviceID;
10072         xcb_block_len += sizeof(uint8_t);
10073         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10074         xcb_parts_idx++;
10075         xcb_align_to = ALIGNOF(uint8_t);
10076         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_sequence */
10077         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_sequence;
10078         xcb_block_len += sizeof(uint16_t);
10079         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10080         xcb_parts_idx++;
10081         xcb_align_to = ALIGNOF(uint16_t);
10082         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_length */
10083         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_length;
10084         xcb_block_len += sizeof(uint32_t);
10085         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10086         xcb_parts_idx++;
10087         xcb_align_to = ALIGNOF(uint32_t);
10088         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.which */
10089         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.which;
10090         xcb_block_len += sizeof(uint32_t);
10091         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10092         xcb_parts_idx++;
10093         xcb_align_to = ALIGNOF(uint32_t);
10094         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.realIndicators */
10095         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.realIndicators;
10096         xcb_block_len += sizeof(uint32_t);
10097         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10098         xcb_parts_idx++;
10099         xcb_align_to = ALIGNOF(uint32_t);
10100         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.nIndicators */
10101         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.nIndicators;
10102         xcb_block_len += sizeof(uint8_t);
10103         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10104         xcb_parts_idx++;
10105         xcb_align_to = ALIGNOF(uint8_t);
10106         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */
10107         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10108         xcb_block_len += sizeof(uint8_t)*15;
10109         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*15;
10110         xcb_parts_idx++;
10111         xcb_align_to = ALIGNOF(uint8_t);
10112         /* insert padding */
10113         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10114         xcb_buffer_len += xcb_block_len + xcb_pad;
10115         if (0 != xcb_pad) {
10116             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10117             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10118             xcb_parts_idx++;
10119             xcb_pad = 0;
10120         }
10121         xcb_block_len = 0;
10122         xcb_padding_offset = 0;
10123         /* maps */
10124         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicator_maps.maps;
10125         xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
10126         xcb_parts[xcb_parts_idx].iov_len = _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
10127         xcb_parts_idx++;
10128         xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
10129     }
10130     if((reported & XCB_XKB_GBN_DETAIL_KEY_NAMES) ||
10131        (reported & XCB_XKB_GBN_DETAIL_OTHER_NAMES)) {
10132         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_type */
10133         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_type;
10134         xcb_block_len += sizeof(uint8_t);
10135         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10136         xcb_parts_idx++;
10137         xcb_align_to = ALIGNOF(uint8_t);
10138         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyDeviceID */
10139         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyDeviceID;
10140         xcb_block_len += sizeof(uint8_t);
10141         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10142         xcb_parts_idx++;
10143         xcb_align_to = ALIGNOF(uint8_t);
10144         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_sequence */
10145         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_sequence;
10146         xcb_block_len += sizeof(uint16_t);
10147         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10148         xcb_parts_idx++;
10149         xcb_align_to = ALIGNOF(uint16_t);
10150         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_length */
10151         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_length;
10152         xcb_block_len += sizeof(uint32_t);
10153         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10154         xcb_parts_idx++;
10155         xcb_align_to = ALIGNOF(uint32_t);
10156         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.which */
10157         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.which;
10158         xcb_block_len += sizeof(uint32_t);
10159         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10160         xcb_parts_idx++;
10161         xcb_align_to = ALIGNOF(uint32_t);
10162         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMinKeyCode */
10163         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyMinKeyCode;
10164         xcb_block_len += sizeof(xcb_keycode_t);
10165         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
10166         xcb_parts_idx++;
10167         xcb_align_to = ALIGNOF(xcb_keycode_t);
10168         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMaxKeyCode */
10169         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyMaxKeyCode;
10170         xcb_block_len += sizeof(xcb_keycode_t);
10171         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
10172         xcb_parts_idx++;
10173         xcb_align_to = ALIGNOF(xcb_keycode_t);
10174         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nTypes */
10175         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nTypes;
10176         xcb_block_len += sizeof(uint8_t);
10177         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10178         xcb_parts_idx++;
10179         xcb_align_to = ALIGNOF(uint8_t);
10180         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.groupNames */
10181         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.groupNames;
10182         xcb_block_len += sizeof(uint8_t);
10183         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10184         xcb_parts_idx++;
10185         xcb_align_to = ALIGNOF(uint8_t);
10186         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.virtualMods */
10187         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.virtualMods;
10188         xcb_block_len += sizeof(uint16_t);
10189         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10190         xcb_parts_idx++;
10191         xcb_align_to = ALIGNOF(uint16_t);
10192         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.firstKey */
10193         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.firstKey;
10194         xcb_block_len += sizeof(xcb_keycode_t);
10195         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
10196         xcb_parts_idx++;
10197         xcb_align_to = ALIGNOF(xcb_keycode_t);
10198         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeys */
10199         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKeys;
10200         xcb_block_len += sizeof(uint8_t);
10201         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10202         xcb_parts_idx++;
10203         xcb_align_to = ALIGNOF(uint8_t);
10204         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.indicators */
10205         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.indicators;
10206         xcb_block_len += sizeof(uint32_t);
10207         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10208         xcb_parts_idx++;
10209         xcb_align_to = ALIGNOF(uint32_t);
10210         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nRadioGroups */
10211         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nRadioGroups;
10212         xcb_block_len += sizeof(uint8_t);
10213         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10214         xcb_parts_idx++;
10215         xcb_align_to = ALIGNOF(uint8_t);
10216         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeyAliases */
10217         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKeyAliases;
10218         xcb_block_len += sizeof(uint8_t);
10219         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10220         xcb_parts_idx++;
10221         xcb_align_to = ALIGNOF(uint8_t);
10222         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKTLevels */
10223         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKTLevels;
10224         xcb_block_len += sizeof(uint16_t);
10225         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10226         xcb_parts_idx++;
10227         xcb_align_to = ALIGNOF(uint16_t);
10228         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */
10229         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10230         xcb_block_len += sizeof(uint8_t)*4;
10231         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*4;
10232         xcb_parts_idx++;
10233         xcb_align_to = ALIGNOF(uint8_t);
10234         /* insert padding */
10235         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10236         xcb_buffer_len += xcb_block_len + xcb_pad;
10237         if (0 != xcb_pad) {
10238             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10239             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10240             xcb_parts_idx++;
10241             xcb_pad = 0;
10242         }
10243         xcb_block_len = 0;
10244         xcb_padding_offset = 0;
10245         /* valueList */
10246         xcb_parts[xcb_parts_idx].iov_base = (char *)0;
10247         xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
10248         xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
10249         xcb_parts_idx++;
10250         xcb_align_to = ALIGNOF(char);
10251     }
10252     if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) {
10253         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */
10254         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_type;
10255         xcb_block_len += sizeof(uint8_t);
10256         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10257         xcb_parts_idx++;
10258         xcb_align_to = ALIGNOF(uint8_t);
10259         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryDeviceID */
10260         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometryDeviceID;
10261         xcb_block_len += sizeof(uint8_t);
10262         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10263         xcb_parts_idx++;
10264         xcb_align_to = ALIGNOF(uint8_t);
10265         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_sequence */
10266         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_sequence;
10267         xcb_block_len += sizeof(uint16_t);
10268         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10269         xcb_parts_idx++;
10270         xcb_align_to = ALIGNOF(uint16_t);
10271         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_length */
10272         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_length;
10273         xcb_block_len += sizeof(uint32_t);
10274         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
10275         xcb_parts_idx++;
10276         xcb_align_to = ALIGNOF(uint32_t);
10277         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.name */
10278         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.name;
10279         xcb_block_len += sizeof(xcb_atom_t);
10280         xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
10281         xcb_parts_idx++;
10282         xcb_align_to = ALIGNOF(xcb_atom_t);
10283         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryFound */
10284         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometryFound;
10285         xcb_block_len += sizeof(uint8_t);
10286         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10287         xcb_parts_idx++;
10288         xcb_align_to = ALIGNOF(uint8_t);
10289         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */
10290         xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
10291         xcb_block_len += sizeof(uint8_t);
10292         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10293         xcb_parts_idx++;
10294         xcb_align_to = ALIGNOF(uint8_t);
10295         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.widthMM */
10296         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.widthMM;
10297         xcb_block_len += sizeof(uint16_t);
10298         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10299         xcb_parts_idx++;
10300         xcb_align_to = ALIGNOF(uint16_t);
10301         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.heightMM */
10302         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.heightMM;
10303         xcb_block_len += sizeof(uint16_t);
10304         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10305         xcb_parts_idx++;
10306         xcb_align_to = ALIGNOF(uint16_t);
10307         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nProperties */
10308         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nProperties;
10309         xcb_block_len += sizeof(uint16_t);
10310         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10311         xcb_parts_idx++;
10312         xcb_align_to = ALIGNOF(uint16_t);
10313         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nColors */
10314         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nColors;
10315         xcb_block_len += sizeof(uint16_t);
10316         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10317         xcb_parts_idx++;
10318         xcb_align_to = ALIGNOF(uint16_t);
10319         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nShapes */
10320         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nShapes;
10321         xcb_block_len += sizeof(uint16_t);
10322         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10323         xcb_parts_idx++;
10324         xcb_align_to = ALIGNOF(uint16_t);
10325         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nSections */
10326         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nSections;
10327         xcb_block_len += sizeof(uint16_t);
10328         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10329         xcb_parts_idx++;
10330         xcb_align_to = ALIGNOF(uint16_t);
10331         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nDoodads */
10332         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nDoodads;
10333         xcb_block_len += sizeof(uint16_t);
10334         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10335         xcb_parts_idx++;
10336         xcb_align_to = ALIGNOF(uint16_t);
10337         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nKeyAliases */
10338         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nKeyAliases;
10339         xcb_block_len += sizeof(uint16_t);
10340         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
10341         xcb_parts_idx++;
10342         xcb_align_to = ALIGNOF(uint16_t);
10343         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.baseColorNdx */
10344         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.baseColorNdx;
10345         xcb_block_len += sizeof(uint8_t);
10346         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10347         xcb_parts_idx++;
10348         xcb_align_to = ALIGNOF(uint8_t);
10349         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.labelColorNdx */
10350         xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.labelColorNdx;
10351         xcb_block_len += sizeof(uint8_t);
10352         xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
10353         xcb_parts_idx++;
10354         xcb_align_to = ALIGNOF(uint8_t);
10355         /* insert padding */
10356         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10357         xcb_buffer_len += xcb_block_len + xcb_pad;
10358         if (0 != xcb_pad) {
10359             xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10360             xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10361             xcb_parts_idx++;
10362             xcb_pad = 0;
10363         }
10364         xcb_block_len = 0;
10365         xcb_padding_offset = 0;
10366         /* labelFont */
10367         xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->geometry.labelFont;
10368         xcb_block_len += xcb_xkb_counted_string_16_sizeof(_aux->geometry.labelFont);
10369         xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_counted_string_16_sizeof(_aux->geometry.labelFont);
10370         xcb_parts_idx++;
10371         xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_t);
10372     }
10373     /* insert padding */
10374     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10375     xcb_buffer_len += xcb_block_len + xcb_pad;
10376     if (0 != xcb_pad) {
10377         xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
10378         xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
10379         xcb_parts_idx++;
10380         xcb_pad = 0;
10381     }
10382     xcb_block_len = 0;
10383     xcb_padding_offset = 0;
10384 
10385     if (NULL == xcb_out) {
10386         /* allocate memory */
10387         xcb_out = malloc(xcb_buffer_len);
10388         *_buffer = xcb_out;
10389     }
10390 
10391     xcb_tmp = xcb_out;
10392     for(i=0; i<xcb_parts_idx; i++) {
10393         if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
10394             memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
10395         if (0 != xcb_parts[i].iov_len)
10396             xcb_tmp += xcb_parts[i].iov_len;
10397     }
10398 
10399     return xcb_buffer_len;
10400 }
10401 
10402 int
xcb_xkb_get_kbd_by_name_replies_unpack(const void * _buffer,uint16_t reported,xcb_xkb_get_kbd_by_name_replies_t * _aux)10403 xcb_xkb_get_kbd_by_name_replies_unpack (const void                         *_buffer,
10404                                         uint16_t                            reported,
10405                                         xcb_xkb_get_kbd_by_name_replies_t  *_aux)
10406 {
10407     char *xcb_tmp = (char *)_buffer;
10408     unsigned int xcb_buffer_len = 0;
10409     unsigned int xcb_block_len = 0;
10410     unsigned int xcb_pad = 0;
10411     unsigned int xcb_align_to = 0;
10412     unsigned int xcb_padding_offset = 0;
10413 
10414 
10415     if((reported & XCB_XKB_GBN_DETAIL_TYPES) ||
10416        (reported & XCB_XKB_GBN_DETAIL_CLIENT_SYMBOLS) ||
10417        (reported & XCB_XKB_GBN_DETAIL_SERVER_SYMBOLS)) {
10418         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_type */
10419         _aux->types.getmap_type = *(uint8_t *)xcb_tmp;
10420         xcb_block_len += sizeof(uint8_t);
10421         xcb_tmp += sizeof(uint8_t);
10422         xcb_align_to = ALIGNOF(uint8_t);
10423         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeDeviceID */
10424         _aux->types.typeDeviceID = *(uint8_t *)xcb_tmp;
10425         xcb_block_len += sizeof(uint8_t);
10426         xcb_tmp += sizeof(uint8_t);
10427         xcb_align_to = ALIGNOF(uint8_t);
10428         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_sequence */
10429         _aux->types.getmap_sequence = *(uint16_t *)xcb_tmp;
10430         xcb_block_len += sizeof(uint16_t);
10431         xcb_tmp += sizeof(uint16_t);
10432         xcb_align_to = ALIGNOF(uint16_t);
10433         /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_length */
10434         _aux->types.getmap_length = *(uint32_t *)xcb_tmp;
10435         xcb_block_len += sizeof(uint32_t);
10436         xcb_tmp += sizeof(uint32_t);
10437         xcb_align_to = ALIGNOF(uint32_t);
10438         /* xcb_xkb_get_kbd_by_name_replies_t.types.pad1 */
10439         _aux->types.pad1[0] = *(uint8_t *)xcb_tmp;
10440         _aux->types.pad1[1] = *(uint8_t *)xcb_tmp;
10441         xcb_block_len += sizeof(uint8_t) * 2;
10442         xcb_tmp += sizeof(uint8_t) * 2;
10443         xcb_align_to = ALIGNOF(uint8_t);
10444         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMinKeyCode */
10445         _aux->types.typeMinKeyCode = *(xcb_keycode_t *)xcb_tmp;
10446         xcb_block_len += sizeof(xcb_keycode_t);
10447         xcb_tmp += sizeof(xcb_keycode_t);
10448         xcb_align_to = ALIGNOF(xcb_keycode_t);
10449         /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMaxKeyCode */
10450         _aux->types.typeMaxKeyCode = *(xcb_keycode_t *)xcb_tmp;
10451         xcb_block_len += sizeof(xcb_keycode_t);
10452         xcb_tmp += sizeof(xcb_keycode_t);
10453         xcb_align_to = ALIGNOF(xcb_keycode_t);
10454         /* xcb_xkb_get_kbd_by_name_replies_t.types.present */
10455         _aux->types.present = *(uint16_t *)xcb_tmp;
10456         xcb_block_len += sizeof(uint16_t);
10457         xcb_tmp += sizeof(uint16_t);
10458         xcb_align_to = ALIGNOF(uint16_t);
10459         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstType */
10460         _aux->types.firstType = *(uint8_t *)xcb_tmp;
10461         xcb_block_len += sizeof(uint8_t);
10462         xcb_tmp += sizeof(uint8_t);
10463         xcb_align_to = ALIGNOF(uint8_t);
10464         /* xcb_xkb_get_kbd_by_name_replies_t.types.nTypes */
10465         _aux->types.nTypes = *(uint8_t *)xcb_tmp;
10466         xcb_block_len += sizeof(uint8_t);
10467         xcb_tmp += sizeof(uint8_t);
10468         xcb_align_to = ALIGNOF(uint8_t);
10469         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalTypes */
10470         _aux->types.totalTypes = *(uint8_t *)xcb_tmp;
10471         xcb_block_len += sizeof(uint8_t);
10472         xcb_tmp += sizeof(uint8_t);
10473         xcb_align_to = ALIGNOF(uint8_t);
10474         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeySym */
10475         _aux->types.firstKeySym = *(xcb_keycode_t *)xcb_tmp;
10476         xcb_block_len += sizeof(xcb_keycode_t);
10477         xcb_tmp += sizeof(xcb_keycode_t);
10478         xcb_align_to = ALIGNOF(xcb_keycode_t);
10479         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalSyms */
10480         _aux->types.totalSyms = *(uint16_t *)xcb_tmp;
10481         xcb_block_len += sizeof(uint16_t);
10482         xcb_tmp += sizeof(uint16_t);
10483         xcb_align_to = ALIGNOF(uint16_t);
10484         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeySyms */
10485         _aux->types.nKeySyms = *(uint8_t *)xcb_tmp;
10486         xcb_block_len += sizeof(uint8_t);
10487         xcb_tmp += sizeof(uint8_t);
10488         xcb_align_to = ALIGNOF(uint8_t);
10489         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyAction */
10490         _aux->types.firstKeyAction = *(xcb_keycode_t *)xcb_tmp;
10491         xcb_block_len += sizeof(xcb_keycode_t);
10492         xcb_tmp += sizeof(xcb_keycode_t);
10493         xcb_align_to = ALIGNOF(xcb_keycode_t);
10494         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalActions */
10495         _aux->types.totalActions = *(uint16_t *)xcb_tmp;
10496         xcb_block_len += sizeof(uint16_t);
10497         xcb_tmp += sizeof(uint16_t);
10498         xcb_align_to = ALIGNOF(uint16_t);
10499         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyActions */
10500         _aux->types.nKeyActions = *(uint8_t *)xcb_tmp;
10501         xcb_block_len += sizeof(uint8_t);
10502         xcb_tmp += sizeof(uint8_t);
10503         xcb_align_to = ALIGNOF(uint8_t);
10504         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyBehavior */
10505         _aux->types.firstKeyBehavior = *(xcb_keycode_t *)xcb_tmp;
10506         xcb_block_len += sizeof(xcb_keycode_t);
10507         xcb_tmp += sizeof(xcb_keycode_t);
10508         xcb_align_to = ALIGNOF(xcb_keycode_t);
10509         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyBehaviors */
10510         _aux->types.nKeyBehaviors = *(uint8_t *)xcb_tmp;
10511         xcb_block_len += sizeof(uint8_t);
10512         xcb_tmp += sizeof(uint8_t);
10513         xcb_align_to = ALIGNOF(uint8_t);
10514         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyBehaviors */
10515         _aux->types.totalKeyBehaviors = *(uint8_t *)xcb_tmp;
10516         xcb_block_len += sizeof(uint8_t);
10517         xcb_tmp += sizeof(uint8_t);
10518         xcb_align_to = ALIGNOF(uint8_t);
10519         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyExplicit */
10520         _aux->types.firstKeyExplicit = *(xcb_keycode_t *)xcb_tmp;
10521         xcb_block_len += sizeof(xcb_keycode_t);
10522         xcb_tmp += sizeof(xcb_keycode_t);
10523         xcb_align_to = ALIGNOF(xcb_keycode_t);
10524         /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyExplicit */
10525         _aux->types.nKeyExplicit = *(uint8_t *)xcb_tmp;
10526         xcb_block_len += sizeof(uint8_t);
10527         xcb_tmp += sizeof(uint8_t);
10528         xcb_align_to = ALIGNOF(uint8_t);
10529         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyExplicit */
10530         _aux->types.totalKeyExplicit = *(uint8_t *)xcb_tmp;
10531         xcb_block_len += sizeof(uint8_t);
10532         xcb_tmp += sizeof(uint8_t);
10533         xcb_align_to = ALIGNOF(uint8_t);
10534         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstModMapKey */
10535         _aux->types.firstModMapKey = *(xcb_keycode_t *)xcb_tmp;
10536         xcb_block_len += sizeof(xcb_keycode_t);
10537         xcb_tmp += sizeof(xcb_keycode_t);
10538         xcb_align_to = ALIGNOF(xcb_keycode_t);
10539         /* xcb_xkb_get_kbd_by_name_replies_t.types.nModMapKeys */
10540         _aux->types.nModMapKeys = *(uint8_t *)xcb_tmp;
10541         xcb_block_len += sizeof(uint8_t);
10542         xcb_tmp += sizeof(uint8_t);
10543         xcb_align_to = ALIGNOF(uint8_t);
10544         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalModMapKeys */
10545         _aux->types.totalModMapKeys = *(uint8_t *)xcb_tmp;
10546         xcb_block_len += sizeof(uint8_t);
10547         xcb_tmp += sizeof(uint8_t);
10548         xcb_align_to = ALIGNOF(uint8_t);
10549         /* xcb_xkb_get_kbd_by_name_replies_t.types.firstVModMapKey */
10550         _aux->types.firstVModMapKey = *(xcb_keycode_t *)xcb_tmp;
10551         xcb_block_len += sizeof(xcb_keycode_t);
10552         xcb_tmp += sizeof(xcb_keycode_t);
10553         xcb_align_to = ALIGNOF(xcb_keycode_t);
10554         /* xcb_xkb_get_kbd_by_name_replies_t.types.nVModMapKeys */
10555         _aux->types.nVModMapKeys = *(uint8_t *)xcb_tmp;
10556         xcb_block_len += sizeof(uint8_t);
10557         xcb_tmp += sizeof(uint8_t);
10558         xcb_align_to = ALIGNOF(uint8_t);
10559         /* xcb_xkb_get_kbd_by_name_replies_t.types.totalVModMapKeys */
10560         _aux->types.totalVModMapKeys = *(uint8_t *)xcb_tmp;
10561         xcb_block_len += sizeof(uint8_t);
10562         xcb_tmp += sizeof(uint8_t);
10563         xcb_align_to = ALIGNOF(uint8_t);
10564         /* xcb_xkb_get_kbd_by_name_replies_t.types.pad2 */
10565         _aux->types.pad2 = *(uint8_t *)xcb_tmp;
10566         xcb_block_len += sizeof(uint8_t);
10567         xcb_tmp += sizeof(uint8_t);
10568         xcb_align_to = ALIGNOF(uint8_t);
10569         /* xcb_xkb_get_kbd_by_name_replies_t.types.virtualMods */
10570         _aux->types.virtualMods = *(uint16_t *)xcb_tmp;
10571         xcb_block_len += sizeof(uint16_t);
10572         xcb_tmp += sizeof(uint16_t);
10573         xcb_align_to = ALIGNOF(uint16_t);
10574         /* insert padding */
10575         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10576         xcb_buffer_len += xcb_block_len + xcb_pad;
10577         if (0 != xcb_pad) {
10578             xcb_tmp += xcb_pad;
10579             xcb_pad = 0;
10580         }
10581         xcb_block_len = 0;
10582         xcb_padding_offset = 0;
10583         /* map */
10584         xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_unpack(xcb_tmp, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
10585         xcb_tmp += xcb_block_len;
10586         xcb_align_to = ALIGNOF(char);
10587     }
10588     if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) {
10589         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */
10590         _aux->compat_map.compatmap_type = *(uint8_t *)xcb_tmp;
10591         xcb_block_len += sizeof(uint8_t);
10592         xcb_tmp += sizeof(uint8_t);
10593         xcb_align_to = ALIGNOF(uint8_t);
10594         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatDeviceID */
10595         _aux->compat_map.compatDeviceID = *(uint8_t *)xcb_tmp;
10596         xcb_block_len += sizeof(uint8_t);
10597         xcb_tmp += sizeof(uint8_t);
10598         xcb_align_to = ALIGNOF(uint8_t);
10599         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_sequence */
10600         _aux->compat_map.compatmap_sequence = *(uint16_t *)xcb_tmp;
10601         xcb_block_len += sizeof(uint16_t);
10602         xcb_tmp += sizeof(uint16_t);
10603         xcb_align_to = ALIGNOF(uint16_t);
10604         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_length */
10605         _aux->compat_map.compatmap_length = *(uint32_t *)xcb_tmp;
10606         xcb_block_len += sizeof(uint32_t);
10607         xcb_tmp += sizeof(uint32_t);
10608         xcb_align_to = ALIGNOF(uint32_t);
10609         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.groupsRtrn */
10610         _aux->compat_map.groupsRtrn = *(uint8_t *)xcb_tmp;
10611         xcb_block_len += sizeof(uint8_t);
10612         xcb_tmp += sizeof(uint8_t);
10613         xcb_align_to = ALIGNOF(uint8_t);
10614         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */
10615         _aux->compat_map.pad7 = *(uint8_t *)xcb_tmp;
10616         xcb_block_len += sizeof(uint8_t);
10617         xcb_tmp += sizeof(uint8_t);
10618         xcb_align_to = ALIGNOF(uint8_t);
10619         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.firstSIRtrn */
10620         _aux->compat_map.firstSIRtrn = *(uint16_t *)xcb_tmp;
10621         xcb_block_len += sizeof(uint16_t);
10622         xcb_tmp += sizeof(uint16_t);
10623         xcb_align_to = ALIGNOF(uint16_t);
10624         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nSIRtrn */
10625         _aux->compat_map.nSIRtrn = *(uint16_t *)xcb_tmp;
10626         xcb_block_len += sizeof(uint16_t);
10627         xcb_tmp += sizeof(uint16_t);
10628         xcb_align_to = ALIGNOF(uint16_t);
10629         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nTotalSI */
10630         _aux->compat_map.nTotalSI = *(uint16_t *)xcb_tmp;
10631         xcb_block_len += sizeof(uint16_t);
10632         xcb_tmp += sizeof(uint16_t);
10633         xcb_align_to = ALIGNOF(uint16_t);
10634         /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */
10635         _aux->compat_map.pad8[0] = *(uint8_t *)xcb_tmp;
10636         _aux->compat_map.pad8[1] = *(uint8_t *)xcb_tmp;
10637         _aux->compat_map.pad8[2] = *(uint8_t *)xcb_tmp;
10638         _aux->compat_map.pad8[3] = *(uint8_t *)xcb_tmp;
10639         _aux->compat_map.pad8[4] = *(uint8_t *)xcb_tmp;
10640         _aux->compat_map.pad8[5] = *(uint8_t *)xcb_tmp;
10641         _aux->compat_map.pad8[6] = *(uint8_t *)xcb_tmp;
10642         _aux->compat_map.pad8[7] = *(uint8_t *)xcb_tmp;
10643         _aux->compat_map.pad8[8] = *(uint8_t *)xcb_tmp;
10644         _aux->compat_map.pad8[9] = *(uint8_t *)xcb_tmp;
10645         _aux->compat_map.pad8[10] = *(uint8_t *)xcb_tmp;
10646         _aux->compat_map.pad8[11] = *(uint8_t *)xcb_tmp;
10647         _aux->compat_map.pad8[12] = *(uint8_t *)xcb_tmp;
10648         _aux->compat_map.pad8[13] = *(uint8_t *)xcb_tmp;
10649         _aux->compat_map.pad8[14] = *(uint8_t *)xcb_tmp;
10650         _aux->compat_map.pad8[15] = *(uint8_t *)xcb_tmp;
10651         xcb_block_len += sizeof(uint8_t) * 16;
10652         xcb_tmp += sizeof(uint8_t) * 16;
10653         xcb_align_to = ALIGNOF(uint8_t);
10654         /* insert padding */
10655         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10656         xcb_buffer_len += xcb_block_len + xcb_pad;
10657         if (0 != xcb_pad) {
10658             xcb_tmp += xcb_pad;
10659             xcb_pad = 0;
10660         }
10661         xcb_block_len = 0;
10662         xcb_padding_offset = 0;
10663         /* si_rtrn */
10664         _aux->compat_map.si_rtrn = (xcb_xkb_sym_interpret_t *)xcb_tmp;
10665         xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
10666         xcb_tmp += xcb_block_len;
10667         xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
10668         /* insert padding */
10669         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10670         xcb_buffer_len += xcb_block_len + xcb_pad;
10671         if (0 != xcb_pad) {
10672             xcb_tmp += xcb_pad;
10673             xcb_pad = 0;
10674         }
10675         xcb_block_len = 0;
10676         xcb_padding_offset = 0;
10677         /* group_rtrn */
10678         _aux->compat_map.group_rtrn = (xcb_xkb_mod_def_t *)xcb_tmp;
10679         xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
10680         xcb_tmp += xcb_block_len;
10681         xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
10682     }
10683     if(reported & XCB_XKB_GBN_DETAIL_INDICATOR_MAPS) {
10684         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_type */
10685         _aux->indicator_maps.indicatormap_type = *(uint8_t *)xcb_tmp;
10686         xcb_block_len += sizeof(uint8_t);
10687         xcb_tmp += sizeof(uint8_t);
10688         xcb_align_to = ALIGNOF(uint8_t);
10689         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatorDeviceID */
10690         _aux->indicator_maps.indicatorDeviceID = *(uint8_t *)xcb_tmp;
10691         xcb_block_len += sizeof(uint8_t);
10692         xcb_tmp += sizeof(uint8_t);
10693         xcb_align_to = ALIGNOF(uint8_t);
10694         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_sequence */
10695         _aux->indicator_maps.indicatormap_sequence = *(uint16_t *)xcb_tmp;
10696         xcb_block_len += sizeof(uint16_t);
10697         xcb_tmp += sizeof(uint16_t);
10698         xcb_align_to = ALIGNOF(uint16_t);
10699         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_length */
10700         _aux->indicator_maps.indicatormap_length = *(uint32_t *)xcb_tmp;
10701         xcb_block_len += sizeof(uint32_t);
10702         xcb_tmp += sizeof(uint32_t);
10703         xcb_align_to = ALIGNOF(uint32_t);
10704         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.which */
10705         _aux->indicator_maps.which = *(uint32_t *)xcb_tmp;
10706         xcb_block_len += sizeof(uint32_t);
10707         xcb_tmp += sizeof(uint32_t);
10708         xcb_align_to = ALIGNOF(uint32_t);
10709         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.realIndicators */
10710         _aux->indicator_maps.realIndicators = *(uint32_t *)xcb_tmp;
10711         xcb_block_len += sizeof(uint32_t);
10712         xcb_tmp += sizeof(uint32_t);
10713         xcb_align_to = ALIGNOF(uint32_t);
10714         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.nIndicators */
10715         _aux->indicator_maps.nIndicators = *(uint8_t *)xcb_tmp;
10716         xcb_block_len += sizeof(uint8_t);
10717         xcb_tmp += sizeof(uint8_t);
10718         xcb_align_to = ALIGNOF(uint8_t);
10719         /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */
10720         _aux->indicator_maps.pad9[0] = *(uint8_t *)xcb_tmp;
10721         _aux->indicator_maps.pad9[1] = *(uint8_t *)xcb_tmp;
10722         _aux->indicator_maps.pad9[2] = *(uint8_t *)xcb_tmp;
10723         _aux->indicator_maps.pad9[3] = *(uint8_t *)xcb_tmp;
10724         _aux->indicator_maps.pad9[4] = *(uint8_t *)xcb_tmp;
10725         _aux->indicator_maps.pad9[5] = *(uint8_t *)xcb_tmp;
10726         _aux->indicator_maps.pad9[6] = *(uint8_t *)xcb_tmp;
10727         _aux->indicator_maps.pad9[7] = *(uint8_t *)xcb_tmp;
10728         _aux->indicator_maps.pad9[8] = *(uint8_t *)xcb_tmp;
10729         _aux->indicator_maps.pad9[9] = *(uint8_t *)xcb_tmp;
10730         _aux->indicator_maps.pad9[10] = *(uint8_t *)xcb_tmp;
10731         _aux->indicator_maps.pad9[11] = *(uint8_t *)xcb_tmp;
10732         _aux->indicator_maps.pad9[12] = *(uint8_t *)xcb_tmp;
10733         _aux->indicator_maps.pad9[13] = *(uint8_t *)xcb_tmp;
10734         _aux->indicator_maps.pad9[14] = *(uint8_t *)xcb_tmp;
10735         xcb_block_len += sizeof(uint8_t) * 15;
10736         xcb_tmp += sizeof(uint8_t) * 15;
10737         xcb_align_to = ALIGNOF(uint8_t);
10738         /* insert padding */
10739         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10740         xcb_buffer_len += xcb_block_len + xcb_pad;
10741         if (0 != xcb_pad) {
10742             xcb_tmp += xcb_pad;
10743             xcb_pad = 0;
10744         }
10745         xcb_block_len = 0;
10746         xcb_padding_offset = 0;
10747         /* maps */
10748         _aux->indicator_maps.maps = (xcb_xkb_indicator_map_t *)xcb_tmp;
10749         xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
10750         xcb_tmp += xcb_block_len;
10751         xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
10752     }
10753     if((reported & XCB_XKB_GBN_DETAIL_KEY_NAMES) ||
10754        (reported & XCB_XKB_GBN_DETAIL_OTHER_NAMES)) {
10755         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_type */
10756         _aux->key_names.keyname_type = *(uint8_t *)xcb_tmp;
10757         xcb_block_len += sizeof(uint8_t);
10758         xcb_tmp += sizeof(uint8_t);
10759         xcb_align_to = ALIGNOF(uint8_t);
10760         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyDeviceID */
10761         _aux->key_names.keyDeviceID = *(uint8_t *)xcb_tmp;
10762         xcb_block_len += sizeof(uint8_t);
10763         xcb_tmp += sizeof(uint8_t);
10764         xcb_align_to = ALIGNOF(uint8_t);
10765         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_sequence */
10766         _aux->key_names.keyname_sequence = *(uint16_t *)xcb_tmp;
10767         xcb_block_len += sizeof(uint16_t);
10768         xcb_tmp += sizeof(uint16_t);
10769         xcb_align_to = ALIGNOF(uint16_t);
10770         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_length */
10771         _aux->key_names.keyname_length = *(uint32_t *)xcb_tmp;
10772         xcb_block_len += sizeof(uint32_t);
10773         xcb_tmp += sizeof(uint32_t);
10774         xcb_align_to = ALIGNOF(uint32_t);
10775         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.which */
10776         _aux->key_names.which = *(uint32_t *)xcb_tmp;
10777         xcb_block_len += sizeof(uint32_t);
10778         xcb_tmp += sizeof(uint32_t);
10779         xcb_align_to = ALIGNOF(uint32_t);
10780         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMinKeyCode */
10781         _aux->key_names.keyMinKeyCode = *(xcb_keycode_t *)xcb_tmp;
10782         xcb_block_len += sizeof(xcb_keycode_t);
10783         xcb_tmp += sizeof(xcb_keycode_t);
10784         xcb_align_to = ALIGNOF(xcb_keycode_t);
10785         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMaxKeyCode */
10786         _aux->key_names.keyMaxKeyCode = *(xcb_keycode_t *)xcb_tmp;
10787         xcb_block_len += sizeof(xcb_keycode_t);
10788         xcb_tmp += sizeof(xcb_keycode_t);
10789         xcb_align_to = ALIGNOF(xcb_keycode_t);
10790         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nTypes */
10791         _aux->key_names.nTypes = *(uint8_t *)xcb_tmp;
10792         xcb_block_len += sizeof(uint8_t);
10793         xcb_tmp += sizeof(uint8_t);
10794         xcb_align_to = ALIGNOF(uint8_t);
10795         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.groupNames */
10796         _aux->key_names.groupNames = *(uint8_t *)xcb_tmp;
10797         xcb_block_len += sizeof(uint8_t);
10798         xcb_tmp += sizeof(uint8_t);
10799         xcb_align_to = ALIGNOF(uint8_t);
10800         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.virtualMods */
10801         _aux->key_names.virtualMods = *(uint16_t *)xcb_tmp;
10802         xcb_block_len += sizeof(uint16_t);
10803         xcb_tmp += sizeof(uint16_t);
10804         xcb_align_to = ALIGNOF(uint16_t);
10805         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.firstKey */
10806         _aux->key_names.firstKey = *(xcb_keycode_t *)xcb_tmp;
10807         xcb_block_len += sizeof(xcb_keycode_t);
10808         xcb_tmp += sizeof(xcb_keycode_t);
10809         xcb_align_to = ALIGNOF(xcb_keycode_t);
10810         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeys */
10811         _aux->key_names.nKeys = *(uint8_t *)xcb_tmp;
10812         xcb_block_len += sizeof(uint8_t);
10813         xcb_tmp += sizeof(uint8_t);
10814         xcb_align_to = ALIGNOF(uint8_t);
10815         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.indicators */
10816         _aux->key_names.indicators = *(uint32_t *)xcb_tmp;
10817         xcb_block_len += sizeof(uint32_t);
10818         xcb_tmp += sizeof(uint32_t);
10819         xcb_align_to = ALIGNOF(uint32_t);
10820         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nRadioGroups */
10821         _aux->key_names.nRadioGroups = *(uint8_t *)xcb_tmp;
10822         xcb_block_len += sizeof(uint8_t);
10823         xcb_tmp += sizeof(uint8_t);
10824         xcb_align_to = ALIGNOF(uint8_t);
10825         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeyAliases */
10826         _aux->key_names.nKeyAliases = *(uint8_t *)xcb_tmp;
10827         xcb_block_len += sizeof(uint8_t);
10828         xcb_tmp += sizeof(uint8_t);
10829         xcb_align_to = ALIGNOF(uint8_t);
10830         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKTLevels */
10831         _aux->key_names.nKTLevels = *(uint16_t *)xcb_tmp;
10832         xcb_block_len += sizeof(uint16_t);
10833         xcb_tmp += sizeof(uint16_t);
10834         xcb_align_to = ALIGNOF(uint16_t);
10835         /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */
10836         _aux->key_names.pad10[0] = *(uint8_t *)xcb_tmp;
10837         _aux->key_names.pad10[1] = *(uint8_t *)xcb_tmp;
10838         _aux->key_names.pad10[2] = *(uint8_t *)xcb_tmp;
10839         _aux->key_names.pad10[3] = *(uint8_t *)xcb_tmp;
10840         xcb_block_len += sizeof(uint8_t) * 4;
10841         xcb_tmp += sizeof(uint8_t) * 4;
10842         xcb_align_to = ALIGNOF(uint8_t);
10843         /* insert padding */
10844         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10845         xcb_buffer_len += xcb_block_len + xcb_pad;
10846         if (0 != xcb_pad) {
10847             xcb_tmp += xcb_pad;
10848             xcb_pad = 0;
10849         }
10850         xcb_block_len = 0;
10851         xcb_padding_offset = 0;
10852         /* valueList */
10853         xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(xcb_tmp, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
10854         xcb_tmp += xcb_block_len;
10855         xcb_align_to = ALIGNOF(char);
10856     }
10857     if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) {
10858         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */
10859         _aux->geometry.geometry_type = *(uint8_t *)xcb_tmp;
10860         xcb_block_len += sizeof(uint8_t);
10861         xcb_tmp += sizeof(uint8_t);
10862         xcb_align_to = ALIGNOF(uint8_t);
10863         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryDeviceID */
10864         _aux->geometry.geometryDeviceID = *(uint8_t *)xcb_tmp;
10865         xcb_block_len += sizeof(uint8_t);
10866         xcb_tmp += sizeof(uint8_t);
10867         xcb_align_to = ALIGNOF(uint8_t);
10868         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_sequence */
10869         _aux->geometry.geometry_sequence = *(uint16_t *)xcb_tmp;
10870         xcb_block_len += sizeof(uint16_t);
10871         xcb_tmp += sizeof(uint16_t);
10872         xcb_align_to = ALIGNOF(uint16_t);
10873         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_length */
10874         _aux->geometry.geometry_length = *(uint32_t *)xcb_tmp;
10875         xcb_block_len += sizeof(uint32_t);
10876         xcb_tmp += sizeof(uint32_t);
10877         xcb_align_to = ALIGNOF(uint32_t);
10878         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.name */
10879         _aux->geometry.name = *(xcb_atom_t *)xcb_tmp;
10880         xcb_block_len += sizeof(xcb_atom_t);
10881         xcb_tmp += sizeof(xcb_atom_t);
10882         xcb_align_to = ALIGNOF(xcb_atom_t);
10883         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryFound */
10884         _aux->geometry.geometryFound = *(uint8_t *)xcb_tmp;
10885         xcb_block_len += sizeof(uint8_t);
10886         xcb_tmp += sizeof(uint8_t);
10887         xcb_align_to = ALIGNOF(uint8_t);
10888         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */
10889         _aux->geometry.pad12 = *(uint8_t *)xcb_tmp;
10890         xcb_block_len += sizeof(uint8_t);
10891         xcb_tmp += sizeof(uint8_t);
10892         xcb_align_to = ALIGNOF(uint8_t);
10893         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.widthMM */
10894         _aux->geometry.widthMM = *(uint16_t *)xcb_tmp;
10895         xcb_block_len += sizeof(uint16_t);
10896         xcb_tmp += sizeof(uint16_t);
10897         xcb_align_to = ALIGNOF(uint16_t);
10898         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.heightMM */
10899         _aux->geometry.heightMM = *(uint16_t *)xcb_tmp;
10900         xcb_block_len += sizeof(uint16_t);
10901         xcb_tmp += sizeof(uint16_t);
10902         xcb_align_to = ALIGNOF(uint16_t);
10903         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nProperties */
10904         _aux->geometry.nProperties = *(uint16_t *)xcb_tmp;
10905         xcb_block_len += sizeof(uint16_t);
10906         xcb_tmp += sizeof(uint16_t);
10907         xcb_align_to = ALIGNOF(uint16_t);
10908         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nColors */
10909         _aux->geometry.nColors = *(uint16_t *)xcb_tmp;
10910         xcb_block_len += sizeof(uint16_t);
10911         xcb_tmp += sizeof(uint16_t);
10912         xcb_align_to = ALIGNOF(uint16_t);
10913         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nShapes */
10914         _aux->geometry.nShapes = *(uint16_t *)xcb_tmp;
10915         xcb_block_len += sizeof(uint16_t);
10916         xcb_tmp += sizeof(uint16_t);
10917         xcb_align_to = ALIGNOF(uint16_t);
10918         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nSections */
10919         _aux->geometry.nSections = *(uint16_t *)xcb_tmp;
10920         xcb_block_len += sizeof(uint16_t);
10921         xcb_tmp += sizeof(uint16_t);
10922         xcb_align_to = ALIGNOF(uint16_t);
10923         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nDoodads */
10924         _aux->geometry.nDoodads = *(uint16_t *)xcb_tmp;
10925         xcb_block_len += sizeof(uint16_t);
10926         xcb_tmp += sizeof(uint16_t);
10927         xcb_align_to = ALIGNOF(uint16_t);
10928         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nKeyAliases */
10929         _aux->geometry.nKeyAliases = *(uint16_t *)xcb_tmp;
10930         xcb_block_len += sizeof(uint16_t);
10931         xcb_tmp += sizeof(uint16_t);
10932         xcb_align_to = ALIGNOF(uint16_t);
10933         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.baseColorNdx */
10934         _aux->geometry.baseColorNdx = *(uint8_t *)xcb_tmp;
10935         xcb_block_len += sizeof(uint8_t);
10936         xcb_tmp += sizeof(uint8_t);
10937         xcb_align_to = ALIGNOF(uint8_t);
10938         /* xcb_xkb_get_kbd_by_name_replies_t.geometry.labelColorNdx */
10939         _aux->geometry.labelColorNdx = *(uint8_t *)xcb_tmp;
10940         xcb_block_len += sizeof(uint8_t);
10941         xcb_tmp += sizeof(uint8_t);
10942         xcb_align_to = ALIGNOF(uint8_t);
10943         /* insert padding */
10944         xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10945         xcb_buffer_len += xcb_block_len + xcb_pad;
10946         if (0 != xcb_pad) {
10947             xcb_tmp += xcb_pad;
10948             xcb_pad = 0;
10949         }
10950         xcb_block_len = 0;
10951         xcb_padding_offset = 0;
10952         /* labelFont */
10953         _aux->geometry.labelFont = (xcb_xkb_counted_string_16_t *)xcb_tmp;
10954         xcb_block_len += xcb_xkb_counted_string_16_sizeof(xcb_tmp);
10955         xcb_tmp += xcb_block_len;
10956         xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_t);
10957     }
10958     /* insert padding */
10959     xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
10960     xcb_buffer_len += xcb_block_len + xcb_pad;
10961     if (0 != xcb_pad) {
10962         xcb_tmp += xcb_pad;
10963         xcb_pad = 0;
10964     }
10965     xcb_block_len = 0;
10966     xcb_padding_offset = 0;
10967 
10968     return xcb_buffer_len;
10969 }
10970 
10971 int
xcb_xkb_get_kbd_by_name_replies_sizeof(const void * _buffer,uint16_t reported)10972 xcb_xkb_get_kbd_by_name_replies_sizeof (const void  *_buffer,
10973                                         uint16_t     reported)
10974 {
10975     xcb_xkb_get_kbd_by_name_replies_t _aux;
10976     return xcb_xkb_get_kbd_by_name_replies_unpack(_buffer, reported, &_aux);
10977 }
10978 
10979 int
xcb_xkb_get_kbd_by_name_sizeof(const void * _buffer)10980 xcb_xkb_get_kbd_by_name_sizeof (const void  *_buffer)
10981 {
10982     char *xcb_tmp = (char *)_buffer;
10983     const xcb_xkb_get_kbd_by_name_reply_t *_aux = (xcb_xkb_get_kbd_by_name_reply_t *)_buffer;
10984     unsigned int xcb_buffer_len = 0;
10985     unsigned int xcb_block_len = 0;
10986     unsigned int xcb_pad = 0;
10987     unsigned int xcb_align_to = 0;
10988 
10989 
10990     xcb_block_len += sizeof(xcb_xkb_get_kbd_by_name_reply_t);
10991     xcb_tmp += xcb_block_len;
10992     xcb_buffer_len += xcb_block_len;
10993     xcb_block_len = 0;
10994     /* replies */
10995     xcb_block_len += xcb_xkb_get_kbd_by_name_replies_sizeof(xcb_tmp, _aux->reported);
10996     xcb_tmp += xcb_block_len;
10997     xcb_align_to = ALIGNOF(char);
10998     /* insert padding */
10999     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11000     xcb_buffer_len += xcb_block_len + xcb_pad;
11001     if (0 != xcb_pad) {
11002         xcb_tmp += xcb_pad;
11003         xcb_pad = 0;
11004     }
11005     xcb_block_len = 0;
11006 
11007     return xcb_buffer_len;
11008 }
11009 
11010 xcb_xkb_get_kbd_by_name_cookie_t
xcb_xkb_get_kbd_by_name(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t need,uint16_t want,uint8_t load)11011 xcb_xkb_get_kbd_by_name (xcb_connection_t      *c,
11012                          xcb_xkb_device_spec_t  deviceSpec,
11013                          uint16_t               need,
11014                          uint16_t               want,
11015                          uint8_t                load)
11016 {
11017     static const xcb_protocol_request_t xcb_req = {
11018         .count = 2,
11019         .ext = &xcb_xkb_id,
11020         .opcode = XCB_XKB_GET_KBD_BY_NAME,
11021         .isvoid = 0
11022     };
11023 
11024     struct iovec xcb_parts[4];
11025     xcb_xkb_get_kbd_by_name_cookie_t xcb_ret;
11026     xcb_xkb_get_kbd_by_name_request_t xcb_out;
11027 
11028     xcb_out.deviceSpec = deviceSpec;
11029     xcb_out.need = need;
11030     xcb_out.want = want;
11031     xcb_out.load = load;
11032     xcb_out.pad0 = 0;
11033 
11034     xcb_parts[2].iov_base = (char *) &xcb_out;
11035     xcb_parts[2].iov_len = sizeof(xcb_out);
11036     xcb_parts[3].iov_base = 0;
11037     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11038 
11039     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11040     return xcb_ret;
11041 }
11042 
11043 xcb_xkb_get_kbd_by_name_cookie_t
xcb_xkb_get_kbd_by_name_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t need,uint16_t want,uint8_t load)11044 xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t      *c,
11045                                    xcb_xkb_device_spec_t  deviceSpec,
11046                                    uint16_t               need,
11047                                    uint16_t               want,
11048                                    uint8_t                load)
11049 {
11050     static const xcb_protocol_request_t xcb_req = {
11051         .count = 2,
11052         .ext = &xcb_xkb_id,
11053         .opcode = XCB_XKB_GET_KBD_BY_NAME,
11054         .isvoid = 0
11055     };
11056 
11057     struct iovec xcb_parts[4];
11058     xcb_xkb_get_kbd_by_name_cookie_t xcb_ret;
11059     xcb_xkb_get_kbd_by_name_request_t xcb_out;
11060 
11061     xcb_out.deviceSpec = deviceSpec;
11062     xcb_out.need = need;
11063     xcb_out.want = want;
11064     xcb_out.load = load;
11065     xcb_out.pad0 = 0;
11066 
11067     xcb_parts[2].iov_base = (char *) &xcb_out;
11068     xcb_parts[2].iov_len = sizeof(xcb_out);
11069     xcb_parts[3].iov_base = 0;
11070     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11071 
11072     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11073     return xcb_ret;
11074 }
11075 
11076 void *
xcb_xkb_get_kbd_by_name_replies(const xcb_xkb_get_kbd_by_name_reply_t * R)11077 xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R)
11078 {
11079     return (void *) (R + 1);
11080 }
11081 
11082 xcb_xkb_get_kbd_by_name_reply_t *
xcb_xkb_get_kbd_by_name_reply(xcb_connection_t * c,xcb_xkb_get_kbd_by_name_cookie_t cookie,xcb_generic_error_t ** e)11083 xcb_xkb_get_kbd_by_name_reply (xcb_connection_t                  *c,
11084                                xcb_xkb_get_kbd_by_name_cookie_t   cookie  /**< */,
11085                                xcb_generic_error_t              **e)
11086 {
11087     return (xcb_xkb_get_kbd_by_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11088 }
11089 
11090 int
xcb_xkb_get_device_info_sizeof(const void * _buffer)11091 xcb_xkb_get_device_info_sizeof (const void  *_buffer)
11092 {
11093     char *xcb_tmp = (char *)_buffer;
11094     const xcb_xkb_get_device_info_reply_t *_aux = (xcb_xkb_get_device_info_reply_t *)_buffer;
11095     unsigned int xcb_buffer_len = 0;
11096     unsigned int xcb_block_len = 0;
11097     unsigned int xcb_pad = 0;
11098     unsigned int xcb_align_to = 0;
11099 
11100     unsigned int i;
11101     unsigned int xcb_tmp_len;
11102 
11103     xcb_block_len += sizeof(xcb_xkb_get_device_info_reply_t);
11104     xcb_tmp += xcb_block_len;
11105     xcb_buffer_len += xcb_block_len;
11106     xcb_block_len = 0;
11107     /* name */
11108     xcb_block_len += _aux->nameLen * sizeof(xcb_xkb_string8_t);
11109     xcb_tmp += xcb_block_len;
11110     xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
11111     xcb_align_to = 4;
11112     /* insert padding */
11113     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11114     xcb_buffer_len += xcb_block_len + xcb_pad;
11115     if (0 != xcb_pad) {
11116         xcb_tmp += xcb_pad;
11117         xcb_pad = 0;
11118     }
11119     xcb_block_len = 0;
11120     /* insert padding */
11121     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11122     xcb_buffer_len += xcb_block_len + xcb_pad;
11123     if (0 != xcb_pad) {
11124         xcb_tmp += xcb_pad;
11125         xcb_pad = 0;
11126     }
11127     xcb_block_len = 0;
11128     /* btnActions */
11129     xcb_block_len += _aux->nBtnsRtrn * sizeof(xcb_xkb_action_t);
11130     xcb_tmp += xcb_block_len;
11131     xcb_align_to = ALIGNOF(xcb_xkb_action_t);
11132     /* insert padding */
11133     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11134     xcb_buffer_len += xcb_block_len + xcb_pad;
11135     if (0 != xcb_pad) {
11136         xcb_tmp += xcb_pad;
11137         xcb_pad = 0;
11138     }
11139     xcb_block_len = 0;
11140     /* leds */
11141     for(i=0; i<_aux->nDeviceLedFBs; i++) {
11142         xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
11143         xcb_block_len += xcb_tmp_len;
11144         xcb_tmp += xcb_tmp_len;
11145     }
11146     xcb_align_to = ALIGNOF(xcb_xkb_device_led_info_t);
11147     /* insert padding */
11148     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11149     xcb_buffer_len += xcb_block_len + xcb_pad;
11150     if (0 != xcb_pad) {
11151         xcb_tmp += xcb_pad;
11152         xcb_pad = 0;
11153     }
11154     xcb_block_len = 0;
11155 
11156     return xcb_buffer_len;
11157 }
11158 
11159 xcb_xkb_get_device_info_cookie_t
xcb_xkb_get_device_info(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t wanted,uint8_t allButtons,uint8_t firstButton,uint8_t nButtons,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID)11160 xcb_xkb_get_device_info (xcb_connection_t         *c,
11161                          xcb_xkb_device_spec_t     deviceSpec,
11162                          uint16_t                  wanted,
11163                          uint8_t                   allButtons,
11164                          uint8_t                   firstButton,
11165                          uint8_t                   nButtons,
11166                          xcb_xkb_led_class_spec_t  ledClass,
11167                          xcb_xkb_id_spec_t         ledID)
11168 {
11169     static const xcb_protocol_request_t xcb_req = {
11170         .count = 2,
11171         .ext = &xcb_xkb_id,
11172         .opcode = XCB_XKB_GET_DEVICE_INFO,
11173         .isvoid = 0
11174     };
11175 
11176     struct iovec xcb_parts[4];
11177     xcb_xkb_get_device_info_cookie_t xcb_ret;
11178     xcb_xkb_get_device_info_request_t xcb_out;
11179 
11180     xcb_out.deviceSpec = deviceSpec;
11181     xcb_out.wanted = wanted;
11182     xcb_out.allButtons = allButtons;
11183     xcb_out.firstButton = firstButton;
11184     xcb_out.nButtons = nButtons;
11185     xcb_out.pad0 = 0;
11186     xcb_out.ledClass = ledClass;
11187     xcb_out.ledID = ledID;
11188 
11189     xcb_parts[2].iov_base = (char *) &xcb_out;
11190     xcb_parts[2].iov_len = sizeof(xcb_out);
11191     xcb_parts[3].iov_base = 0;
11192     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11193 
11194     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11195     return xcb_ret;
11196 }
11197 
11198 xcb_xkb_get_device_info_cookie_t
xcb_xkb_get_device_info_unchecked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint16_t wanted,uint8_t allButtons,uint8_t firstButton,uint8_t nButtons,xcb_xkb_led_class_spec_t ledClass,xcb_xkb_id_spec_t ledID)11199 xcb_xkb_get_device_info_unchecked (xcb_connection_t         *c,
11200                                    xcb_xkb_device_spec_t     deviceSpec,
11201                                    uint16_t                  wanted,
11202                                    uint8_t                   allButtons,
11203                                    uint8_t                   firstButton,
11204                                    uint8_t                   nButtons,
11205                                    xcb_xkb_led_class_spec_t  ledClass,
11206                                    xcb_xkb_id_spec_t         ledID)
11207 {
11208     static const xcb_protocol_request_t xcb_req = {
11209         .count = 2,
11210         .ext = &xcb_xkb_id,
11211         .opcode = XCB_XKB_GET_DEVICE_INFO,
11212         .isvoid = 0
11213     };
11214 
11215     struct iovec xcb_parts[4];
11216     xcb_xkb_get_device_info_cookie_t xcb_ret;
11217     xcb_xkb_get_device_info_request_t xcb_out;
11218 
11219     xcb_out.deviceSpec = deviceSpec;
11220     xcb_out.wanted = wanted;
11221     xcb_out.allButtons = allButtons;
11222     xcb_out.firstButton = firstButton;
11223     xcb_out.nButtons = nButtons;
11224     xcb_out.pad0 = 0;
11225     xcb_out.ledClass = ledClass;
11226     xcb_out.ledID = ledID;
11227 
11228     xcb_parts[2].iov_base = (char *) &xcb_out;
11229     xcb_parts[2].iov_len = sizeof(xcb_out);
11230     xcb_parts[3].iov_base = 0;
11231     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11232 
11233     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11234     return xcb_ret;
11235 }
11236 
11237 xcb_xkb_string8_t *
xcb_xkb_get_device_info_name(const xcb_xkb_get_device_info_reply_t * R)11238 xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R)
11239 {
11240     return (xcb_xkb_string8_t *) (R + 1);
11241 }
11242 
11243 int
xcb_xkb_get_device_info_name_length(const xcb_xkb_get_device_info_reply_t * R)11244 xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R)
11245 {
11246     return R->nameLen;
11247 }
11248 
11249 xcb_generic_iterator_t
xcb_xkb_get_device_info_name_end(const xcb_xkb_get_device_info_reply_t * R)11250 xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R)
11251 {
11252     xcb_generic_iterator_t i;
11253     i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->nameLen);
11254     i.rem = 0;
11255     i.index = (char *) i.data - (char *) R;
11256     return i;
11257 }
11258 
11259 xcb_xkb_action_t *
xcb_xkb_get_device_info_btn_actions(const xcb_xkb_get_device_info_reply_t * R)11260 xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R)
11261 {
11262     xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R);
11263     return (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
11264 }
11265 
11266 int
xcb_xkb_get_device_info_btn_actions_length(const xcb_xkb_get_device_info_reply_t * R)11267 xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R)
11268 {
11269     return R->nBtnsRtrn;
11270 }
11271 
11272 xcb_xkb_action_iterator_t
xcb_xkb_get_device_info_btn_actions_iterator(const xcb_xkb_get_device_info_reply_t * R)11273 xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R)
11274 {
11275     xcb_xkb_action_iterator_t i;
11276     xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R);
11277     i.data = (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
11278     i.rem = R->nBtnsRtrn;
11279     i.index = (char *) i.data - (char *) R;
11280     return i;
11281 }
11282 
11283 int
xcb_xkb_get_device_info_leds_length(const xcb_xkb_get_device_info_reply_t * R)11284 xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R)
11285 {
11286     return R->nDeviceLedFBs;
11287 }
11288 
11289 xcb_xkb_device_led_info_iterator_t
xcb_xkb_get_device_info_leds_iterator(const xcb_xkb_get_device_info_reply_t * R)11290 xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R)
11291 {
11292     xcb_xkb_device_led_info_iterator_t i;
11293     xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_get_device_info_btn_actions_iterator(R));
11294     i.data = (xcb_xkb_device_led_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_device_led_info_t, prev.index));
11295     i.rem = R->nDeviceLedFBs;
11296     i.index = (char *) i.data - (char *) R;
11297     return i;
11298 }
11299 
11300 xcb_xkb_get_device_info_reply_t *
xcb_xkb_get_device_info_reply(xcb_connection_t * c,xcb_xkb_get_device_info_cookie_t cookie,xcb_generic_error_t ** e)11301 xcb_xkb_get_device_info_reply (xcb_connection_t                  *c,
11302                                xcb_xkb_get_device_info_cookie_t   cookie  /**< */,
11303                                xcb_generic_error_t              **e)
11304 {
11305     return (xcb_xkb_get_device_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11306 }
11307 
11308 int
xcb_xkb_set_device_info_sizeof(const void * _buffer)11309 xcb_xkb_set_device_info_sizeof (const void  *_buffer)
11310 {
11311     char *xcb_tmp = (char *)_buffer;
11312     const xcb_xkb_set_device_info_request_t *_aux = (xcb_xkb_set_device_info_request_t *)_buffer;
11313     unsigned int xcb_buffer_len = 0;
11314     unsigned int xcb_block_len = 0;
11315     unsigned int xcb_pad = 0;
11316     unsigned int xcb_align_to = 0;
11317 
11318     unsigned int i;
11319     unsigned int xcb_tmp_len;
11320 
11321     xcb_block_len += sizeof(xcb_xkb_set_device_info_request_t);
11322     xcb_tmp += xcb_block_len;
11323     xcb_buffer_len += xcb_block_len;
11324     xcb_block_len = 0;
11325     /* btnActions */
11326     xcb_block_len += _aux->nBtns * sizeof(xcb_xkb_action_t);
11327     xcb_tmp += xcb_block_len;
11328     xcb_align_to = ALIGNOF(xcb_xkb_action_t);
11329     /* insert padding */
11330     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11331     xcb_buffer_len += xcb_block_len + xcb_pad;
11332     if (0 != xcb_pad) {
11333         xcb_tmp += xcb_pad;
11334         xcb_pad = 0;
11335     }
11336     xcb_block_len = 0;
11337     /* leds */
11338     for(i=0; i<_aux->nDeviceLedFBs; i++) {
11339         xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
11340         xcb_block_len += xcb_tmp_len;
11341         xcb_tmp += xcb_tmp_len;
11342     }
11343     xcb_align_to = ALIGNOF(xcb_xkb_device_led_info_t);
11344     /* insert padding */
11345     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11346     xcb_buffer_len += xcb_block_len + xcb_pad;
11347     if (0 != xcb_pad) {
11348         xcb_tmp += xcb_pad;
11349         xcb_pad = 0;
11350     }
11351     xcb_block_len = 0;
11352 
11353     return xcb_buffer_len;
11354 }
11355 
11356 xcb_void_cookie_t
xcb_xkb_set_device_info_checked(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t firstBtn,uint8_t nBtns,uint16_t change,uint16_t nDeviceLedFBs,const xcb_xkb_action_t * btnActions,const xcb_xkb_device_led_info_t * leds)11357 xcb_xkb_set_device_info_checked (xcb_connection_t                *c,
11358                                  xcb_xkb_device_spec_t            deviceSpec,
11359                                  uint8_t                          firstBtn,
11360                                  uint8_t                          nBtns,
11361                                  uint16_t                         change,
11362                                  uint16_t                         nDeviceLedFBs,
11363                                  const xcb_xkb_action_t          *btnActions,
11364                                  const xcb_xkb_device_led_info_t *leds)
11365 {
11366     static const xcb_protocol_request_t xcb_req = {
11367         .count = 6,
11368         .ext = &xcb_xkb_id,
11369         .opcode = XCB_XKB_SET_DEVICE_INFO,
11370         .isvoid = 1
11371     };
11372 
11373     struct iovec xcb_parts[8];
11374     xcb_void_cookie_t xcb_ret;
11375     xcb_xkb_set_device_info_request_t xcb_out;
11376     unsigned int xcb_tmp_len;
11377     char *xcb_tmp;
11378     unsigned int i;
11379 
11380     xcb_out.deviceSpec = deviceSpec;
11381     xcb_out.firstBtn = firstBtn;
11382     xcb_out.nBtns = nBtns;
11383     xcb_out.change = change;
11384     xcb_out.nDeviceLedFBs = nDeviceLedFBs;
11385 
11386     xcb_parts[2].iov_base = (char *) &xcb_out;
11387     xcb_parts[2].iov_len = sizeof(xcb_out);
11388     xcb_parts[3].iov_base = 0;
11389     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11390     /* xcb_xkb_action_t btnActions */
11391     xcb_parts[4].iov_base = (char *) btnActions;
11392     xcb_parts[4].iov_len = nBtns * sizeof(xcb_xkb_action_t);
11393     xcb_parts[5].iov_base = 0;
11394     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11395     /* xcb_xkb_device_led_info_t leds */
11396     xcb_parts[6].iov_base = (char *) leds;
11397     xcb_parts[6].iov_len = 0;
11398     xcb_tmp = (char *)leds;
11399     for(i=0; i<nDeviceLedFBs; i++) {
11400         xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
11401         xcb_parts[6].iov_len += xcb_tmp_len;
11402         xcb_tmp += xcb_tmp_len;
11403     }
11404     xcb_parts[7].iov_base = 0;
11405     xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
11406 
11407     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11408     return xcb_ret;
11409 }
11410 
11411 xcb_void_cookie_t
xcb_xkb_set_device_info(xcb_connection_t * c,xcb_xkb_device_spec_t deviceSpec,uint8_t firstBtn,uint8_t nBtns,uint16_t change,uint16_t nDeviceLedFBs,const xcb_xkb_action_t * btnActions,const xcb_xkb_device_led_info_t * leds)11412 xcb_xkb_set_device_info (xcb_connection_t                *c,
11413                          xcb_xkb_device_spec_t            deviceSpec,
11414                          uint8_t                          firstBtn,
11415                          uint8_t                          nBtns,
11416                          uint16_t                         change,
11417                          uint16_t                         nDeviceLedFBs,
11418                          const xcb_xkb_action_t          *btnActions,
11419                          const xcb_xkb_device_led_info_t *leds)
11420 {
11421     static const xcb_protocol_request_t xcb_req = {
11422         .count = 6,
11423         .ext = &xcb_xkb_id,
11424         .opcode = XCB_XKB_SET_DEVICE_INFO,
11425         .isvoid = 1
11426     };
11427 
11428     struct iovec xcb_parts[8];
11429     xcb_void_cookie_t xcb_ret;
11430     xcb_xkb_set_device_info_request_t xcb_out;
11431     unsigned int xcb_tmp_len;
11432     char *xcb_tmp;
11433     unsigned int i;
11434 
11435     xcb_out.deviceSpec = deviceSpec;
11436     xcb_out.firstBtn = firstBtn;
11437     xcb_out.nBtns = nBtns;
11438     xcb_out.change = change;
11439     xcb_out.nDeviceLedFBs = nDeviceLedFBs;
11440 
11441     xcb_parts[2].iov_base = (char *) &xcb_out;
11442     xcb_parts[2].iov_len = sizeof(xcb_out);
11443     xcb_parts[3].iov_base = 0;
11444     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11445     /* xcb_xkb_action_t btnActions */
11446     xcb_parts[4].iov_base = (char *) btnActions;
11447     xcb_parts[4].iov_len = nBtns * sizeof(xcb_xkb_action_t);
11448     xcb_parts[5].iov_base = 0;
11449     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11450     /* xcb_xkb_device_led_info_t leds */
11451     xcb_parts[6].iov_base = (char *) leds;
11452     xcb_parts[6].iov_len = 0;
11453     xcb_tmp = (char *)leds;
11454     for(i=0; i<nDeviceLedFBs; i++) {
11455         xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
11456         xcb_parts[6].iov_len += xcb_tmp_len;
11457         xcb_tmp += xcb_tmp_len;
11458     }
11459     xcb_parts[7].iov_base = 0;
11460     xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
11461 
11462     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11463     return xcb_ret;
11464 }
11465 
11466 xcb_xkb_action_t *
xcb_xkb_set_device_info_btn_actions(const xcb_xkb_set_device_info_request_t * R)11467 xcb_xkb_set_device_info_btn_actions (const xcb_xkb_set_device_info_request_t *R)
11468 {
11469     return (xcb_xkb_action_t *) (R + 1);
11470 }
11471 
11472 int
xcb_xkb_set_device_info_btn_actions_length(const xcb_xkb_set_device_info_request_t * R)11473 xcb_xkb_set_device_info_btn_actions_length (const xcb_xkb_set_device_info_request_t *R)
11474 {
11475     return R->nBtns;
11476 }
11477 
11478 xcb_xkb_action_iterator_t
xcb_xkb_set_device_info_btn_actions_iterator(const xcb_xkb_set_device_info_request_t * R)11479 xcb_xkb_set_device_info_btn_actions_iterator (const xcb_xkb_set_device_info_request_t *R)
11480 {
11481     xcb_xkb_action_iterator_t i;
11482     i.data = (xcb_xkb_action_t *) (R + 1);
11483     i.rem = R->nBtns;
11484     i.index = (char *) i.data - (char *) R;
11485     return i;
11486 }
11487 
11488 int
xcb_xkb_set_device_info_leds_length(const xcb_xkb_set_device_info_request_t * R)11489 xcb_xkb_set_device_info_leds_length (const xcb_xkb_set_device_info_request_t *R)
11490 {
11491     return R->nDeviceLedFBs;
11492 }
11493 
11494 xcb_xkb_device_led_info_iterator_t
xcb_xkb_set_device_info_leds_iterator(const xcb_xkb_set_device_info_request_t * R)11495 xcb_xkb_set_device_info_leds_iterator (const xcb_xkb_set_device_info_request_t *R)
11496 {
11497     xcb_xkb_device_led_info_iterator_t i;
11498     xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_set_device_info_btn_actions_iterator(R));
11499     i.data = (xcb_xkb_device_led_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_device_led_info_t, prev.index));
11500     i.rem = R->nDeviceLedFBs;
11501     i.index = (char *) i.data - (char *) R;
11502     return i;
11503 }
11504 
11505 int
xcb_xkb_set_debugging_flags_sizeof(const void * _buffer)11506 xcb_xkb_set_debugging_flags_sizeof (const void  *_buffer)
11507 {
11508     char *xcb_tmp = (char *)_buffer;
11509     const xcb_xkb_set_debugging_flags_request_t *_aux = (xcb_xkb_set_debugging_flags_request_t *)_buffer;
11510     unsigned int xcb_buffer_len = 0;
11511     unsigned int xcb_block_len = 0;
11512     unsigned int xcb_pad = 0;
11513     unsigned int xcb_align_to = 0;
11514 
11515 
11516     xcb_block_len += sizeof(xcb_xkb_set_debugging_flags_request_t);
11517     xcb_tmp += xcb_block_len;
11518     xcb_buffer_len += xcb_block_len;
11519     xcb_block_len = 0;
11520     /* message */
11521     xcb_block_len += _aux->msgLength * sizeof(xcb_xkb_string8_t);
11522     xcb_tmp += xcb_block_len;
11523     xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
11524     /* insert padding */
11525     xcb_pad = -xcb_block_len & (xcb_align_to - 1);
11526     xcb_buffer_len += xcb_block_len + xcb_pad;
11527     if (0 != xcb_pad) {
11528         xcb_tmp += xcb_pad;
11529         xcb_pad = 0;
11530     }
11531     xcb_block_len = 0;
11532 
11533     return xcb_buffer_len;
11534 }
11535 
11536 xcb_xkb_set_debugging_flags_cookie_t
xcb_xkb_set_debugging_flags(xcb_connection_t * c,uint16_t msgLength,uint32_t affectFlags,uint32_t flags,uint32_t affectCtrls,uint32_t ctrls,const xcb_xkb_string8_t * message)11537 xcb_xkb_set_debugging_flags (xcb_connection_t        *c,
11538                              uint16_t                 msgLength,
11539                              uint32_t                 affectFlags,
11540                              uint32_t                 flags,
11541                              uint32_t                 affectCtrls,
11542                              uint32_t                 ctrls,
11543                              const xcb_xkb_string8_t *message)
11544 {
11545     static const xcb_protocol_request_t xcb_req = {
11546         .count = 4,
11547         .ext = &xcb_xkb_id,
11548         .opcode = XCB_XKB_SET_DEBUGGING_FLAGS,
11549         .isvoid = 0
11550     };
11551 
11552     struct iovec xcb_parts[6];
11553     xcb_xkb_set_debugging_flags_cookie_t xcb_ret;
11554     xcb_xkb_set_debugging_flags_request_t xcb_out;
11555 
11556     xcb_out.msgLength = msgLength;
11557     memset(xcb_out.pad0, 0, 2);
11558     xcb_out.affectFlags = affectFlags;
11559     xcb_out.flags = flags;
11560     xcb_out.affectCtrls = affectCtrls;
11561     xcb_out.ctrls = ctrls;
11562 
11563     xcb_parts[2].iov_base = (char *) &xcb_out;
11564     xcb_parts[2].iov_len = sizeof(xcb_out);
11565     xcb_parts[3].iov_base = 0;
11566     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11567     /* xcb_xkb_string8_t message */
11568     xcb_parts[4].iov_base = (char *) message;
11569     xcb_parts[4].iov_len = msgLength * sizeof(xcb_xkb_string8_t);
11570     xcb_parts[5].iov_base = 0;
11571     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11572 
11573     xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
11574     return xcb_ret;
11575 }
11576 
11577 xcb_xkb_set_debugging_flags_cookie_t
xcb_xkb_set_debugging_flags_unchecked(xcb_connection_t * c,uint16_t msgLength,uint32_t affectFlags,uint32_t flags,uint32_t affectCtrls,uint32_t ctrls,const xcb_xkb_string8_t * message)11578 xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t        *c,
11579                                        uint16_t                 msgLength,
11580                                        uint32_t                 affectFlags,
11581                                        uint32_t                 flags,
11582                                        uint32_t                 affectCtrls,
11583                                        uint32_t                 ctrls,
11584                                        const xcb_xkb_string8_t *message)
11585 {
11586     static const xcb_protocol_request_t xcb_req = {
11587         .count = 4,
11588         .ext = &xcb_xkb_id,
11589         .opcode = XCB_XKB_SET_DEBUGGING_FLAGS,
11590         .isvoid = 0
11591     };
11592 
11593     struct iovec xcb_parts[6];
11594     xcb_xkb_set_debugging_flags_cookie_t xcb_ret;
11595     xcb_xkb_set_debugging_flags_request_t xcb_out;
11596 
11597     xcb_out.msgLength = msgLength;
11598     memset(xcb_out.pad0, 0, 2);
11599     xcb_out.affectFlags = affectFlags;
11600     xcb_out.flags = flags;
11601     xcb_out.affectCtrls = affectCtrls;
11602     xcb_out.ctrls = ctrls;
11603 
11604     xcb_parts[2].iov_base = (char *) &xcb_out;
11605     xcb_parts[2].iov_len = sizeof(xcb_out);
11606     xcb_parts[3].iov_base = 0;
11607     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
11608     /* xcb_xkb_string8_t message */
11609     xcb_parts[4].iov_base = (char *) message;
11610     xcb_parts[4].iov_len = msgLength * sizeof(xcb_xkb_string8_t);
11611     xcb_parts[5].iov_base = 0;
11612     xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
11613 
11614     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
11615     return xcb_ret;
11616 }
11617 
11618 xcb_xkb_set_debugging_flags_reply_t *
xcb_xkb_set_debugging_flags_reply(xcb_connection_t * c,xcb_xkb_set_debugging_flags_cookie_t cookie,xcb_generic_error_t ** e)11619 xcb_xkb_set_debugging_flags_reply (xcb_connection_t                      *c,
11620                                    xcb_xkb_set_debugging_flags_cookie_t   cookie  /**< */,
11621                                    xcb_generic_error_t                  **e)
11622 {
11623     return (xcb_xkb_set_debugging_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
11624 }
11625 
11626