1 /*
2 * This file generated automatically from sync.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 "sync.h"
15
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 #include "xproto.h"
18
19 xcb_extension_t xcb_sync_id = { "SYNC", 0 };
20
21 void
xcb_sync_alarm_next(xcb_sync_alarm_iterator_t * i)22 xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i)
23 {
24 --i->rem;
25 ++i->data;
26 i->index += sizeof(xcb_sync_alarm_t);
27 }
28
29 xcb_generic_iterator_t
xcb_sync_alarm_end(xcb_sync_alarm_iterator_t i)30 xcb_sync_alarm_end (xcb_sync_alarm_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_sync_counter_next(xcb_sync_counter_iterator_t * i)40 xcb_sync_counter_next (xcb_sync_counter_iterator_t *i)
41 {
42 --i->rem;
43 ++i->data;
44 i->index += sizeof(xcb_sync_counter_t);
45 }
46
47 xcb_generic_iterator_t
xcb_sync_counter_end(xcb_sync_counter_iterator_t i)48 xcb_sync_counter_end (xcb_sync_counter_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_sync_fence_next(xcb_sync_fence_iterator_t * i)58 xcb_sync_fence_next (xcb_sync_fence_iterator_t *i)
59 {
60 --i->rem;
61 ++i->data;
62 i->index += sizeof(xcb_sync_fence_t);
63 }
64
65 xcb_generic_iterator_t
xcb_sync_fence_end(xcb_sync_fence_iterator_t i)66 xcb_sync_fence_end (xcb_sync_fence_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_sync_int64_next(xcb_sync_int64_iterator_t * i)76 xcb_sync_int64_next (xcb_sync_int64_iterator_t *i)
77 {
78 --i->rem;
79 ++i->data;
80 i->index += sizeof(xcb_sync_int64_t);
81 }
82
83 xcb_generic_iterator_t
xcb_sync_int64_end(xcb_sync_int64_iterator_t i)84 xcb_sync_int64_end (xcb_sync_int64_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 int
xcb_sync_systemcounter_sizeof(const void * _buffer)94 xcb_sync_systemcounter_sizeof (const void *_buffer)
95 {
96 char *xcb_tmp = (char *)_buffer;
97 const xcb_sync_systemcounter_t *_aux = (xcb_sync_systemcounter_t *)_buffer;
98 unsigned int xcb_buffer_len = 0;
99 unsigned int xcb_block_len = 0;
100 unsigned int xcb_pad = 0;
101 unsigned int xcb_align_to = 0;
102
103
104 xcb_block_len += sizeof(xcb_sync_systemcounter_t);
105 xcb_tmp += xcb_block_len;
106 xcb_buffer_len += xcb_block_len;
107 xcb_block_len = 0;
108 /* name */
109 xcb_block_len += _aux->name_len * sizeof(char);
110 xcb_tmp += xcb_block_len;
111 xcb_align_to = ALIGNOF(char);
112 xcb_align_to = 4;
113 /* insert padding */
114 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
115 xcb_buffer_len += xcb_block_len + xcb_pad;
116 if (0 != xcb_pad) {
117 xcb_tmp += xcb_pad;
118 xcb_pad = 0;
119 }
120 xcb_block_len = 0;
121 /* insert padding */
122 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
123 xcb_buffer_len += xcb_block_len + xcb_pad;
124 if (0 != xcb_pad) {
125 xcb_tmp += xcb_pad;
126 xcb_pad = 0;
127 }
128 xcb_block_len = 0;
129
130 return xcb_buffer_len;
131 }
132
133 char *
xcb_sync_systemcounter_name(const xcb_sync_systemcounter_t * R)134 xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R)
135 {
136 return (char *) (R + 1);
137 }
138
139 int
xcb_sync_systemcounter_name_length(const xcb_sync_systemcounter_t * R)140 xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R)
141 {
142 return R->name_len;
143 }
144
145 xcb_generic_iterator_t
xcb_sync_systemcounter_name_end(const xcb_sync_systemcounter_t * R)146 xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R)
147 {
148 xcb_generic_iterator_t i;
149 i.data = ((char *) (R + 1)) + (R->name_len);
150 i.rem = 0;
151 i.index = (char *) i.data - (char *) R;
152 return i;
153 }
154
155 void
xcb_sync_systemcounter_next(xcb_sync_systemcounter_iterator_t * i)156 xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i)
157 {
158 xcb_sync_systemcounter_t *R = i->data;
159 xcb_generic_iterator_t child;
160 child.data = (xcb_sync_systemcounter_t *)(((char *)R) + xcb_sync_systemcounter_sizeof(R));
161 i->index = (char *) child.data - (char *) i->data;
162 --i->rem;
163 i->data = (xcb_sync_systemcounter_t *) child.data;
164 }
165
166 xcb_generic_iterator_t
xcb_sync_systemcounter_end(xcb_sync_systemcounter_iterator_t i)167 xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i)
168 {
169 xcb_generic_iterator_t ret;
170 while(i.rem > 0)
171 xcb_sync_systemcounter_next(&i);
172 ret.data = i.data;
173 ret.rem = i.rem;
174 ret.index = i.index;
175 return ret;
176 }
177
178 void
xcb_sync_trigger_next(xcb_sync_trigger_iterator_t * i)179 xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i)
180 {
181 --i->rem;
182 ++i->data;
183 i->index += sizeof(xcb_sync_trigger_t);
184 }
185
186 xcb_generic_iterator_t
xcb_sync_trigger_end(xcb_sync_trigger_iterator_t i)187 xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i)
188 {
189 xcb_generic_iterator_t ret;
190 ret.data = i.data + i.rem;
191 ret.index = i.index + ((char *) ret.data - (char *) i.data);
192 ret.rem = 0;
193 return ret;
194 }
195
196 void
xcb_sync_waitcondition_next(xcb_sync_waitcondition_iterator_t * i)197 xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i)
198 {
199 --i->rem;
200 ++i->data;
201 i->index += sizeof(xcb_sync_waitcondition_t);
202 }
203
204 xcb_generic_iterator_t
xcb_sync_waitcondition_end(xcb_sync_waitcondition_iterator_t i)205 xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i)
206 {
207 xcb_generic_iterator_t ret;
208 ret.data = i.data + i.rem;
209 ret.index = i.index + ((char *) ret.data - (char *) i.data);
210 ret.rem = 0;
211 return ret;
212 }
213
214 xcb_sync_initialize_cookie_t
xcb_sync_initialize(xcb_connection_t * c,uint8_t desired_major_version,uint8_t desired_minor_version)215 xcb_sync_initialize (xcb_connection_t *c,
216 uint8_t desired_major_version,
217 uint8_t desired_minor_version)
218 {
219 static const xcb_protocol_request_t xcb_req = {
220 .count = 2,
221 .ext = &xcb_sync_id,
222 .opcode = XCB_SYNC_INITIALIZE,
223 .isvoid = 0
224 };
225
226 struct iovec xcb_parts[4];
227 xcb_sync_initialize_cookie_t xcb_ret;
228 xcb_sync_initialize_request_t xcb_out;
229
230 xcb_out.desired_major_version = desired_major_version;
231 xcb_out.desired_minor_version = desired_minor_version;
232
233 xcb_parts[2].iov_base = (char *) &xcb_out;
234 xcb_parts[2].iov_len = sizeof(xcb_out);
235 xcb_parts[3].iov_base = 0;
236 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
237
238 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
239 return xcb_ret;
240 }
241
242 xcb_sync_initialize_cookie_t
xcb_sync_initialize_unchecked(xcb_connection_t * c,uint8_t desired_major_version,uint8_t desired_minor_version)243 xcb_sync_initialize_unchecked (xcb_connection_t *c,
244 uint8_t desired_major_version,
245 uint8_t desired_minor_version)
246 {
247 static const xcb_protocol_request_t xcb_req = {
248 .count = 2,
249 .ext = &xcb_sync_id,
250 .opcode = XCB_SYNC_INITIALIZE,
251 .isvoid = 0
252 };
253
254 struct iovec xcb_parts[4];
255 xcb_sync_initialize_cookie_t xcb_ret;
256 xcb_sync_initialize_request_t xcb_out;
257
258 xcb_out.desired_major_version = desired_major_version;
259 xcb_out.desired_minor_version = desired_minor_version;
260
261 xcb_parts[2].iov_base = (char *) &xcb_out;
262 xcb_parts[2].iov_len = sizeof(xcb_out);
263 xcb_parts[3].iov_base = 0;
264 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
265
266 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
267 return xcb_ret;
268 }
269
270 xcb_sync_initialize_reply_t *
xcb_sync_initialize_reply(xcb_connection_t * c,xcb_sync_initialize_cookie_t cookie,xcb_generic_error_t ** e)271 xcb_sync_initialize_reply (xcb_connection_t *c,
272 xcb_sync_initialize_cookie_t cookie /**< */,
273 xcb_generic_error_t **e)
274 {
275 return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
276 }
277
278 int
xcb_sync_list_system_counters_sizeof(const void * _buffer)279 xcb_sync_list_system_counters_sizeof (const void *_buffer)
280 {
281 char *xcb_tmp = (char *)_buffer;
282 const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer;
283 unsigned int xcb_buffer_len = 0;
284 unsigned int xcb_block_len = 0;
285 unsigned int xcb_pad = 0;
286 unsigned int xcb_align_to = 0;
287
288 unsigned int i;
289 unsigned int xcb_tmp_len;
290
291 xcb_block_len += sizeof(xcb_sync_list_system_counters_reply_t);
292 xcb_tmp += xcb_block_len;
293 xcb_buffer_len += xcb_block_len;
294 xcb_block_len = 0;
295 /* counters */
296 for(i=0; i<_aux->counters_len; i++) {
297 xcb_tmp_len = xcb_sync_systemcounter_sizeof(xcb_tmp);
298 xcb_block_len += xcb_tmp_len;
299 xcb_tmp += xcb_tmp_len;
300 }
301 xcb_align_to = ALIGNOF(xcb_sync_systemcounter_t);
302 /* insert padding */
303 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
304 xcb_buffer_len += xcb_block_len + xcb_pad;
305 if (0 != xcb_pad) {
306 xcb_tmp += xcb_pad;
307 xcb_pad = 0;
308 }
309 xcb_block_len = 0;
310
311 return xcb_buffer_len;
312 }
313
314 xcb_sync_list_system_counters_cookie_t
xcb_sync_list_system_counters(xcb_connection_t * c)315 xcb_sync_list_system_counters (xcb_connection_t *c)
316 {
317 static const xcb_protocol_request_t xcb_req = {
318 .count = 2,
319 .ext = &xcb_sync_id,
320 .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS,
321 .isvoid = 0
322 };
323
324 struct iovec xcb_parts[4];
325 xcb_sync_list_system_counters_cookie_t xcb_ret;
326 xcb_sync_list_system_counters_request_t xcb_out;
327
328
329 xcb_parts[2].iov_base = (char *) &xcb_out;
330 xcb_parts[2].iov_len = sizeof(xcb_out);
331 xcb_parts[3].iov_base = 0;
332 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
333
334 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
335 return xcb_ret;
336 }
337
338 xcb_sync_list_system_counters_cookie_t
xcb_sync_list_system_counters_unchecked(xcb_connection_t * c)339 xcb_sync_list_system_counters_unchecked (xcb_connection_t *c)
340 {
341 static const xcb_protocol_request_t xcb_req = {
342 .count = 2,
343 .ext = &xcb_sync_id,
344 .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS,
345 .isvoid = 0
346 };
347
348 struct iovec xcb_parts[4];
349 xcb_sync_list_system_counters_cookie_t xcb_ret;
350 xcb_sync_list_system_counters_request_t xcb_out;
351
352
353 xcb_parts[2].iov_base = (char *) &xcb_out;
354 xcb_parts[2].iov_len = sizeof(xcb_out);
355 xcb_parts[3].iov_base = 0;
356 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
357
358 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
359 return xcb_ret;
360 }
361
362 int
xcb_sync_list_system_counters_counters_length(const xcb_sync_list_system_counters_reply_t * R)363 xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R)
364 {
365 return R->counters_len;
366 }
367
368 xcb_sync_systemcounter_iterator_t
xcb_sync_list_system_counters_counters_iterator(const xcb_sync_list_system_counters_reply_t * R)369 xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R)
370 {
371 xcb_sync_systemcounter_iterator_t i;
372 i.data = (xcb_sync_systemcounter_t *) (R + 1);
373 i.rem = R->counters_len;
374 i.index = (char *) i.data - (char *) R;
375 return i;
376 }
377
378 xcb_sync_list_system_counters_reply_t *
xcb_sync_list_system_counters_reply(xcb_connection_t * c,xcb_sync_list_system_counters_cookie_t cookie,xcb_generic_error_t ** e)379 xcb_sync_list_system_counters_reply (xcb_connection_t *c,
380 xcb_sync_list_system_counters_cookie_t cookie /**< */,
381 xcb_generic_error_t **e)
382 {
383 return (xcb_sync_list_system_counters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
384 }
385
386 xcb_void_cookie_t
xcb_sync_create_counter_checked(xcb_connection_t * c,xcb_sync_counter_t id,xcb_sync_int64_t initial_value)387 xcb_sync_create_counter_checked (xcb_connection_t *c,
388 xcb_sync_counter_t id,
389 xcb_sync_int64_t initial_value)
390 {
391 static const xcb_protocol_request_t xcb_req = {
392 .count = 2,
393 .ext = &xcb_sync_id,
394 .opcode = XCB_SYNC_CREATE_COUNTER,
395 .isvoid = 1
396 };
397
398 struct iovec xcb_parts[4];
399 xcb_void_cookie_t xcb_ret;
400 xcb_sync_create_counter_request_t xcb_out;
401
402 xcb_out.id = id;
403 xcb_out.initial_value = initial_value;
404
405 xcb_parts[2].iov_base = (char *) &xcb_out;
406 xcb_parts[2].iov_len = sizeof(xcb_out);
407 xcb_parts[3].iov_base = 0;
408 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
409
410 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
411 return xcb_ret;
412 }
413
414 xcb_void_cookie_t
xcb_sync_create_counter(xcb_connection_t * c,xcb_sync_counter_t id,xcb_sync_int64_t initial_value)415 xcb_sync_create_counter (xcb_connection_t *c,
416 xcb_sync_counter_t id,
417 xcb_sync_int64_t initial_value)
418 {
419 static const xcb_protocol_request_t xcb_req = {
420 .count = 2,
421 .ext = &xcb_sync_id,
422 .opcode = XCB_SYNC_CREATE_COUNTER,
423 .isvoid = 1
424 };
425
426 struct iovec xcb_parts[4];
427 xcb_void_cookie_t xcb_ret;
428 xcb_sync_create_counter_request_t xcb_out;
429
430 xcb_out.id = id;
431 xcb_out.initial_value = initial_value;
432
433 xcb_parts[2].iov_base = (char *) &xcb_out;
434 xcb_parts[2].iov_len = sizeof(xcb_out);
435 xcb_parts[3].iov_base = 0;
436 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
437
438 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
439 return xcb_ret;
440 }
441
442 xcb_void_cookie_t
xcb_sync_destroy_counter_checked(xcb_connection_t * c,xcb_sync_counter_t counter)443 xcb_sync_destroy_counter_checked (xcb_connection_t *c,
444 xcb_sync_counter_t counter)
445 {
446 static const xcb_protocol_request_t xcb_req = {
447 .count = 2,
448 .ext = &xcb_sync_id,
449 .opcode = XCB_SYNC_DESTROY_COUNTER,
450 .isvoid = 1
451 };
452
453 struct iovec xcb_parts[4];
454 xcb_void_cookie_t xcb_ret;
455 xcb_sync_destroy_counter_request_t xcb_out;
456
457 xcb_out.counter = counter;
458
459 xcb_parts[2].iov_base = (char *) &xcb_out;
460 xcb_parts[2].iov_len = sizeof(xcb_out);
461 xcb_parts[3].iov_base = 0;
462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
463
464 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
465 return xcb_ret;
466 }
467
468 xcb_void_cookie_t
xcb_sync_destroy_counter(xcb_connection_t * c,xcb_sync_counter_t counter)469 xcb_sync_destroy_counter (xcb_connection_t *c,
470 xcb_sync_counter_t counter)
471 {
472 static const xcb_protocol_request_t xcb_req = {
473 .count = 2,
474 .ext = &xcb_sync_id,
475 .opcode = XCB_SYNC_DESTROY_COUNTER,
476 .isvoid = 1
477 };
478
479 struct iovec xcb_parts[4];
480 xcb_void_cookie_t xcb_ret;
481 xcb_sync_destroy_counter_request_t xcb_out;
482
483 xcb_out.counter = counter;
484
485 xcb_parts[2].iov_base = (char *) &xcb_out;
486 xcb_parts[2].iov_len = sizeof(xcb_out);
487 xcb_parts[3].iov_base = 0;
488 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
489
490 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
491 return xcb_ret;
492 }
493
494 xcb_sync_query_counter_cookie_t
xcb_sync_query_counter(xcb_connection_t * c,xcb_sync_counter_t counter)495 xcb_sync_query_counter (xcb_connection_t *c,
496 xcb_sync_counter_t counter)
497 {
498 static const xcb_protocol_request_t xcb_req = {
499 .count = 2,
500 .ext = &xcb_sync_id,
501 .opcode = XCB_SYNC_QUERY_COUNTER,
502 .isvoid = 0
503 };
504
505 struct iovec xcb_parts[4];
506 xcb_sync_query_counter_cookie_t xcb_ret;
507 xcb_sync_query_counter_request_t xcb_out;
508
509 xcb_out.counter = counter;
510
511 xcb_parts[2].iov_base = (char *) &xcb_out;
512 xcb_parts[2].iov_len = sizeof(xcb_out);
513 xcb_parts[3].iov_base = 0;
514 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
515
516 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
517 return xcb_ret;
518 }
519
520 xcb_sync_query_counter_cookie_t
xcb_sync_query_counter_unchecked(xcb_connection_t * c,xcb_sync_counter_t counter)521 xcb_sync_query_counter_unchecked (xcb_connection_t *c,
522 xcb_sync_counter_t counter)
523 {
524 static const xcb_protocol_request_t xcb_req = {
525 .count = 2,
526 .ext = &xcb_sync_id,
527 .opcode = XCB_SYNC_QUERY_COUNTER,
528 .isvoid = 0
529 };
530
531 struct iovec xcb_parts[4];
532 xcb_sync_query_counter_cookie_t xcb_ret;
533 xcb_sync_query_counter_request_t xcb_out;
534
535 xcb_out.counter = counter;
536
537 xcb_parts[2].iov_base = (char *) &xcb_out;
538 xcb_parts[2].iov_len = sizeof(xcb_out);
539 xcb_parts[3].iov_base = 0;
540 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
541
542 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
543 return xcb_ret;
544 }
545
546 xcb_sync_query_counter_reply_t *
xcb_sync_query_counter_reply(xcb_connection_t * c,xcb_sync_query_counter_cookie_t cookie,xcb_generic_error_t ** e)547 xcb_sync_query_counter_reply (xcb_connection_t *c,
548 xcb_sync_query_counter_cookie_t cookie /**< */,
549 xcb_generic_error_t **e)
550 {
551 return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
552 }
553
554 int
xcb_sync_await_sizeof(const void * _buffer,uint32_t wait_list_len)555 xcb_sync_await_sizeof (const void *_buffer,
556 uint32_t wait_list_len)
557 {
558 char *xcb_tmp = (char *)_buffer;
559 unsigned int xcb_buffer_len = 0;
560 unsigned int xcb_block_len = 0;
561 unsigned int xcb_pad = 0;
562 unsigned int xcb_align_to = 0;
563
564
565 xcb_block_len += sizeof(xcb_sync_await_request_t);
566 xcb_tmp += xcb_block_len;
567 xcb_buffer_len += xcb_block_len;
568 xcb_block_len = 0;
569 /* wait_list */
570 xcb_block_len += wait_list_len * sizeof(xcb_sync_waitcondition_t);
571 xcb_tmp += xcb_block_len;
572 xcb_align_to = ALIGNOF(xcb_sync_waitcondition_t);
573 /* insert padding */
574 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
575 xcb_buffer_len += xcb_block_len + xcb_pad;
576 if (0 != xcb_pad) {
577 xcb_tmp += xcb_pad;
578 xcb_pad = 0;
579 }
580 xcb_block_len = 0;
581
582 return xcb_buffer_len;
583 }
584
585 xcb_void_cookie_t
xcb_sync_await_checked(xcb_connection_t * c,uint32_t wait_list_len,const xcb_sync_waitcondition_t * wait_list)586 xcb_sync_await_checked (xcb_connection_t *c,
587 uint32_t wait_list_len,
588 const xcb_sync_waitcondition_t *wait_list)
589 {
590 static const xcb_protocol_request_t xcb_req = {
591 .count = 4,
592 .ext = &xcb_sync_id,
593 .opcode = XCB_SYNC_AWAIT,
594 .isvoid = 1
595 };
596
597 struct iovec xcb_parts[6];
598 xcb_void_cookie_t xcb_ret;
599 xcb_sync_await_request_t xcb_out;
600
601
602 xcb_parts[2].iov_base = (char *) &xcb_out;
603 xcb_parts[2].iov_len = sizeof(xcb_out);
604 xcb_parts[3].iov_base = 0;
605 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
606 /* xcb_sync_waitcondition_t wait_list */
607 xcb_parts[4].iov_base = (char *) wait_list;
608 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t);
609 xcb_parts[5].iov_base = 0;
610 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
611
612 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
613 return xcb_ret;
614 }
615
616 xcb_void_cookie_t
xcb_sync_await(xcb_connection_t * c,uint32_t wait_list_len,const xcb_sync_waitcondition_t * wait_list)617 xcb_sync_await (xcb_connection_t *c,
618 uint32_t wait_list_len,
619 const xcb_sync_waitcondition_t *wait_list)
620 {
621 static const xcb_protocol_request_t xcb_req = {
622 .count = 4,
623 .ext = &xcb_sync_id,
624 .opcode = XCB_SYNC_AWAIT,
625 .isvoid = 1
626 };
627
628 struct iovec xcb_parts[6];
629 xcb_void_cookie_t xcb_ret;
630 xcb_sync_await_request_t xcb_out;
631
632
633 xcb_parts[2].iov_base = (char *) &xcb_out;
634 xcb_parts[2].iov_len = sizeof(xcb_out);
635 xcb_parts[3].iov_base = 0;
636 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
637 /* xcb_sync_waitcondition_t wait_list */
638 xcb_parts[4].iov_base = (char *) wait_list;
639 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t);
640 xcb_parts[5].iov_base = 0;
641 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
642
643 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
644 return xcb_ret;
645 }
646
647 xcb_sync_waitcondition_t *
xcb_sync_await_wait_list(const xcb_sync_await_request_t * R)648 xcb_sync_await_wait_list (const xcb_sync_await_request_t *R)
649 {
650 return (xcb_sync_waitcondition_t *) (R + 1);
651 }
652
653 int
xcb_sync_await_wait_list_length(const xcb_sync_await_request_t * R)654 xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R)
655 {
656 return (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t));
657 }
658
659 xcb_sync_waitcondition_iterator_t
xcb_sync_await_wait_list_iterator(const xcb_sync_await_request_t * R)660 xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R)
661 {
662 xcb_sync_waitcondition_iterator_t i;
663 i.data = (xcb_sync_waitcondition_t *) (R + 1);
664 i.rem = (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t));
665 i.index = (char *) i.data - (char *) R;
666 return i;
667 }
668
669 xcb_void_cookie_t
xcb_sync_change_counter_checked(xcb_connection_t * c,xcb_sync_counter_t counter,xcb_sync_int64_t amount)670 xcb_sync_change_counter_checked (xcb_connection_t *c,
671 xcb_sync_counter_t counter,
672 xcb_sync_int64_t amount)
673 {
674 static const xcb_protocol_request_t xcb_req = {
675 .count = 2,
676 .ext = &xcb_sync_id,
677 .opcode = XCB_SYNC_CHANGE_COUNTER,
678 .isvoid = 1
679 };
680
681 struct iovec xcb_parts[4];
682 xcb_void_cookie_t xcb_ret;
683 xcb_sync_change_counter_request_t xcb_out;
684
685 xcb_out.counter = counter;
686 xcb_out.amount = amount;
687
688 xcb_parts[2].iov_base = (char *) &xcb_out;
689 xcb_parts[2].iov_len = sizeof(xcb_out);
690 xcb_parts[3].iov_base = 0;
691 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
692
693 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
694 return xcb_ret;
695 }
696
697 xcb_void_cookie_t
xcb_sync_change_counter(xcb_connection_t * c,xcb_sync_counter_t counter,xcb_sync_int64_t amount)698 xcb_sync_change_counter (xcb_connection_t *c,
699 xcb_sync_counter_t counter,
700 xcb_sync_int64_t amount)
701 {
702 static const xcb_protocol_request_t xcb_req = {
703 .count = 2,
704 .ext = &xcb_sync_id,
705 .opcode = XCB_SYNC_CHANGE_COUNTER,
706 .isvoid = 1
707 };
708
709 struct iovec xcb_parts[4];
710 xcb_void_cookie_t xcb_ret;
711 xcb_sync_change_counter_request_t xcb_out;
712
713 xcb_out.counter = counter;
714 xcb_out.amount = amount;
715
716 xcb_parts[2].iov_base = (char *) &xcb_out;
717 xcb_parts[2].iov_len = sizeof(xcb_out);
718 xcb_parts[3].iov_base = 0;
719 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
720
721 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
722 return xcb_ret;
723 }
724
725 xcb_void_cookie_t
xcb_sync_set_counter_checked(xcb_connection_t * c,xcb_sync_counter_t counter,xcb_sync_int64_t value)726 xcb_sync_set_counter_checked (xcb_connection_t *c,
727 xcb_sync_counter_t counter,
728 xcb_sync_int64_t value)
729 {
730 static const xcb_protocol_request_t xcb_req = {
731 .count = 2,
732 .ext = &xcb_sync_id,
733 .opcode = XCB_SYNC_SET_COUNTER,
734 .isvoid = 1
735 };
736
737 struct iovec xcb_parts[4];
738 xcb_void_cookie_t xcb_ret;
739 xcb_sync_set_counter_request_t xcb_out;
740
741 xcb_out.counter = counter;
742 xcb_out.value = value;
743
744 xcb_parts[2].iov_base = (char *) &xcb_out;
745 xcb_parts[2].iov_len = sizeof(xcb_out);
746 xcb_parts[3].iov_base = 0;
747 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
748
749 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
750 return xcb_ret;
751 }
752
753 xcb_void_cookie_t
xcb_sync_set_counter(xcb_connection_t * c,xcb_sync_counter_t counter,xcb_sync_int64_t value)754 xcb_sync_set_counter (xcb_connection_t *c,
755 xcb_sync_counter_t counter,
756 xcb_sync_int64_t value)
757 {
758 static const xcb_protocol_request_t xcb_req = {
759 .count = 2,
760 .ext = &xcb_sync_id,
761 .opcode = XCB_SYNC_SET_COUNTER,
762 .isvoid = 1
763 };
764
765 struct iovec xcb_parts[4];
766 xcb_void_cookie_t xcb_ret;
767 xcb_sync_set_counter_request_t xcb_out;
768
769 xcb_out.counter = counter;
770 xcb_out.value = value;
771
772 xcb_parts[2].iov_base = (char *) &xcb_out;
773 xcb_parts[2].iov_len = sizeof(xcb_out);
774 xcb_parts[3].iov_base = 0;
775 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
776
777 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
778 return xcb_ret;
779 }
780
781 int
xcb_sync_create_alarm_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_sync_create_alarm_value_list_t * _aux)782 xcb_sync_create_alarm_value_list_serialize (void **_buffer,
783 uint32_t value_mask,
784 const xcb_sync_create_alarm_value_list_t *_aux)
785 {
786 char *xcb_out = *_buffer;
787 unsigned int xcb_buffer_len = 0;
788 unsigned int xcb_align_to = 0;
789 unsigned int xcb_padding_offset = 0;
790
791 unsigned int xcb_pad = 0;
792 char xcb_pad0[3] = {0, 0, 0};
793 struct iovec xcb_parts[7];
794 unsigned int xcb_parts_idx = 0;
795 unsigned int xcb_block_len = 0;
796 unsigned int i;
797 char *xcb_tmp;
798
799 if(value_mask & XCB_SYNC_CA_COUNTER) {
800 /* xcb_sync_create_alarm_value_list_t.counter */
801 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter;
802 xcb_block_len += sizeof(xcb_sync_counter_t);
803 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t);
804 xcb_parts_idx++;
805 xcb_align_to = ALIGNOF(xcb_sync_counter_t);
806 }
807 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
808 /* xcb_sync_create_alarm_value_list_t.valueType */
809 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType;
810 xcb_block_len += sizeof(uint32_t);
811 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
812 xcb_parts_idx++;
813 xcb_align_to = ALIGNOF(uint32_t);
814 }
815 if(value_mask & XCB_SYNC_CA_VALUE) {
816 /* xcb_sync_create_alarm_value_list_t.value */
817 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value;
818 xcb_block_len += sizeof(xcb_sync_int64_t);
819 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
820 xcb_parts_idx++;
821 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
822 }
823 if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
824 /* xcb_sync_create_alarm_value_list_t.testType */
825 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType;
826 xcb_block_len += sizeof(uint32_t);
827 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
828 xcb_parts_idx++;
829 xcb_align_to = ALIGNOF(uint32_t);
830 }
831 if(value_mask & XCB_SYNC_CA_DELTA) {
832 /* xcb_sync_create_alarm_value_list_t.delta */
833 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta;
834 xcb_block_len += sizeof(xcb_sync_int64_t);
835 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
836 xcb_parts_idx++;
837 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
838 }
839 if(value_mask & XCB_SYNC_CA_EVENTS) {
840 /* xcb_sync_create_alarm_value_list_t.events */
841 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events;
842 xcb_block_len += sizeof(uint32_t);
843 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
844 xcb_parts_idx++;
845 xcb_align_to = ALIGNOF(uint32_t);
846 }
847 /* insert padding */
848 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
849 xcb_buffer_len += xcb_block_len + xcb_pad;
850 if (0 != xcb_pad) {
851 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
852 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
853 xcb_parts_idx++;
854 xcb_pad = 0;
855 }
856 xcb_block_len = 0;
857 xcb_padding_offset = 0;
858
859 if (NULL == xcb_out) {
860 /* allocate memory */
861 xcb_out = malloc(xcb_buffer_len);
862 *_buffer = xcb_out;
863 }
864
865 xcb_tmp = xcb_out;
866 for(i=0; i<xcb_parts_idx; i++) {
867 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
868 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
869 if (0 != xcb_parts[i].iov_len)
870 xcb_tmp += xcb_parts[i].iov_len;
871 }
872
873 return xcb_buffer_len;
874 }
875
876 int
xcb_sync_create_alarm_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_sync_create_alarm_value_list_t * _aux)877 xcb_sync_create_alarm_value_list_unpack (const void *_buffer,
878 uint32_t value_mask,
879 xcb_sync_create_alarm_value_list_t *_aux)
880 {
881 char *xcb_tmp = (char *)_buffer;
882 unsigned int xcb_buffer_len = 0;
883 unsigned int xcb_block_len = 0;
884 unsigned int xcb_pad = 0;
885 unsigned int xcb_align_to = 0;
886 unsigned int xcb_padding_offset = 0;
887
888
889 if(value_mask & XCB_SYNC_CA_COUNTER) {
890 /* xcb_sync_create_alarm_value_list_t.counter */
891 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp;
892 xcb_block_len += sizeof(xcb_sync_counter_t);
893 xcb_tmp += sizeof(xcb_sync_counter_t);
894 xcb_align_to = ALIGNOF(xcb_sync_counter_t);
895 }
896 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
897 /* xcb_sync_create_alarm_value_list_t.valueType */
898 _aux->valueType = *(uint32_t *)xcb_tmp;
899 xcb_block_len += sizeof(uint32_t);
900 xcb_tmp += sizeof(uint32_t);
901 xcb_align_to = ALIGNOF(uint32_t);
902 }
903 if(value_mask & XCB_SYNC_CA_VALUE) {
904 /* xcb_sync_create_alarm_value_list_t.value */
905 _aux->value = *(xcb_sync_int64_t *)xcb_tmp;
906 xcb_block_len += sizeof(xcb_sync_int64_t);
907 xcb_tmp += sizeof(xcb_sync_int64_t);
908 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
909 }
910 if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
911 /* xcb_sync_create_alarm_value_list_t.testType */
912 _aux->testType = *(uint32_t *)xcb_tmp;
913 xcb_block_len += sizeof(uint32_t);
914 xcb_tmp += sizeof(uint32_t);
915 xcb_align_to = ALIGNOF(uint32_t);
916 }
917 if(value_mask & XCB_SYNC_CA_DELTA) {
918 /* xcb_sync_create_alarm_value_list_t.delta */
919 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp;
920 xcb_block_len += sizeof(xcb_sync_int64_t);
921 xcb_tmp += sizeof(xcb_sync_int64_t);
922 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
923 }
924 if(value_mask & XCB_SYNC_CA_EVENTS) {
925 /* xcb_sync_create_alarm_value_list_t.events */
926 _aux->events = *(uint32_t *)xcb_tmp;
927 xcb_block_len += sizeof(uint32_t);
928 xcb_tmp += sizeof(uint32_t);
929 xcb_align_to = ALIGNOF(uint32_t);
930 }
931 /* insert padding */
932 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
933 xcb_buffer_len += xcb_block_len + xcb_pad;
934 if (0 != xcb_pad) {
935 xcb_tmp += xcb_pad;
936 xcb_pad = 0;
937 }
938 xcb_block_len = 0;
939 xcb_padding_offset = 0;
940
941 return xcb_buffer_len;
942 }
943
944 int
xcb_sync_create_alarm_value_list_sizeof(const void * _buffer,uint32_t value_mask)945 xcb_sync_create_alarm_value_list_sizeof (const void *_buffer,
946 uint32_t value_mask)
947 {
948 xcb_sync_create_alarm_value_list_t _aux;
949 return xcb_sync_create_alarm_value_list_unpack(_buffer, value_mask, &_aux);
950 }
951
952 int
xcb_sync_create_alarm_sizeof(const void * _buffer)953 xcb_sync_create_alarm_sizeof (const void *_buffer)
954 {
955 char *xcb_tmp = (char *)_buffer;
956 const xcb_sync_create_alarm_request_t *_aux = (xcb_sync_create_alarm_request_t *)_buffer;
957 unsigned int xcb_buffer_len = 0;
958 unsigned int xcb_block_len = 0;
959 unsigned int xcb_pad = 0;
960 unsigned int xcb_align_to = 0;
961
962
963 xcb_block_len += sizeof(xcb_sync_create_alarm_request_t);
964 xcb_tmp += xcb_block_len;
965 xcb_buffer_len += xcb_block_len;
966 xcb_block_len = 0;
967 /* value_list */
968 xcb_block_len += xcb_sync_create_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask);
969 xcb_tmp += xcb_block_len;
970 xcb_align_to = ALIGNOF(char);
971 /* insert padding */
972 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
973 xcb_buffer_len += xcb_block_len + xcb_pad;
974 if (0 != xcb_pad) {
975 xcb_tmp += xcb_pad;
976 xcb_pad = 0;
977 }
978 xcb_block_len = 0;
979
980 return xcb_buffer_len;
981 }
982
983 xcb_void_cookie_t
xcb_sync_create_alarm_checked(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const void * value_list)984 xcb_sync_create_alarm_checked (xcb_connection_t *c,
985 xcb_sync_alarm_t id,
986 uint32_t value_mask,
987 const void *value_list)
988 {
989 static const xcb_protocol_request_t xcb_req = {
990 .count = 3,
991 .ext = &xcb_sync_id,
992 .opcode = XCB_SYNC_CREATE_ALARM,
993 .isvoid = 1
994 };
995
996 struct iovec xcb_parts[5];
997 xcb_void_cookie_t xcb_ret;
998 xcb_sync_create_alarm_request_t xcb_out;
999
1000 xcb_out.id = id;
1001 xcb_out.value_mask = value_mask;
1002
1003 xcb_parts[2].iov_base = (char *) &xcb_out;
1004 xcb_parts[2].iov_len = sizeof(xcb_out);
1005 xcb_parts[3].iov_base = 0;
1006 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1007 /* xcb_sync_create_alarm_value_list_t value_list */
1008 xcb_parts[4].iov_base = (char *) value_list;
1009 xcb_parts[4].iov_len =
1010 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask);
1011
1012 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1013 return xcb_ret;
1014 }
1015
1016 xcb_void_cookie_t
xcb_sync_create_alarm(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const void * value_list)1017 xcb_sync_create_alarm (xcb_connection_t *c,
1018 xcb_sync_alarm_t id,
1019 uint32_t value_mask,
1020 const void *value_list)
1021 {
1022 static const xcb_protocol_request_t xcb_req = {
1023 .count = 3,
1024 .ext = &xcb_sync_id,
1025 .opcode = XCB_SYNC_CREATE_ALARM,
1026 .isvoid = 1
1027 };
1028
1029 struct iovec xcb_parts[5];
1030 xcb_void_cookie_t xcb_ret;
1031 xcb_sync_create_alarm_request_t xcb_out;
1032
1033 xcb_out.id = id;
1034 xcb_out.value_mask = value_mask;
1035
1036 xcb_parts[2].iov_base = (char *) &xcb_out;
1037 xcb_parts[2].iov_len = sizeof(xcb_out);
1038 xcb_parts[3].iov_base = 0;
1039 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1040 /* xcb_sync_create_alarm_value_list_t value_list */
1041 xcb_parts[4].iov_base = (char *) value_list;
1042 xcb_parts[4].iov_len =
1043 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask);
1044
1045 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1046 return xcb_ret;
1047 }
1048
1049 xcb_void_cookie_t
xcb_sync_create_alarm_aux_checked(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const xcb_sync_create_alarm_value_list_t * value_list)1050 xcb_sync_create_alarm_aux_checked (xcb_connection_t *c,
1051 xcb_sync_alarm_t id,
1052 uint32_t value_mask,
1053 const xcb_sync_create_alarm_value_list_t *value_list)
1054 {
1055 static const xcb_protocol_request_t xcb_req = {
1056 .count = 3,
1057 .ext = &xcb_sync_id,
1058 .opcode = XCB_SYNC_CREATE_ALARM,
1059 .isvoid = 1
1060 };
1061
1062 struct iovec xcb_parts[5];
1063 xcb_void_cookie_t xcb_ret;
1064 xcb_sync_create_alarm_request_t xcb_out;
1065 void *xcb_aux0 = 0;
1066
1067 xcb_out.id = id;
1068 xcb_out.value_mask = value_mask;
1069
1070 xcb_parts[2].iov_base = (char *) &xcb_out;
1071 xcb_parts[2].iov_len = sizeof(xcb_out);
1072 xcb_parts[3].iov_base = 0;
1073 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1074 /* xcb_sync_create_alarm_value_list_t value_list */
1075 xcb_parts[4].iov_len =
1076 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
1077 xcb_parts[4].iov_base = xcb_aux0;
1078
1079 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1080 free(xcb_aux0);
1081 return xcb_ret;
1082 }
1083
1084 xcb_void_cookie_t
xcb_sync_create_alarm_aux(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const xcb_sync_create_alarm_value_list_t * value_list)1085 xcb_sync_create_alarm_aux (xcb_connection_t *c,
1086 xcb_sync_alarm_t id,
1087 uint32_t value_mask,
1088 const xcb_sync_create_alarm_value_list_t *value_list)
1089 {
1090 static const xcb_protocol_request_t xcb_req = {
1091 .count = 3,
1092 .ext = &xcb_sync_id,
1093 .opcode = XCB_SYNC_CREATE_ALARM,
1094 .isvoid = 1
1095 };
1096
1097 struct iovec xcb_parts[5];
1098 xcb_void_cookie_t xcb_ret;
1099 xcb_sync_create_alarm_request_t xcb_out;
1100 void *xcb_aux0 = 0;
1101
1102 xcb_out.id = id;
1103 xcb_out.value_mask = value_mask;
1104
1105 xcb_parts[2].iov_base = (char *) &xcb_out;
1106 xcb_parts[2].iov_len = sizeof(xcb_out);
1107 xcb_parts[3].iov_base = 0;
1108 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1109 /* xcb_sync_create_alarm_value_list_t value_list */
1110 xcb_parts[4].iov_len =
1111 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
1112 xcb_parts[4].iov_base = xcb_aux0;
1113
1114 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1115 free(xcb_aux0);
1116 return xcb_ret;
1117 }
1118
1119 void *
xcb_sync_create_alarm_value_list(const xcb_sync_create_alarm_request_t * R)1120 xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R)
1121 {
1122 return (void *) (R + 1);
1123 }
1124
1125 int
xcb_sync_change_alarm_value_list_serialize(void ** _buffer,uint32_t value_mask,const xcb_sync_change_alarm_value_list_t * _aux)1126 xcb_sync_change_alarm_value_list_serialize (void **_buffer,
1127 uint32_t value_mask,
1128 const xcb_sync_change_alarm_value_list_t *_aux)
1129 {
1130 char *xcb_out = *_buffer;
1131 unsigned int xcb_buffer_len = 0;
1132 unsigned int xcb_align_to = 0;
1133 unsigned int xcb_padding_offset = 0;
1134
1135 unsigned int xcb_pad = 0;
1136 char xcb_pad0[3] = {0, 0, 0};
1137 struct iovec xcb_parts[7];
1138 unsigned int xcb_parts_idx = 0;
1139 unsigned int xcb_block_len = 0;
1140 unsigned int i;
1141 char *xcb_tmp;
1142
1143 if(value_mask & XCB_SYNC_CA_COUNTER) {
1144 /* xcb_sync_change_alarm_value_list_t.counter */
1145 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter;
1146 xcb_block_len += sizeof(xcb_sync_counter_t);
1147 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t);
1148 xcb_parts_idx++;
1149 xcb_align_to = ALIGNOF(xcb_sync_counter_t);
1150 }
1151 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
1152 /* xcb_sync_change_alarm_value_list_t.valueType */
1153 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType;
1154 xcb_block_len += sizeof(uint32_t);
1155 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1156 xcb_parts_idx++;
1157 xcb_align_to = ALIGNOF(uint32_t);
1158 }
1159 if(value_mask & XCB_SYNC_CA_VALUE) {
1160 /* xcb_sync_change_alarm_value_list_t.value */
1161 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value;
1162 xcb_block_len += sizeof(xcb_sync_int64_t);
1163 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
1164 xcb_parts_idx++;
1165 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
1166 }
1167 if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
1168 /* xcb_sync_change_alarm_value_list_t.testType */
1169 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType;
1170 xcb_block_len += sizeof(uint32_t);
1171 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1172 xcb_parts_idx++;
1173 xcb_align_to = ALIGNOF(uint32_t);
1174 }
1175 if(value_mask & XCB_SYNC_CA_DELTA) {
1176 /* xcb_sync_change_alarm_value_list_t.delta */
1177 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta;
1178 xcb_block_len += sizeof(xcb_sync_int64_t);
1179 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
1180 xcb_parts_idx++;
1181 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
1182 }
1183 if(value_mask & XCB_SYNC_CA_EVENTS) {
1184 /* xcb_sync_change_alarm_value_list_t.events */
1185 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events;
1186 xcb_block_len += sizeof(uint32_t);
1187 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
1188 xcb_parts_idx++;
1189 xcb_align_to = ALIGNOF(uint32_t);
1190 }
1191 /* insert padding */
1192 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1193 xcb_buffer_len += xcb_block_len + xcb_pad;
1194 if (0 != xcb_pad) {
1195 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
1196 xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
1197 xcb_parts_idx++;
1198 xcb_pad = 0;
1199 }
1200 xcb_block_len = 0;
1201 xcb_padding_offset = 0;
1202
1203 if (NULL == xcb_out) {
1204 /* allocate memory */
1205 xcb_out = malloc(xcb_buffer_len);
1206 *_buffer = xcb_out;
1207 }
1208
1209 xcb_tmp = xcb_out;
1210 for(i=0; i<xcb_parts_idx; i++) {
1211 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
1212 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
1213 if (0 != xcb_parts[i].iov_len)
1214 xcb_tmp += xcb_parts[i].iov_len;
1215 }
1216
1217 return xcb_buffer_len;
1218 }
1219
1220 int
xcb_sync_change_alarm_value_list_unpack(const void * _buffer,uint32_t value_mask,xcb_sync_change_alarm_value_list_t * _aux)1221 xcb_sync_change_alarm_value_list_unpack (const void *_buffer,
1222 uint32_t value_mask,
1223 xcb_sync_change_alarm_value_list_t *_aux)
1224 {
1225 char *xcb_tmp = (char *)_buffer;
1226 unsigned int xcb_buffer_len = 0;
1227 unsigned int xcb_block_len = 0;
1228 unsigned int xcb_pad = 0;
1229 unsigned int xcb_align_to = 0;
1230 unsigned int xcb_padding_offset = 0;
1231
1232
1233 if(value_mask & XCB_SYNC_CA_COUNTER) {
1234 /* xcb_sync_change_alarm_value_list_t.counter */
1235 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp;
1236 xcb_block_len += sizeof(xcb_sync_counter_t);
1237 xcb_tmp += sizeof(xcb_sync_counter_t);
1238 xcb_align_to = ALIGNOF(xcb_sync_counter_t);
1239 }
1240 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
1241 /* xcb_sync_change_alarm_value_list_t.valueType */
1242 _aux->valueType = *(uint32_t *)xcb_tmp;
1243 xcb_block_len += sizeof(uint32_t);
1244 xcb_tmp += sizeof(uint32_t);
1245 xcb_align_to = ALIGNOF(uint32_t);
1246 }
1247 if(value_mask & XCB_SYNC_CA_VALUE) {
1248 /* xcb_sync_change_alarm_value_list_t.value */
1249 _aux->value = *(xcb_sync_int64_t *)xcb_tmp;
1250 xcb_block_len += sizeof(xcb_sync_int64_t);
1251 xcb_tmp += sizeof(xcb_sync_int64_t);
1252 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
1253 }
1254 if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
1255 /* xcb_sync_change_alarm_value_list_t.testType */
1256 _aux->testType = *(uint32_t *)xcb_tmp;
1257 xcb_block_len += sizeof(uint32_t);
1258 xcb_tmp += sizeof(uint32_t);
1259 xcb_align_to = ALIGNOF(uint32_t);
1260 }
1261 if(value_mask & XCB_SYNC_CA_DELTA) {
1262 /* xcb_sync_change_alarm_value_list_t.delta */
1263 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp;
1264 xcb_block_len += sizeof(xcb_sync_int64_t);
1265 xcb_tmp += sizeof(xcb_sync_int64_t);
1266 xcb_align_to = ALIGNOF(xcb_sync_int64_t);
1267 }
1268 if(value_mask & XCB_SYNC_CA_EVENTS) {
1269 /* xcb_sync_change_alarm_value_list_t.events */
1270 _aux->events = *(uint32_t *)xcb_tmp;
1271 xcb_block_len += sizeof(uint32_t);
1272 xcb_tmp += sizeof(uint32_t);
1273 xcb_align_to = ALIGNOF(uint32_t);
1274 }
1275 /* insert padding */
1276 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
1277 xcb_buffer_len += xcb_block_len + xcb_pad;
1278 if (0 != xcb_pad) {
1279 xcb_tmp += xcb_pad;
1280 xcb_pad = 0;
1281 }
1282 xcb_block_len = 0;
1283 xcb_padding_offset = 0;
1284
1285 return xcb_buffer_len;
1286 }
1287
1288 int
xcb_sync_change_alarm_value_list_sizeof(const void * _buffer,uint32_t value_mask)1289 xcb_sync_change_alarm_value_list_sizeof (const void *_buffer,
1290 uint32_t value_mask)
1291 {
1292 xcb_sync_change_alarm_value_list_t _aux;
1293 return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux);
1294 }
1295
1296 int
xcb_sync_change_alarm_sizeof(const void * _buffer)1297 xcb_sync_change_alarm_sizeof (const void *_buffer)
1298 {
1299 char *xcb_tmp = (char *)_buffer;
1300 const xcb_sync_change_alarm_request_t *_aux = (xcb_sync_change_alarm_request_t *)_buffer;
1301 unsigned int xcb_buffer_len = 0;
1302 unsigned int xcb_block_len = 0;
1303 unsigned int xcb_pad = 0;
1304 unsigned int xcb_align_to = 0;
1305
1306
1307 xcb_block_len += sizeof(xcb_sync_change_alarm_request_t);
1308 xcb_tmp += xcb_block_len;
1309 xcb_buffer_len += xcb_block_len;
1310 xcb_block_len = 0;
1311 /* value_list */
1312 xcb_block_len += xcb_sync_change_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask);
1313 xcb_tmp += xcb_block_len;
1314 xcb_align_to = ALIGNOF(char);
1315 /* insert padding */
1316 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1317 xcb_buffer_len += xcb_block_len + xcb_pad;
1318 if (0 != xcb_pad) {
1319 xcb_tmp += xcb_pad;
1320 xcb_pad = 0;
1321 }
1322 xcb_block_len = 0;
1323
1324 return xcb_buffer_len;
1325 }
1326
1327 xcb_void_cookie_t
xcb_sync_change_alarm_checked(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const void * value_list)1328 xcb_sync_change_alarm_checked (xcb_connection_t *c,
1329 xcb_sync_alarm_t id,
1330 uint32_t value_mask,
1331 const void *value_list)
1332 {
1333 static const xcb_protocol_request_t xcb_req = {
1334 .count = 3,
1335 .ext = &xcb_sync_id,
1336 .opcode = XCB_SYNC_CHANGE_ALARM,
1337 .isvoid = 1
1338 };
1339
1340 struct iovec xcb_parts[5];
1341 xcb_void_cookie_t xcb_ret;
1342 xcb_sync_change_alarm_request_t xcb_out;
1343
1344 xcb_out.id = id;
1345 xcb_out.value_mask = value_mask;
1346
1347 xcb_parts[2].iov_base = (char *) &xcb_out;
1348 xcb_parts[2].iov_len = sizeof(xcb_out);
1349 xcb_parts[3].iov_base = 0;
1350 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1351 /* xcb_sync_change_alarm_value_list_t value_list */
1352 xcb_parts[4].iov_base = (char *) value_list;
1353 xcb_parts[4].iov_len =
1354 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask);
1355
1356 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1357 return xcb_ret;
1358 }
1359
1360 xcb_void_cookie_t
xcb_sync_change_alarm(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const void * value_list)1361 xcb_sync_change_alarm (xcb_connection_t *c,
1362 xcb_sync_alarm_t id,
1363 uint32_t value_mask,
1364 const void *value_list)
1365 {
1366 static const xcb_protocol_request_t xcb_req = {
1367 .count = 3,
1368 .ext = &xcb_sync_id,
1369 .opcode = XCB_SYNC_CHANGE_ALARM,
1370 .isvoid = 1
1371 };
1372
1373 struct iovec xcb_parts[5];
1374 xcb_void_cookie_t xcb_ret;
1375 xcb_sync_change_alarm_request_t xcb_out;
1376
1377 xcb_out.id = id;
1378 xcb_out.value_mask = value_mask;
1379
1380 xcb_parts[2].iov_base = (char *) &xcb_out;
1381 xcb_parts[2].iov_len = sizeof(xcb_out);
1382 xcb_parts[3].iov_base = 0;
1383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1384 /* xcb_sync_change_alarm_value_list_t value_list */
1385 xcb_parts[4].iov_base = (char *) value_list;
1386 xcb_parts[4].iov_len =
1387 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask);
1388
1389 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1390 return xcb_ret;
1391 }
1392
1393 xcb_void_cookie_t
xcb_sync_change_alarm_aux_checked(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const xcb_sync_change_alarm_value_list_t * value_list)1394 xcb_sync_change_alarm_aux_checked (xcb_connection_t *c,
1395 xcb_sync_alarm_t id,
1396 uint32_t value_mask,
1397 const xcb_sync_change_alarm_value_list_t *value_list)
1398 {
1399 static const xcb_protocol_request_t xcb_req = {
1400 .count = 3,
1401 .ext = &xcb_sync_id,
1402 .opcode = XCB_SYNC_CHANGE_ALARM,
1403 .isvoid = 1
1404 };
1405
1406 struct iovec xcb_parts[5];
1407 xcb_void_cookie_t xcb_ret;
1408 xcb_sync_change_alarm_request_t xcb_out;
1409 void *xcb_aux0 = 0;
1410
1411 xcb_out.id = id;
1412 xcb_out.value_mask = value_mask;
1413
1414 xcb_parts[2].iov_base = (char *) &xcb_out;
1415 xcb_parts[2].iov_len = sizeof(xcb_out);
1416 xcb_parts[3].iov_base = 0;
1417 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1418 /* xcb_sync_change_alarm_value_list_t value_list */
1419 xcb_parts[4].iov_len =
1420 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
1421 xcb_parts[4].iov_base = xcb_aux0;
1422
1423 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1424 free(xcb_aux0);
1425 return xcb_ret;
1426 }
1427
1428 xcb_void_cookie_t
xcb_sync_change_alarm_aux(xcb_connection_t * c,xcb_sync_alarm_t id,uint32_t value_mask,const xcb_sync_change_alarm_value_list_t * value_list)1429 xcb_sync_change_alarm_aux (xcb_connection_t *c,
1430 xcb_sync_alarm_t id,
1431 uint32_t value_mask,
1432 const xcb_sync_change_alarm_value_list_t *value_list)
1433 {
1434 static const xcb_protocol_request_t xcb_req = {
1435 .count = 3,
1436 .ext = &xcb_sync_id,
1437 .opcode = XCB_SYNC_CHANGE_ALARM,
1438 .isvoid = 1
1439 };
1440
1441 struct iovec xcb_parts[5];
1442 xcb_void_cookie_t xcb_ret;
1443 xcb_sync_change_alarm_request_t xcb_out;
1444 void *xcb_aux0 = 0;
1445
1446 xcb_out.id = id;
1447 xcb_out.value_mask = value_mask;
1448
1449 xcb_parts[2].iov_base = (char *) &xcb_out;
1450 xcb_parts[2].iov_len = sizeof(xcb_out);
1451 xcb_parts[3].iov_base = 0;
1452 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1453 /* xcb_sync_change_alarm_value_list_t value_list */
1454 xcb_parts[4].iov_len =
1455 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
1456 xcb_parts[4].iov_base = xcb_aux0;
1457
1458 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1459 free(xcb_aux0);
1460 return xcb_ret;
1461 }
1462
1463 void *
xcb_sync_change_alarm_value_list(const xcb_sync_change_alarm_request_t * R)1464 xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R)
1465 {
1466 return (void *) (R + 1);
1467 }
1468
1469 xcb_void_cookie_t
xcb_sync_destroy_alarm_checked(xcb_connection_t * c,xcb_sync_alarm_t alarm)1470 xcb_sync_destroy_alarm_checked (xcb_connection_t *c,
1471 xcb_sync_alarm_t alarm)
1472 {
1473 static const xcb_protocol_request_t xcb_req = {
1474 .count = 2,
1475 .ext = &xcb_sync_id,
1476 .opcode = XCB_SYNC_DESTROY_ALARM,
1477 .isvoid = 1
1478 };
1479
1480 struct iovec xcb_parts[4];
1481 xcb_void_cookie_t xcb_ret;
1482 xcb_sync_destroy_alarm_request_t xcb_out;
1483
1484 xcb_out.alarm = alarm;
1485
1486 xcb_parts[2].iov_base = (char *) &xcb_out;
1487 xcb_parts[2].iov_len = sizeof(xcb_out);
1488 xcb_parts[3].iov_base = 0;
1489 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1490
1491 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1492 return xcb_ret;
1493 }
1494
1495 xcb_void_cookie_t
xcb_sync_destroy_alarm(xcb_connection_t * c,xcb_sync_alarm_t alarm)1496 xcb_sync_destroy_alarm (xcb_connection_t *c,
1497 xcb_sync_alarm_t alarm)
1498 {
1499 static const xcb_protocol_request_t xcb_req = {
1500 .count = 2,
1501 .ext = &xcb_sync_id,
1502 .opcode = XCB_SYNC_DESTROY_ALARM,
1503 .isvoid = 1
1504 };
1505
1506 struct iovec xcb_parts[4];
1507 xcb_void_cookie_t xcb_ret;
1508 xcb_sync_destroy_alarm_request_t xcb_out;
1509
1510 xcb_out.alarm = alarm;
1511
1512 xcb_parts[2].iov_base = (char *) &xcb_out;
1513 xcb_parts[2].iov_len = sizeof(xcb_out);
1514 xcb_parts[3].iov_base = 0;
1515 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1516
1517 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1518 return xcb_ret;
1519 }
1520
1521 xcb_sync_query_alarm_cookie_t
xcb_sync_query_alarm(xcb_connection_t * c,xcb_sync_alarm_t alarm)1522 xcb_sync_query_alarm (xcb_connection_t *c,
1523 xcb_sync_alarm_t alarm)
1524 {
1525 static const xcb_protocol_request_t xcb_req = {
1526 .count = 2,
1527 .ext = &xcb_sync_id,
1528 .opcode = XCB_SYNC_QUERY_ALARM,
1529 .isvoid = 0
1530 };
1531
1532 struct iovec xcb_parts[4];
1533 xcb_sync_query_alarm_cookie_t xcb_ret;
1534 xcb_sync_query_alarm_request_t xcb_out;
1535
1536 xcb_out.alarm = alarm;
1537
1538 xcb_parts[2].iov_base = (char *) &xcb_out;
1539 xcb_parts[2].iov_len = sizeof(xcb_out);
1540 xcb_parts[3].iov_base = 0;
1541 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1542
1543 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1544 return xcb_ret;
1545 }
1546
1547 xcb_sync_query_alarm_cookie_t
xcb_sync_query_alarm_unchecked(xcb_connection_t * c,xcb_sync_alarm_t alarm)1548 xcb_sync_query_alarm_unchecked (xcb_connection_t *c,
1549 xcb_sync_alarm_t alarm)
1550 {
1551 static const xcb_protocol_request_t xcb_req = {
1552 .count = 2,
1553 .ext = &xcb_sync_id,
1554 .opcode = XCB_SYNC_QUERY_ALARM,
1555 .isvoid = 0
1556 };
1557
1558 struct iovec xcb_parts[4];
1559 xcb_sync_query_alarm_cookie_t xcb_ret;
1560 xcb_sync_query_alarm_request_t xcb_out;
1561
1562 xcb_out.alarm = alarm;
1563
1564 xcb_parts[2].iov_base = (char *) &xcb_out;
1565 xcb_parts[2].iov_len = sizeof(xcb_out);
1566 xcb_parts[3].iov_base = 0;
1567 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1568
1569 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1570 return xcb_ret;
1571 }
1572
1573 xcb_sync_query_alarm_reply_t *
xcb_sync_query_alarm_reply(xcb_connection_t * c,xcb_sync_query_alarm_cookie_t cookie,xcb_generic_error_t ** e)1574 xcb_sync_query_alarm_reply (xcb_connection_t *c,
1575 xcb_sync_query_alarm_cookie_t cookie /**< */,
1576 xcb_generic_error_t **e)
1577 {
1578 return (xcb_sync_query_alarm_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1579 }
1580
1581 xcb_void_cookie_t
xcb_sync_set_priority_checked(xcb_connection_t * c,uint32_t id,int32_t priority)1582 xcb_sync_set_priority_checked (xcb_connection_t *c,
1583 uint32_t id,
1584 int32_t priority)
1585 {
1586 static const xcb_protocol_request_t xcb_req = {
1587 .count = 2,
1588 .ext = &xcb_sync_id,
1589 .opcode = XCB_SYNC_SET_PRIORITY,
1590 .isvoid = 1
1591 };
1592
1593 struct iovec xcb_parts[4];
1594 xcb_void_cookie_t xcb_ret;
1595 xcb_sync_set_priority_request_t xcb_out;
1596
1597 xcb_out.id = id;
1598 xcb_out.priority = priority;
1599
1600 xcb_parts[2].iov_base = (char *) &xcb_out;
1601 xcb_parts[2].iov_len = sizeof(xcb_out);
1602 xcb_parts[3].iov_base = 0;
1603 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1604
1605 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1606 return xcb_ret;
1607 }
1608
1609 xcb_void_cookie_t
xcb_sync_set_priority(xcb_connection_t * c,uint32_t id,int32_t priority)1610 xcb_sync_set_priority (xcb_connection_t *c,
1611 uint32_t id,
1612 int32_t priority)
1613 {
1614 static const xcb_protocol_request_t xcb_req = {
1615 .count = 2,
1616 .ext = &xcb_sync_id,
1617 .opcode = XCB_SYNC_SET_PRIORITY,
1618 .isvoid = 1
1619 };
1620
1621 struct iovec xcb_parts[4];
1622 xcb_void_cookie_t xcb_ret;
1623 xcb_sync_set_priority_request_t xcb_out;
1624
1625 xcb_out.id = id;
1626 xcb_out.priority = priority;
1627
1628 xcb_parts[2].iov_base = (char *) &xcb_out;
1629 xcb_parts[2].iov_len = sizeof(xcb_out);
1630 xcb_parts[3].iov_base = 0;
1631 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1632
1633 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1634 return xcb_ret;
1635 }
1636
1637 xcb_sync_get_priority_cookie_t
xcb_sync_get_priority(xcb_connection_t * c,uint32_t id)1638 xcb_sync_get_priority (xcb_connection_t *c,
1639 uint32_t id)
1640 {
1641 static const xcb_protocol_request_t xcb_req = {
1642 .count = 2,
1643 .ext = &xcb_sync_id,
1644 .opcode = XCB_SYNC_GET_PRIORITY,
1645 .isvoid = 0
1646 };
1647
1648 struct iovec xcb_parts[4];
1649 xcb_sync_get_priority_cookie_t xcb_ret;
1650 xcb_sync_get_priority_request_t xcb_out;
1651
1652 xcb_out.id = id;
1653
1654 xcb_parts[2].iov_base = (char *) &xcb_out;
1655 xcb_parts[2].iov_len = sizeof(xcb_out);
1656 xcb_parts[3].iov_base = 0;
1657 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1658
1659 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1660 return xcb_ret;
1661 }
1662
1663 xcb_sync_get_priority_cookie_t
xcb_sync_get_priority_unchecked(xcb_connection_t * c,uint32_t id)1664 xcb_sync_get_priority_unchecked (xcb_connection_t *c,
1665 uint32_t id)
1666 {
1667 static const xcb_protocol_request_t xcb_req = {
1668 .count = 2,
1669 .ext = &xcb_sync_id,
1670 .opcode = XCB_SYNC_GET_PRIORITY,
1671 .isvoid = 0
1672 };
1673
1674 struct iovec xcb_parts[4];
1675 xcb_sync_get_priority_cookie_t xcb_ret;
1676 xcb_sync_get_priority_request_t xcb_out;
1677
1678 xcb_out.id = id;
1679
1680 xcb_parts[2].iov_base = (char *) &xcb_out;
1681 xcb_parts[2].iov_len = sizeof(xcb_out);
1682 xcb_parts[3].iov_base = 0;
1683 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1684
1685 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1686 return xcb_ret;
1687 }
1688
1689 xcb_sync_get_priority_reply_t *
xcb_sync_get_priority_reply(xcb_connection_t * c,xcb_sync_get_priority_cookie_t cookie,xcb_generic_error_t ** e)1690 xcb_sync_get_priority_reply (xcb_connection_t *c,
1691 xcb_sync_get_priority_cookie_t cookie /**< */,
1692 xcb_generic_error_t **e)
1693 {
1694 return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1695 }
1696
1697 xcb_void_cookie_t
xcb_sync_create_fence_checked(xcb_connection_t * c,xcb_drawable_t drawable,xcb_sync_fence_t fence,uint8_t initially_triggered)1698 xcb_sync_create_fence_checked (xcb_connection_t *c,
1699 xcb_drawable_t drawable,
1700 xcb_sync_fence_t fence,
1701 uint8_t initially_triggered)
1702 {
1703 static const xcb_protocol_request_t xcb_req = {
1704 .count = 2,
1705 .ext = &xcb_sync_id,
1706 .opcode = XCB_SYNC_CREATE_FENCE,
1707 .isvoid = 1
1708 };
1709
1710 struct iovec xcb_parts[4];
1711 xcb_void_cookie_t xcb_ret;
1712 xcb_sync_create_fence_request_t xcb_out;
1713
1714 xcb_out.drawable = drawable;
1715 xcb_out.fence = fence;
1716 xcb_out.initially_triggered = initially_triggered;
1717
1718 xcb_parts[2].iov_base = (char *) &xcb_out;
1719 xcb_parts[2].iov_len = sizeof(xcb_out);
1720 xcb_parts[3].iov_base = 0;
1721 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1722
1723 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1724 return xcb_ret;
1725 }
1726
1727 xcb_void_cookie_t
xcb_sync_create_fence(xcb_connection_t * c,xcb_drawable_t drawable,xcb_sync_fence_t fence,uint8_t initially_triggered)1728 xcb_sync_create_fence (xcb_connection_t *c,
1729 xcb_drawable_t drawable,
1730 xcb_sync_fence_t fence,
1731 uint8_t initially_triggered)
1732 {
1733 static const xcb_protocol_request_t xcb_req = {
1734 .count = 2,
1735 .ext = &xcb_sync_id,
1736 .opcode = XCB_SYNC_CREATE_FENCE,
1737 .isvoid = 1
1738 };
1739
1740 struct iovec xcb_parts[4];
1741 xcb_void_cookie_t xcb_ret;
1742 xcb_sync_create_fence_request_t xcb_out;
1743
1744 xcb_out.drawable = drawable;
1745 xcb_out.fence = fence;
1746 xcb_out.initially_triggered = initially_triggered;
1747
1748 xcb_parts[2].iov_base = (char *) &xcb_out;
1749 xcb_parts[2].iov_len = sizeof(xcb_out);
1750 xcb_parts[3].iov_base = 0;
1751 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1752
1753 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1754 return xcb_ret;
1755 }
1756
1757 xcb_void_cookie_t
xcb_sync_trigger_fence_checked(xcb_connection_t * c,xcb_sync_fence_t fence)1758 xcb_sync_trigger_fence_checked (xcb_connection_t *c,
1759 xcb_sync_fence_t fence)
1760 {
1761 static const xcb_protocol_request_t xcb_req = {
1762 .count = 2,
1763 .ext = &xcb_sync_id,
1764 .opcode = XCB_SYNC_TRIGGER_FENCE,
1765 .isvoid = 1
1766 };
1767
1768 struct iovec xcb_parts[4];
1769 xcb_void_cookie_t xcb_ret;
1770 xcb_sync_trigger_fence_request_t xcb_out;
1771
1772 xcb_out.fence = fence;
1773
1774 xcb_parts[2].iov_base = (char *) &xcb_out;
1775 xcb_parts[2].iov_len = sizeof(xcb_out);
1776 xcb_parts[3].iov_base = 0;
1777 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1778
1779 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1780 return xcb_ret;
1781 }
1782
1783 xcb_void_cookie_t
xcb_sync_trigger_fence(xcb_connection_t * c,xcb_sync_fence_t fence)1784 xcb_sync_trigger_fence (xcb_connection_t *c,
1785 xcb_sync_fence_t fence)
1786 {
1787 static const xcb_protocol_request_t xcb_req = {
1788 .count = 2,
1789 .ext = &xcb_sync_id,
1790 .opcode = XCB_SYNC_TRIGGER_FENCE,
1791 .isvoid = 1
1792 };
1793
1794 struct iovec xcb_parts[4];
1795 xcb_void_cookie_t xcb_ret;
1796 xcb_sync_trigger_fence_request_t xcb_out;
1797
1798 xcb_out.fence = fence;
1799
1800 xcb_parts[2].iov_base = (char *) &xcb_out;
1801 xcb_parts[2].iov_len = sizeof(xcb_out);
1802 xcb_parts[3].iov_base = 0;
1803 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1804
1805 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1806 return xcb_ret;
1807 }
1808
1809 xcb_void_cookie_t
xcb_sync_reset_fence_checked(xcb_connection_t * c,xcb_sync_fence_t fence)1810 xcb_sync_reset_fence_checked (xcb_connection_t *c,
1811 xcb_sync_fence_t fence)
1812 {
1813 static const xcb_protocol_request_t xcb_req = {
1814 .count = 2,
1815 .ext = &xcb_sync_id,
1816 .opcode = XCB_SYNC_RESET_FENCE,
1817 .isvoid = 1
1818 };
1819
1820 struct iovec xcb_parts[4];
1821 xcb_void_cookie_t xcb_ret;
1822 xcb_sync_reset_fence_request_t xcb_out;
1823
1824 xcb_out.fence = fence;
1825
1826 xcb_parts[2].iov_base = (char *) &xcb_out;
1827 xcb_parts[2].iov_len = sizeof(xcb_out);
1828 xcb_parts[3].iov_base = 0;
1829 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1830
1831 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1832 return xcb_ret;
1833 }
1834
1835 xcb_void_cookie_t
xcb_sync_reset_fence(xcb_connection_t * c,xcb_sync_fence_t fence)1836 xcb_sync_reset_fence (xcb_connection_t *c,
1837 xcb_sync_fence_t fence)
1838 {
1839 static const xcb_protocol_request_t xcb_req = {
1840 .count = 2,
1841 .ext = &xcb_sync_id,
1842 .opcode = XCB_SYNC_RESET_FENCE,
1843 .isvoid = 1
1844 };
1845
1846 struct iovec xcb_parts[4];
1847 xcb_void_cookie_t xcb_ret;
1848 xcb_sync_reset_fence_request_t xcb_out;
1849
1850 xcb_out.fence = fence;
1851
1852 xcb_parts[2].iov_base = (char *) &xcb_out;
1853 xcb_parts[2].iov_len = sizeof(xcb_out);
1854 xcb_parts[3].iov_base = 0;
1855 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1856
1857 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1858 return xcb_ret;
1859 }
1860
1861 xcb_void_cookie_t
xcb_sync_destroy_fence_checked(xcb_connection_t * c,xcb_sync_fence_t fence)1862 xcb_sync_destroy_fence_checked (xcb_connection_t *c,
1863 xcb_sync_fence_t fence)
1864 {
1865 static const xcb_protocol_request_t xcb_req = {
1866 .count = 2,
1867 .ext = &xcb_sync_id,
1868 .opcode = XCB_SYNC_DESTROY_FENCE,
1869 .isvoid = 1
1870 };
1871
1872 struct iovec xcb_parts[4];
1873 xcb_void_cookie_t xcb_ret;
1874 xcb_sync_destroy_fence_request_t xcb_out;
1875
1876 xcb_out.fence = fence;
1877
1878 xcb_parts[2].iov_base = (char *) &xcb_out;
1879 xcb_parts[2].iov_len = sizeof(xcb_out);
1880 xcb_parts[3].iov_base = 0;
1881 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1882
1883 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1884 return xcb_ret;
1885 }
1886
1887 xcb_void_cookie_t
xcb_sync_destroy_fence(xcb_connection_t * c,xcb_sync_fence_t fence)1888 xcb_sync_destroy_fence (xcb_connection_t *c,
1889 xcb_sync_fence_t fence)
1890 {
1891 static const xcb_protocol_request_t xcb_req = {
1892 .count = 2,
1893 .ext = &xcb_sync_id,
1894 .opcode = XCB_SYNC_DESTROY_FENCE,
1895 .isvoid = 1
1896 };
1897
1898 struct iovec xcb_parts[4];
1899 xcb_void_cookie_t xcb_ret;
1900 xcb_sync_destroy_fence_request_t xcb_out;
1901
1902 xcb_out.fence = fence;
1903
1904 xcb_parts[2].iov_base = (char *) &xcb_out;
1905 xcb_parts[2].iov_len = sizeof(xcb_out);
1906 xcb_parts[3].iov_base = 0;
1907 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1908
1909 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1910 return xcb_ret;
1911 }
1912
1913 xcb_sync_query_fence_cookie_t
xcb_sync_query_fence(xcb_connection_t * c,xcb_sync_fence_t fence)1914 xcb_sync_query_fence (xcb_connection_t *c,
1915 xcb_sync_fence_t fence)
1916 {
1917 static const xcb_protocol_request_t xcb_req = {
1918 .count = 2,
1919 .ext = &xcb_sync_id,
1920 .opcode = XCB_SYNC_QUERY_FENCE,
1921 .isvoid = 0
1922 };
1923
1924 struct iovec xcb_parts[4];
1925 xcb_sync_query_fence_cookie_t xcb_ret;
1926 xcb_sync_query_fence_request_t xcb_out;
1927
1928 xcb_out.fence = fence;
1929
1930 xcb_parts[2].iov_base = (char *) &xcb_out;
1931 xcb_parts[2].iov_len = sizeof(xcb_out);
1932 xcb_parts[3].iov_base = 0;
1933 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1934
1935 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1936 return xcb_ret;
1937 }
1938
1939 xcb_sync_query_fence_cookie_t
xcb_sync_query_fence_unchecked(xcb_connection_t * c,xcb_sync_fence_t fence)1940 xcb_sync_query_fence_unchecked (xcb_connection_t *c,
1941 xcb_sync_fence_t fence)
1942 {
1943 static const xcb_protocol_request_t xcb_req = {
1944 .count = 2,
1945 .ext = &xcb_sync_id,
1946 .opcode = XCB_SYNC_QUERY_FENCE,
1947 .isvoid = 0
1948 };
1949
1950 struct iovec xcb_parts[4];
1951 xcb_sync_query_fence_cookie_t xcb_ret;
1952 xcb_sync_query_fence_request_t xcb_out;
1953
1954 xcb_out.fence = fence;
1955
1956 xcb_parts[2].iov_base = (char *) &xcb_out;
1957 xcb_parts[2].iov_len = sizeof(xcb_out);
1958 xcb_parts[3].iov_base = 0;
1959 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1960
1961 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1962 return xcb_ret;
1963 }
1964
1965 xcb_sync_query_fence_reply_t *
xcb_sync_query_fence_reply(xcb_connection_t * c,xcb_sync_query_fence_cookie_t cookie,xcb_generic_error_t ** e)1966 xcb_sync_query_fence_reply (xcb_connection_t *c,
1967 xcb_sync_query_fence_cookie_t cookie /**< */,
1968 xcb_generic_error_t **e)
1969 {
1970 return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1971 }
1972
1973 int
xcb_sync_await_fence_sizeof(const void * _buffer,uint32_t fence_list_len)1974 xcb_sync_await_fence_sizeof (const void *_buffer,
1975 uint32_t fence_list_len)
1976 {
1977 char *xcb_tmp = (char *)_buffer;
1978 unsigned int xcb_buffer_len = 0;
1979 unsigned int xcb_block_len = 0;
1980 unsigned int xcb_pad = 0;
1981 unsigned int xcb_align_to = 0;
1982
1983
1984 xcb_block_len += sizeof(xcb_sync_await_fence_request_t);
1985 xcb_tmp += xcb_block_len;
1986 xcb_buffer_len += xcb_block_len;
1987 xcb_block_len = 0;
1988 /* fence_list */
1989 xcb_block_len += fence_list_len * sizeof(xcb_sync_fence_t);
1990 xcb_tmp += xcb_block_len;
1991 xcb_align_to = ALIGNOF(xcb_sync_fence_t);
1992 /* insert padding */
1993 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1994 xcb_buffer_len += xcb_block_len + xcb_pad;
1995 if (0 != xcb_pad) {
1996 xcb_tmp += xcb_pad;
1997 xcb_pad = 0;
1998 }
1999 xcb_block_len = 0;
2000
2001 return xcb_buffer_len;
2002 }
2003
2004 xcb_void_cookie_t
xcb_sync_await_fence_checked(xcb_connection_t * c,uint32_t fence_list_len,const xcb_sync_fence_t * fence_list)2005 xcb_sync_await_fence_checked (xcb_connection_t *c,
2006 uint32_t fence_list_len,
2007 const xcb_sync_fence_t *fence_list)
2008 {
2009 static const xcb_protocol_request_t xcb_req = {
2010 .count = 4,
2011 .ext = &xcb_sync_id,
2012 .opcode = XCB_SYNC_AWAIT_FENCE,
2013 .isvoid = 1
2014 };
2015
2016 struct iovec xcb_parts[6];
2017 xcb_void_cookie_t xcb_ret;
2018 xcb_sync_await_fence_request_t xcb_out;
2019
2020
2021 xcb_parts[2].iov_base = (char *) &xcb_out;
2022 xcb_parts[2].iov_len = sizeof(xcb_out);
2023 xcb_parts[3].iov_base = 0;
2024 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2025 /* xcb_sync_fence_t fence_list */
2026 xcb_parts[4].iov_base = (char *) fence_list;
2027 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t);
2028 xcb_parts[5].iov_base = 0;
2029 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2030
2031 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2032 return xcb_ret;
2033 }
2034
2035 xcb_void_cookie_t
xcb_sync_await_fence(xcb_connection_t * c,uint32_t fence_list_len,const xcb_sync_fence_t * fence_list)2036 xcb_sync_await_fence (xcb_connection_t *c,
2037 uint32_t fence_list_len,
2038 const xcb_sync_fence_t *fence_list)
2039 {
2040 static const xcb_protocol_request_t xcb_req = {
2041 .count = 4,
2042 .ext = &xcb_sync_id,
2043 .opcode = XCB_SYNC_AWAIT_FENCE,
2044 .isvoid = 1
2045 };
2046
2047 struct iovec xcb_parts[6];
2048 xcb_void_cookie_t xcb_ret;
2049 xcb_sync_await_fence_request_t xcb_out;
2050
2051
2052 xcb_parts[2].iov_base = (char *) &xcb_out;
2053 xcb_parts[2].iov_len = sizeof(xcb_out);
2054 xcb_parts[3].iov_base = 0;
2055 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2056 /* xcb_sync_fence_t fence_list */
2057 xcb_parts[4].iov_base = (char *) fence_list;
2058 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t);
2059 xcb_parts[5].iov_base = 0;
2060 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2061
2062 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2063 return xcb_ret;
2064 }
2065
2066 xcb_sync_fence_t *
xcb_sync_await_fence_fence_list(const xcb_sync_await_fence_request_t * R)2067 xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R)
2068 {
2069 return (xcb_sync_fence_t *) (R + 1);
2070 }
2071
2072 int
xcb_sync_await_fence_fence_list_length(const xcb_sync_await_fence_request_t * R)2073 xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R)
2074 {
2075 return (((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t));
2076 }
2077
2078 xcb_generic_iterator_t
xcb_sync_await_fence_fence_list_end(const xcb_sync_await_fence_request_t * R)2079 xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R)
2080 {
2081 xcb_generic_iterator_t i;
2082 i.data = ((xcb_sync_fence_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t)));
2083 i.rem = 0;
2084 i.index = (char *) i.data - (char *) R;
2085 return i;
2086 }
2087
2088