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