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