sync.c revision 1.3
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 = 0; 182 183 184 xcb_block_len += sizeof(xcb_sync_systemcounter_t); 185 xcb_tmp += xcb_block_len; 186 xcb_buffer_len += xcb_block_len; 187 xcb_block_len = 0; 188 /* name */ 189 xcb_block_len += _aux->name_len * sizeof(char); 190 xcb_tmp += xcb_block_len; 191 xcb_align_to = ALIGNOF(char); 192 /* insert padding */ 193 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 194 xcb_buffer_len += xcb_block_len + xcb_pad; 195 if (0 != xcb_pad) { 196 xcb_tmp += xcb_pad; 197 xcb_pad = 0; 198 } 199 xcb_block_len = 0; 200 201 return xcb_buffer_len; 202 } 203 204 205 /***************************************************************************** 206 ** 207 ** char * xcb_sync_systemcounter_name 208 ** 209 ** @param const xcb_sync_systemcounter_t *R 210 ** @returns char * 211 ** 212 *****************************************************************************/ 213 214 char * 215 xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R /**< */) 216 { 217 return (char *) (R + 1); 218 } 219 220 221 /***************************************************************************** 222 ** 223 ** int xcb_sync_systemcounter_name_length 224 ** 225 ** @param const xcb_sync_systemcounter_t *R 226 ** @returns int 227 ** 228 *****************************************************************************/ 229 230 int 231 xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R /**< */) 232 { 233 return R->name_len; 234 } 235 236 237 /***************************************************************************** 238 ** 239 ** xcb_generic_iterator_t xcb_sync_systemcounter_name_end 240 ** 241 ** @param const xcb_sync_systemcounter_t *R 242 ** @returns xcb_generic_iterator_t 243 ** 244 *****************************************************************************/ 245 246 xcb_generic_iterator_t 247 xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R /**< */) 248 { 249 xcb_generic_iterator_t i; 250 i.data = ((char *) (R + 1)) + (R->name_len); 251 i.rem = 0; 252 i.index = (char *) i.data - (char *) R; 253 return i; 254 } 255 256 257 /***************************************************************************** 258 ** 259 ** void xcb_sync_systemcounter_next 260 ** 261 ** @param xcb_sync_systemcounter_iterator_t *i 262 ** @returns void 263 ** 264 *****************************************************************************/ 265 266 void 267 xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */) 268 { 269 xcb_sync_systemcounter_t *R = i->data; 270 xcb_generic_iterator_t child; 271 child.data = (xcb_sync_systemcounter_t *)(((char *)R) + xcb_sync_systemcounter_sizeof(R)); 272 i->index = (char *) child.data - (char *) i->data; 273 --i->rem; 274 i->data = (xcb_sync_systemcounter_t *) child.data; 275 } 276 277 278 /***************************************************************************** 279 ** 280 ** xcb_generic_iterator_t xcb_sync_systemcounter_end 281 ** 282 ** @param xcb_sync_systemcounter_iterator_t i 283 ** @returns xcb_generic_iterator_t 284 ** 285 *****************************************************************************/ 286 287 xcb_generic_iterator_t 288 xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i /**< */) 289 { 290 xcb_generic_iterator_t ret; 291 while(i.rem > 0) 292 xcb_sync_systemcounter_next(&i); 293 ret.data = i.data; 294 ret.rem = i.rem; 295 ret.index = i.index; 296 return ret; 297 } 298 299 300 /***************************************************************************** 301 ** 302 ** void xcb_sync_trigger_next 303 ** 304 ** @param xcb_sync_trigger_iterator_t *i 305 ** @returns void 306 ** 307 *****************************************************************************/ 308 309 void 310 xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i /**< */) 311 { 312 --i->rem; 313 ++i->data; 314 i->index += sizeof(xcb_sync_trigger_t); 315 } 316 317 318 /***************************************************************************** 319 ** 320 ** xcb_generic_iterator_t xcb_sync_trigger_end 321 ** 322 ** @param xcb_sync_trigger_iterator_t i 323 ** @returns xcb_generic_iterator_t 324 ** 325 *****************************************************************************/ 326 327 xcb_generic_iterator_t 328 xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i /**< */) 329 { 330 xcb_generic_iterator_t ret; 331 ret.data = i.data + i.rem; 332 ret.index = i.index + ((char *) ret.data - (char *) i.data); 333 ret.rem = 0; 334 return ret; 335 } 336 337 338 /***************************************************************************** 339 ** 340 ** void xcb_sync_waitcondition_next 341 ** 342 ** @param xcb_sync_waitcondition_iterator_t *i 343 ** @returns void 344 ** 345 *****************************************************************************/ 346 347 void 348 xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i /**< */) 349 { 350 --i->rem; 351 ++i->data; 352 i->index += sizeof(xcb_sync_waitcondition_t); 353 } 354 355 356 /***************************************************************************** 357 ** 358 ** xcb_generic_iterator_t xcb_sync_waitcondition_end 359 ** 360 ** @param xcb_sync_waitcondition_iterator_t i 361 ** @returns xcb_generic_iterator_t 362 ** 363 *****************************************************************************/ 364 365 xcb_generic_iterator_t 366 xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */) 367 { 368 xcb_generic_iterator_t ret; 369 ret.data = i.data + i.rem; 370 ret.index = i.index + ((char *) ret.data - (char *) i.data); 371 ret.rem = 0; 372 return ret; 373 } 374 375 376 /***************************************************************************** 377 ** 378 ** xcb_sync_initialize_cookie_t xcb_sync_initialize 379 ** 380 ** @param xcb_connection_t *c 381 ** @param uint8_t desired_major_version 382 ** @param uint8_t desired_minor_version 383 ** @returns xcb_sync_initialize_cookie_t 384 ** 385 *****************************************************************************/ 386 387 xcb_sync_initialize_cookie_t 388 xcb_sync_initialize (xcb_connection_t *c /**< */, 389 uint8_t desired_major_version /**< */, 390 uint8_t desired_minor_version /**< */) 391 { 392 static const xcb_protocol_request_t xcb_req = { 393 /* count */ 2, 394 /* ext */ &xcb_sync_id, 395 /* opcode */ XCB_SYNC_INITIALIZE, 396 /* isvoid */ 0 397 }; 398 399 struct iovec xcb_parts[4]; 400 xcb_sync_initialize_cookie_t xcb_ret; 401 xcb_sync_initialize_request_t xcb_out; 402 403 xcb_out.desired_major_version = desired_major_version; 404 xcb_out.desired_minor_version = desired_minor_version; 405 406 xcb_parts[2].iov_base = (char *) &xcb_out; 407 xcb_parts[2].iov_len = sizeof(xcb_out); 408 xcb_parts[3].iov_base = 0; 409 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 410 411 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 412 return xcb_ret; 413 } 414 415 416 /***************************************************************************** 417 ** 418 ** xcb_sync_initialize_cookie_t xcb_sync_initialize_unchecked 419 ** 420 ** @param xcb_connection_t *c 421 ** @param uint8_t desired_major_version 422 ** @param uint8_t desired_minor_version 423 ** @returns xcb_sync_initialize_cookie_t 424 ** 425 *****************************************************************************/ 426 427 xcb_sync_initialize_cookie_t 428 xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, 429 uint8_t desired_major_version /**< */, 430 uint8_t desired_minor_version /**< */) 431 { 432 static const xcb_protocol_request_t xcb_req = { 433 /* count */ 2, 434 /* ext */ &xcb_sync_id, 435 /* opcode */ XCB_SYNC_INITIALIZE, 436 /* isvoid */ 0 437 }; 438 439 struct iovec xcb_parts[4]; 440 xcb_sync_initialize_cookie_t xcb_ret; 441 xcb_sync_initialize_request_t xcb_out; 442 443 xcb_out.desired_major_version = desired_major_version; 444 xcb_out.desired_minor_version = desired_minor_version; 445 446 xcb_parts[2].iov_base = (char *) &xcb_out; 447 xcb_parts[2].iov_len = sizeof(xcb_out); 448 xcb_parts[3].iov_base = 0; 449 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 450 451 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 452 return xcb_ret; 453 } 454 455 456 /***************************************************************************** 457 ** 458 ** xcb_sync_initialize_reply_t * xcb_sync_initialize_reply 459 ** 460 ** @param xcb_connection_t *c 461 ** @param xcb_sync_initialize_cookie_t cookie 462 ** @param xcb_generic_error_t **e 463 ** @returns xcb_sync_initialize_reply_t * 464 ** 465 *****************************************************************************/ 466 467 xcb_sync_initialize_reply_t * 468 xcb_sync_initialize_reply (xcb_connection_t *c /**< */, 469 xcb_sync_initialize_cookie_t cookie /**< */, 470 xcb_generic_error_t **e /**< */) 471 { 472 return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 473 } 474 475 int 476 xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */) 477 { 478 char *xcb_tmp = (char *)_buffer; 479 const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer; 480 unsigned int xcb_buffer_len = 0; 481 unsigned int xcb_block_len = 0; 482 unsigned int xcb_pad = 0; 483 unsigned int xcb_align_to = 0; 484 485 unsigned int i; 486 unsigned int xcb_tmp_len; 487 488 xcb_block_len += sizeof(xcb_sync_list_system_counters_reply_t); 489 xcb_tmp += xcb_block_len; 490 xcb_buffer_len += xcb_block_len; 491 xcb_block_len = 0; 492 /* counters */ 493 for(i=0; i<_aux->counters_len; i++) { 494 xcb_tmp_len = xcb_sync_systemcounter_sizeof(xcb_tmp); 495 xcb_block_len += xcb_tmp_len; 496 xcb_tmp += xcb_tmp_len; 497 } 498 xcb_align_to = ALIGNOF(xcb_sync_systemcounter_t); 499 /* insert padding */ 500 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 501 xcb_buffer_len += xcb_block_len + xcb_pad; 502 if (0 != xcb_pad) { 503 xcb_tmp += xcb_pad; 504 xcb_pad = 0; 505 } 506 xcb_block_len = 0; 507 508 return xcb_buffer_len; 509 } 510 511 512 /***************************************************************************** 513 ** 514 ** xcb_sync_list_system_counters_cookie_t xcb_sync_list_system_counters 515 ** 516 ** @param xcb_connection_t *c 517 ** @returns xcb_sync_list_system_counters_cookie_t 518 ** 519 *****************************************************************************/ 520 521 xcb_sync_list_system_counters_cookie_t 522 xcb_sync_list_system_counters (xcb_connection_t *c /**< */) 523 { 524 static const xcb_protocol_request_t xcb_req = { 525 /* count */ 2, 526 /* ext */ &xcb_sync_id, 527 /* opcode */ XCB_SYNC_LIST_SYSTEM_COUNTERS, 528 /* isvoid */ 0 529 }; 530 531 struct iovec xcb_parts[4]; 532 xcb_sync_list_system_counters_cookie_t xcb_ret; 533 xcb_sync_list_system_counters_request_t xcb_out; 534 535 536 xcb_parts[2].iov_base = (char *) &xcb_out; 537 xcb_parts[2].iov_len = sizeof(xcb_out); 538 xcb_parts[3].iov_base = 0; 539 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 540 541 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 542 return xcb_ret; 543 } 544 545 546 /***************************************************************************** 547 ** 548 ** xcb_sync_list_system_counters_cookie_t xcb_sync_list_system_counters_unchecked 549 ** 550 ** @param xcb_connection_t *c 551 ** @returns xcb_sync_list_system_counters_cookie_t 552 ** 553 *****************************************************************************/ 554 555 xcb_sync_list_system_counters_cookie_t 556 xcb_sync_list_system_counters_unchecked (xcb_connection_t *c /**< */) 557 { 558 static const xcb_protocol_request_t xcb_req = { 559 /* count */ 2, 560 /* ext */ &xcb_sync_id, 561 /* opcode */ XCB_SYNC_LIST_SYSTEM_COUNTERS, 562 /* isvoid */ 0 563 }; 564 565 struct iovec xcb_parts[4]; 566 xcb_sync_list_system_counters_cookie_t xcb_ret; 567 xcb_sync_list_system_counters_request_t xcb_out; 568 569 570 xcb_parts[2].iov_base = (char *) &xcb_out; 571 xcb_parts[2].iov_len = sizeof(xcb_out); 572 xcb_parts[3].iov_base = 0; 573 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 574 575 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 576 return xcb_ret; 577 } 578 579 580 /***************************************************************************** 581 ** 582 ** int xcb_sync_list_system_counters_counters_length 583 ** 584 ** @param const xcb_sync_list_system_counters_reply_t *R 585 ** @returns int 586 ** 587 *****************************************************************************/ 588 589 int 590 xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R /**< */) 591 { 592 return R->counters_len; 593 } 594 595 596 /***************************************************************************** 597 ** 598 ** xcb_sync_systemcounter_iterator_t xcb_sync_list_system_counters_counters_iterator 599 ** 600 ** @param const xcb_sync_list_system_counters_reply_t *R 601 ** @returns xcb_sync_systemcounter_iterator_t 602 ** 603 *****************************************************************************/ 604 605 xcb_sync_systemcounter_iterator_t 606 xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R /**< */) 607 { 608 xcb_sync_systemcounter_iterator_t i; 609 i.data = (xcb_sync_systemcounter_t *) (R + 1); 610 i.rem = R->counters_len; 611 i.index = (char *) i.data - (char *) R; 612 return i; 613 } 614 615 616 /***************************************************************************** 617 ** 618 ** xcb_sync_list_system_counters_reply_t * xcb_sync_list_system_counters_reply 619 ** 620 ** @param xcb_connection_t *c 621 ** @param xcb_sync_list_system_counters_cookie_t cookie 622 ** @param xcb_generic_error_t **e 623 ** @returns xcb_sync_list_system_counters_reply_t * 624 ** 625 *****************************************************************************/ 626 627 xcb_sync_list_system_counters_reply_t * 628 xcb_sync_list_system_counters_reply (xcb_connection_t *c /**< */, 629 xcb_sync_list_system_counters_cookie_t cookie /**< */, 630 xcb_generic_error_t **e /**< */) 631 { 632 return (xcb_sync_list_system_counters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 633 } 634 635 636 /***************************************************************************** 637 ** 638 ** xcb_void_cookie_t xcb_sync_create_counter_checked 639 ** 640 ** @param xcb_connection_t *c 641 ** @param xcb_sync_counter_t id 642 ** @param xcb_sync_int64_t initial_value 643 ** @returns xcb_void_cookie_t 644 ** 645 *****************************************************************************/ 646 647 xcb_void_cookie_t 648 xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, 649 xcb_sync_counter_t id /**< */, 650 xcb_sync_int64_t initial_value /**< */) 651 { 652 static const xcb_protocol_request_t xcb_req = { 653 /* count */ 2, 654 /* ext */ &xcb_sync_id, 655 /* opcode */ XCB_SYNC_CREATE_COUNTER, 656 /* isvoid */ 1 657 }; 658 659 struct iovec xcb_parts[4]; 660 xcb_void_cookie_t xcb_ret; 661 xcb_sync_create_counter_request_t xcb_out; 662 663 xcb_out.id = id; 664 xcb_out.initial_value = initial_value; 665 666 xcb_parts[2].iov_base = (char *) &xcb_out; 667 xcb_parts[2].iov_len = sizeof(xcb_out); 668 xcb_parts[3].iov_base = 0; 669 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 670 671 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 672 return xcb_ret; 673 } 674 675 676 /***************************************************************************** 677 ** 678 ** xcb_void_cookie_t xcb_sync_create_counter 679 ** 680 ** @param xcb_connection_t *c 681 ** @param xcb_sync_counter_t id 682 ** @param xcb_sync_int64_t initial_value 683 ** @returns xcb_void_cookie_t 684 ** 685 *****************************************************************************/ 686 687 xcb_void_cookie_t 688 xcb_sync_create_counter (xcb_connection_t *c /**< */, 689 xcb_sync_counter_t id /**< */, 690 xcb_sync_int64_t initial_value /**< */) 691 { 692 static const xcb_protocol_request_t xcb_req = { 693 /* count */ 2, 694 /* ext */ &xcb_sync_id, 695 /* opcode */ XCB_SYNC_CREATE_COUNTER, 696 /* isvoid */ 1 697 }; 698 699 struct iovec xcb_parts[4]; 700 xcb_void_cookie_t xcb_ret; 701 xcb_sync_create_counter_request_t xcb_out; 702 703 xcb_out.id = id; 704 xcb_out.initial_value = initial_value; 705 706 xcb_parts[2].iov_base = (char *) &xcb_out; 707 xcb_parts[2].iov_len = sizeof(xcb_out); 708 xcb_parts[3].iov_base = 0; 709 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 710 711 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 712 return xcb_ret; 713 } 714 715 716 /***************************************************************************** 717 ** 718 ** xcb_void_cookie_t xcb_sync_destroy_counter_checked 719 ** 720 ** @param xcb_connection_t *c 721 ** @param xcb_sync_counter_t counter 722 ** @returns xcb_void_cookie_t 723 ** 724 *****************************************************************************/ 725 726 xcb_void_cookie_t 727 xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, 728 xcb_sync_counter_t counter /**< */) 729 { 730 static const xcb_protocol_request_t xcb_req = { 731 /* count */ 2, 732 /* ext */ &xcb_sync_id, 733 /* opcode */ XCB_SYNC_DESTROY_COUNTER, 734 /* isvoid */ 1 735 }; 736 737 struct iovec xcb_parts[4]; 738 xcb_void_cookie_t xcb_ret; 739 xcb_sync_destroy_counter_request_t xcb_out; 740 741 xcb_out.counter = counter; 742 743 xcb_parts[2].iov_base = (char *) &xcb_out; 744 xcb_parts[2].iov_len = sizeof(xcb_out); 745 xcb_parts[3].iov_base = 0; 746 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 747 748 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 749 return xcb_ret; 750 } 751 752 753 /***************************************************************************** 754 ** 755 ** xcb_void_cookie_t xcb_sync_destroy_counter 756 ** 757 ** @param xcb_connection_t *c 758 ** @param xcb_sync_counter_t counter 759 ** @returns xcb_void_cookie_t 760 ** 761 *****************************************************************************/ 762 763 xcb_void_cookie_t 764 xcb_sync_destroy_counter (xcb_connection_t *c /**< */, 765 xcb_sync_counter_t counter /**< */) 766 { 767 static const xcb_protocol_request_t xcb_req = { 768 /* count */ 2, 769 /* ext */ &xcb_sync_id, 770 /* opcode */ XCB_SYNC_DESTROY_COUNTER, 771 /* isvoid */ 1 772 }; 773 774 struct iovec xcb_parts[4]; 775 xcb_void_cookie_t xcb_ret; 776 xcb_sync_destroy_counter_request_t xcb_out; 777 778 xcb_out.counter = counter; 779 780 xcb_parts[2].iov_base = (char *) &xcb_out; 781 xcb_parts[2].iov_len = sizeof(xcb_out); 782 xcb_parts[3].iov_base = 0; 783 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 784 785 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 786 return xcb_ret; 787 } 788 789 790 /***************************************************************************** 791 ** 792 ** xcb_sync_query_counter_cookie_t xcb_sync_query_counter 793 ** 794 ** @param xcb_connection_t *c 795 ** @param xcb_sync_counter_t counter 796 ** @returns xcb_sync_query_counter_cookie_t 797 ** 798 *****************************************************************************/ 799 800 xcb_sync_query_counter_cookie_t 801 xcb_sync_query_counter (xcb_connection_t *c /**< */, 802 xcb_sync_counter_t counter /**< */) 803 { 804 static const xcb_protocol_request_t xcb_req = { 805 /* count */ 2, 806 /* ext */ &xcb_sync_id, 807 /* opcode */ XCB_SYNC_QUERY_COUNTER, 808 /* isvoid */ 0 809 }; 810 811 struct iovec xcb_parts[4]; 812 xcb_sync_query_counter_cookie_t xcb_ret; 813 xcb_sync_query_counter_request_t xcb_out; 814 815 xcb_out.counter = counter; 816 817 xcb_parts[2].iov_base = (char *) &xcb_out; 818 xcb_parts[2].iov_len = sizeof(xcb_out); 819 xcb_parts[3].iov_base = 0; 820 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 821 822 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 823 return xcb_ret; 824 } 825 826 827 /***************************************************************************** 828 ** 829 ** xcb_sync_query_counter_cookie_t xcb_sync_query_counter_unchecked 830 ** 831 ** @param xcb_connection_t *c 832 ** @param xcb_sync_counter_t counter 833 ** @returns xcb_sync_query_counter_cookie_t 834 ** 835 *****************************************************************************/ 836 837 xcb_sync_query_counter_cookie_t 838 xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, 839 xcb_sync_counter_t counter /**< */) 840 { 841 static const xcb_protocol_request_t xcb_req = { 842 /* count */ 2, 843 /* ext */ &xcb_sync_id, 844 /* opcode */ XCB_SYNC_QUERY_COUNTER, 845 /* isvoid */ 0 846 }; 847 848 struct iovec xcb_parts[4]; 849 xcb_sync_query_counter_cookie_t xcb_ret; 850 xcb_sync_query_counter_request_t xcb_out; 851 852 xcb_out.counter = counter; 853 854 xcb_parts[2].iov_base = (char *) &xcb_out; 855 xcb_parts[2].iov_len = sizeof(xcb_out); 856 xcb_parts[3].iov_base = 0; 857 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 858 859 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 860 return xcb_ret; 861 } 862 863 864 /***************************************************************************** 865 ** 866 ** xcb_sync_query_counter_reply_t * xcb_sync_query_counter_reply 867 ** 868 ** @param xcb_connection_t *c 869 ** @param xcb_sync_query_counter_cookie_t cookie 870 ** @param xcb_generic_error_t **e 871 ** @returns xcb_sync_query_counter_reply_t * 872 ** 873 *****************************************************************************/ 874 875 xcb_sync_query_counter_reply_t * 876 xcb_sync_query_counter_reply (xcb_connection_t *c /**< */, 877 xcb_sync_query_counter_cookie_t cookie /**< */, 878 xcb_generic_error_t **e /**< */) 879 { 880 return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 881 } 882 883 int 884 xcb_sync_await_sizeof (const void *_buffer /**< */, 885 uint32_t wait_list_len /**< */) 886 { 887 char *xcb_tmp = (char *)_buffer; 888 unsigned int xcb_buffer_len = 0; 889 unsigned int xcb_block_len = 0; 890 unsigned int xcb_pad = 0; 891 unsigned int xcb_align_to = 0; 892 893 894 xcb_block_len += sizeof(xcb_sync_await_request_t); 895 xcb_tmp += xcb_block_len; 896 xcb_buffer_len += xcb_block_len; 897 xcb_block_len = 0; 898 /* wait_list */ 899 xcb_block_len += wait_list_len * sizeof(xcb_sync_waitcondition_t); 900 xcb_tmp += xcb_block_len; 901 xcb_align_to = ALIGNOF(xcb_sync_waitcondition_t); 902 /* insert padding */ 903 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 904 xcb_buffer_len += xcb_block_len + xcb_pad; 905 if (0 != xcb_pad) { 906 xcb_tmp += xcb_pad; 907 xcb_pad = 0; 908 } 909 xcb_block_len = 0; 910 911 return xcb_buffer_len; 912 } 913 914 915 /***************************************************************************** 916 ** 917 ** xcb_void_cookie_t xcb_sync_await_checked 918 ** 919 ** @param xcb_connection_t *c 920 ** @param uint32_t wait_list_len 921 ** @param const xcb_sync_waitcondition_t *wait_list 922 ** @returns xcb_void_cookie_t 923 ** 924 *****************************************************************************/ 925 926 xcb_void_cookie_t 927 xcb_sync_await_checked (xcb_connection_t *c /**< */, 928 uint32_t wait_list_len /**< */, 929 const xcb_sync_waitcondition_t *wait_list /**< */) 930 { 931 static const xcb_protocol_request_t xcb_req = { 932 /* count */ 4, 933 /* ext */ &xcb_sync_id, 934 /* opcode */ XCB_SYNC_AWAIT, 935 /* isvoid */ 1 936 }; 937 938 struct iovec xcb_parts[6]; 939 xcb_void_cookie_t xcb_ret; 940 xcb_sync_await_request_t xcb_out; 941 942 943 xcb_parts[2].iov_base = (char *) &xcb_out; 944 xcb_parts[2].iov_len = sizeof(xcb_out); 945 xcb_parts[3].iov_base = 0; 946 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 947 /* xcb_sync_waitcondition_t wait_list */ 948 xcb_parts[4].iov_base = (char *) wait_list; 949 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); 950 xcb_parts[5].iov_base = 0; 951 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 952 953 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 954 return xcb_ret; 955 } 956 957 958 /***************************************************************************** 959 ** 960 ** xcb_void_cookie_t xcb_sync_await 961 ** 962 ** @param xcb_connection_t *c 963 ** @param uint32_t wait_list_len 964 ** @param const xcb_sync_waitcondition_t *wait_list 965 ** @returns xcb_void_cookie_t 966 ** 967 *****************************************************************************/ 968 969 xcb_void_cookie_t 970 xcb_sync_await (xcb_connection_t *c /**< */, 971 uint32_t wait_list_len /**< */, 972 const xcb_sync_waitcondition_t *wait_list /**< */) 973 { 974 static const xcb_protocol_request_t xcb_req = { 975 /* count */ 4, 976 /* ext */ &xcb_sync_id, 977 /* opcode */ XCB_SYNC_AWAIT, 978 /* isvoid */ 1 979 }; 980 981 struct iovec xcb_parts[6]; 982 xcb_void_cookie_t xcb_ret; 983 xcb_sync_await_request_t xcb_out; 984 985 986 xcb_parts[2].iov_base = (char *) &xcb_out; 987 xcb_parts[2].iov_len = sizeof(xcb_out); 988 xcb_parts[3].iov_base = 0; 989 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 990 /* xcb_sync_waitcondition_t wait_list */ 991 xcb_parts[4].iov_base = (char *) wait_list; 992 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); 993 xcb_parts[5].iov_base = 0; 994 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 995 996 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 997 return xcb_ret; 998 } 999 1000 1001 /***************************************************************************** 1002 ** 1003 ** xcb_void_cookie_t xcb_sync_change_counter_checked 1004 ** 1005 ** @param xcb_connection_t *c 1006 ** @param xcb_sync_counter_t counter 1007 ** @param xcb_sync_int64_t amount 1008 ** @returns xcb_void_cookie_t 1009 ** 1010 *****************************************************************************/ 1011 1012 xcb_void_cookie_t 1013 xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, 1014 xcb_sync_counter_t counter /**< */, 1015 xcb_sync_int64_t amount /**< */) 1016 { 1017 static const xcb_protocol_request_t xcb_req = { 1018 /* count */ 2, 1019 /* ext */ &xcb_sync_id, 1020 /* opcode */ XCB_SYNC_CHANGE_COUNTER, 1021 /* isvoid */ 1 1022 }; 1023 1024 struct iovec xcb_parts[4]; 1025 xcb_void_cookie_t xcb_ret; 1026 xcb_sync_change_counter_request_t xcb_out; 1027 1028 xcb_out.counter = counter; 1029 xcb_out.amount = amount; 1030 1031 xcb_parts[2].iov_base = (char *) &xcb_out; 1032 xcb_parts[2].iov_len = sizeof(xcb_out); 1033 xcb_parts[3].iov_base = 0; 1034 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1035 1036 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1037 return xcb_ret; 1038 } 1039 1040 1041 /***************************************************************************** 1042 ** 1043 ** xcb_void_cookie_t xcb_sync_change_counter 1044 ** 1045 ** @param xcb_connection_t *c 1046 ** @param xcb_sync_counter_t counter 1047 ** @param xcb_sync_int64_t amount 1048 ** @returns xcb_void_cookie_t 1049 ** 1050 *****************************************************************************/ 1051 1052 xcb_void_cookie_t 1053 xcb_sync_change_counter (xcb_connection_t *c /**< */, 1054 xcb_sync_counter_t counter /**< */, 1055 xcb_sync_int64_t amount /**< */) 1056 { 1057 static const xcb_protocol_request_t xcb_req = { 1058 /* count */ 2, 1059 /* ext */ &xcb_sync_id, 1060 /* opcode */ XCB_SYNC_CHANGE_COUNTER, 1061 /* isvoid */ 1 1062 }; 1063 1064 struct iovec xcb_parts[4]; 1065 xcb_void_cookie_t xcb_ret; 1066 xcb_sync_change_counter_request_t xcb_out; 1067 1068 xcb_out.counter = counter; 1069 xcb_out.amount = amount; 1070 1071 xcb_parts[2].iov_base = (char *) &xcb_out; 1072 xcb_parts[2].iov_len = sizeof(xcb_out); 1073 xcb_parts[3].iov_base = 0; 1074 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1075 1076 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1077 return xcb_ret; 1078 } 1079 1080 1081 /***************************************************************************** 1082 ** 1083 ** xcb_void_cookie_t xcb_sync_set_counter_checked 1084 ** 1085 ** @param xcb_connection_t *c 1086 ** @param xcb_sync_counter_t counter 1087 ** @param xcb_sync_int64_t value 1088 ** @returns xcb_void_cookie_t 1089 ** 1090 *****************************************************************************/ 1091 1092 xcb_void_cookie_t 1093 xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, 1094 xcb_sync_counter_t counter /**< */, 1095 xcb_sync_int64_t value /**< */) 1096 { 1097 static const xcb_protocol_request_t xcb_req = { 1098 /* count */ 2, 1099 /* ext */ &xcb_sync_id, 1100 /* opcode */ XCB_SYNC_SET_COUNTER, 1101 /* isvoid */ 1 1102 }; 1103 1104 struct iovec xcb_parts[4]; 1105 xcb_void_cookie_t xcb_ret; 1106 xcb_sync_set_counter_request_t xcb_out; 1107 1108 xcb_out.counter = counter; 1109 xcb_out.value = value; 1110 1111 xcb_parts[2].iov_base = (char *) &xcb_out; 1112 xcb_parts[2].iov_len = sizeof(xcb_out); 1113 xcb_parts[3].iov_base = 0; 1114 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1115 1116 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1117 return xcb_ret; 1118 } 1119 1120 1121 /***************************************************************************** 1122 ** 1123 ** xcb_void_cookie_t xcb_sync_set_counter 1124 ** 1125 ** @param xcb_connection_t *c 1126 ** @param xcb_sync_counter_t counter 1127 ** @param xcb_sync_int64_t value 1128 ** @returns xcb_void_cookie_t 1129 ** 1130 *****************************************************************************/ 1131 1132 xcb_void_cookie_t 1133 xcb_sync_set_counter (xcb_connection_t *c /**< */, 1134 xcb_sync_counter_t counter /**< */, 1135 xcb_sync_int64_t value /**< */) 1136 { 1137 static const xcb_protocol_request_t xcb_req = { 1138 /* count */ 2, 1139 /* ext */ &xcb_sync_id, 1140 /* opcode */ XCB_SYNC_SET_COUNTER, 1141 /* isvoid */ 1 1142 }; 1143 1144 struct iovec xcb_parts[4]; 1145 xcb_void_cookie_t xcb_ret; 1146 xcb_sync_set_counter_request_t xcb_out; 1147 1148 xcb_out.counter = counter; 1149 xcb_out.value = value; 1150 1151 xcb_parts[2].iov_base = (char *) &xcb_out; 1152 xcb_parts[2].iov_len = sizeof(xcb_out); 1153 xcb_parts[3].iov_base = 0; 1154 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1155 1156 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1157 return xcb_ret; 1158 } 1159 1160 int 1161 xcb_sync_create_alarm_value_list_serialize (void **_buffer /**< */, 1162 uint32_t value_mask /**< */, 1163 const xcb_sync_create_alarm_value_list_t *_aux /**< */) 1164 { 1165 char *xcb_out = *_buffer; 1166 unsigned int xcb_buffer_len = 0; 1167 unsigned int xcb_align_to = 0; 1168 1169 unsigned int xcb_pad = 0; 1170 char xcb_pad0[3] = {0, 0, 0}; 1171 struct iovec xcb_parts[7]; 1172 unsigned int xcb_parts_idx = 0; 1173 unsigned int xcb_block_len = 0; 1174 unsigned int i; 1175 char *xcb_tmp; 1176 1177 if(value_mask & XCB_SYNC_CA_COUNTER) { 1178 /* xcb_sync_create_alarm_value_list_t.counter */ 1179 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter; 1180 xcb_block_len += sizeof(xcb_sync_counter_t); 1181 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t); 1182 xcb_parts_idx++; 1183 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1184 } 1185 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1186 /* xcb_sync_create_alarm_value_list_t.valueType */ 1187 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType; 1188 xcb_block_len += sizeof(uint32_t); 1189 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1190 xcb_parts_idx++; 1191 xcb_align_to = ALIGNOF(uint32_t); 1192 } 1193 if(value_mask & XCB_SYNC_CA_VALUE) { 1194 /* xcb_sync_create_alarm_value_list_t.value */ 1195 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value; 1196 xcb_block_len += sizeof(xcb_sync_int64_t); 1197 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1198 xcb_parts_idx++; 1199 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1200 } 1201 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1202 /* xcb_sync_create_alarm_value_list_t.testType */ 1203 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType; 1204 xcb_block_len += sizeof(uint32_t); 1205 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1206 xcb_parts_idx++; 1207 xcb_align_to = ALIGNOF(uint32_t); 1208 } 1209 if(value_mask & XCB_SYNC_CA_DELTA) { 1210 /* xcb_sync_create_alarm_value_list_t.delta */ 1211 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta; 1212 xcb_block_len += sizeof(xcb_sync_int64_t); 1213 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1214 xcb_parts_idx++; 1215 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1216 } 1217 if(value_mask & XCB_SYNC_CA_EVENTS) { 1218 /* xcb_sync_create_alarm_value_list_t.events */ 1219 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events; 1220 xcb_block_len += sizeof(uint32_t); 1221 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1222 xcb_parts_idx++; 1223 xcb_align_to = ALIGNOF(uint32_t); 1224 } 1225 /* insert padding */ 1226 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1227 xcb_buffer_len += xcb_block_len + xcb_pad; 1228 if (0 != xcb_pad) { 1229 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 1230 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 1231 xcb_parts_idx++; 1232 xcb_pad = 0; 1233 } 1234 xcb_block_len = 0; 1235 1236 if (NULL == xcb_out) { 1237 /* allocate memory */ 1238 xcb_out = malloc(xcb_buffer_len); 1239 *_buffer = xcb_out; 1240 } 1241 1242 xcb_tmp = xcb_out; 1243 for(i=0; i<xcb_parts_idx; i++) { 1244 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 1245 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 1246 if (0 != xcb_parts[i].iov_len) 1247 xcb_tmp += xcb_parts[i].iov_len; 1248 } 1249 1250 return xcb_buffer_len; 1251 } 1252 1253 int 1254 xcb_sync_create_alarm_value_list_unpack (const void *_buffer /**< */, 1255 uint32_t value_mask /**< */, 1256 xcb_sync_create_alarm_value_list_t *_aux /**< */) 1257 { 1258 char *xcb_tmp = (char *)_buffer; 1259 unsigned int xcb_buffer_len = 0; 1260 unsigned int xcb_block_len = 0; 1261 unsigned int xcb_pad = 0; 1262 unsigned int xcb_align_to = 0; 1263 1264 1265 if(value_mask & XCB_SYNC_CA_COUNTER) { 1266 /* xcb_sync_create_alarm_value_list_t.counter */ 1267 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp; 1268 xcb_block_len += sizeof(xcb_sync_counter_t); 1269 xcb_tmp += sizeof(xcb_sync_counter_t); 1270 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1271 } 1272 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1273 /* xcb_sync_create_alarm_value_list_t.valueType */ 1274 _aux->valueType = *(uint32_t *)xcb_tmp; 1275 xcb_block_len += sizeof(uint32_t); 1276 xcb_tmp += sizeof(uint32_t); 1277 xcb_align_to = ALIGNOF(uint32_t); 1278 } 1279 if(value_mask & XCB_SYNC_CA_VALUE) { 1280 /* xcb_sync_create_alarm_value_list_t.value */ 1281 _aux->value = *(xcb_sync_int64_t *)xcb_tmp; 1282 xcb_block_len += sizeof(xcb_sync_int64_t); 1283 xcb_tmp += sizeof(xcb_sync_int64_t); 1284 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1285 } 1286 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1287 /* xcb_sync_create_alarm_value_list_t.testType */ 1288 _aux->testType = *(uint32_t *)xcb_tmp; 1289 xcb_block_len += sizeof(uint32_t); 1290 xcb_tmp += sizeof(uint32_t); 1291 xcb_align_to = ALIGNOF(uint32_t); 1292 } 1293 if(value_mask & XCB_SYNC_CA_DELTA) { 1294 /* xcb_sync_create_alarm_value_list_t.delta */ 1295 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp; 1296 xcb_block_len += sizeof(xcb_sync_int64_t); 1297 xcb_tmp += sizeof(xcb_sync_int64_t); 1298 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1299 } 1300 if(value_mask & XCB_SYNC_CA_EVENTS) { 1301 /* xcb_sync_create_alarm_value_list_t.events */ 1302 _aux->events = *(uint32_t *)xcb_tmp; 1303 xcb_block_len += sizeof(uint32_t); 1304 xcb_tmp += sizeof(uint32_t); 1305 xcb_align_to = ALIGNOF(uint32_t); 1306 } 1307 /* insert padding */ 1308 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1309 xcb_buffer_len += xcb_block_len + xcb_pad; 1310 if (0 != xcb_pad) { 1311 xcb_tmp += xcb_pad; 1312 xcb_pad = 0; 1313 } 1314 xcb_block_len = 0; 1315 1316 return xcb_buffer_len; 1317 } 1318 1319 int 1320 xcb_sync_create_alarm_value_list_sizeof (const void *_buffer /**< */, 1321 uint32_t value_mask /**< */) 1322 { 1323 xcb_sync_create_alarm_value_list_t _aux; 1324 return xcb_sync_create_alarm_value_list_unpack(_buffer, value_mask, &_aux); 1325 } 1326 1327 1328 /***************************************************************************** 1329 ** 1330 ** xcb_void_cookie_t xcb_sync_create_alarm_checked 1331 ** 1332 ** @param xcb_connection_t *c 1333 ** @param xcb_sync_alarm_t id 1334 ** @param uint32_t value_mask 1335 ** @param const void *value_list 1336 ** @returns xcb_void_cookie_t 1337 ** 1338 *****************************************************************************/ 1339 1340 xcb_void_cookie_t 1341 xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, 1342 xcb_sync_alarm_t id /**< */, 1343 uint32_t value_mask /**< */, 1344 const void *value_list /**< */) 1345 { 1346 static const xcb_protocol_request_t xcb_req = { 1347 /* count */ 3, 1348 /* ext */ &xcb_sync_id, 1349 /* opcode */ XCB_SYNC_CREATE_ALARM, 1350 /* isvoid */ 1 1351 }; 1352 1353 struct iovec xcb_parts[5]; 1354 xcb_void_cookie_t xcb_ret; 1355 xcb_sync_create_alarm_request_t xcb_out; 1356 1357 xcb_out.id = id; 1358 xcb_out.value_mask = value_mask; 1359 1360 xcb_parts[2].iov_base = (char *) &xcb_out; 1361 xcb_parts[2].iov_len = sizeof(xcb_out); 1362 xcb_parts[3].iov_base = 0; 1363 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1364 /* xcb_sync_create_alarm_value_list_t value_list */ 1365 xcb_parts[4].iov_base = (char *) value_list; 1366 xcb_parts[4].iov_len = 1367 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask); 1368 1369 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1370 return xcb_ret; 1371 } 1372 1373 1374 /***************************************************************************** 1375 ** 1376 ** xcb_void_cookie_t xcb_sync_create_alarm 1377 ** 1378 ** @param xcb_connection_t *c 1379 ** @param xcb_sync_alarm_t id 1380 ** @param uint32_t value_mask 1381 ** @param const void *value_list 1382 ** @returns xcb_void_cookie_t 1383 ** 1384 *****************************************************************************/ 1385 1386 xcb_void_cookie_t 1387 xcb_sync_create_alarm (xcb_connection_t *c /**< */, 1388 xcb_sync_alarm_t id /**< */, 1389 uint32_t value_mask /**< */, 1390 const void *value_list /**< */) 1391 { 1392 static const xcb_protocol_request_t xcb_req = { 1393 /* count */ 3, 1394 /* ext */ &xcb_sync_id, 1395 /* opcode */ XCB_SYNC_CREATE_ALARM, 1396 /* isvoid */ 1 1397 }; 1398 1399 struct iovec xcb_parts[5]; 1400 xcb_void_cookie_t xcb_ret; 1401 xcb_sync_create_alarm_request_t xcb_out; 1402 1403 xcb_out.id = id; 1404 xcb_out.value_mask = value_mask; 1405 1406 xcb_parts[2].iov_base = (char *) &xcb_out; 1407 xcb_parts[2].iov_len = sizeof(xcb_out); 1408 xcb_parts[3].iov_base = 0; 1409 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1410 /* xcb_sync_create_alarm_value_list_t value_list */ 1411 xcb_parts[4].iov_base = (char *) value_list; 1412 xcb_parts[4].iov_len = 1413 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask); 1414 1415 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1416 return xcb_ret; 1417 } 1418 1419 1420 /***************************************************************************** 1421 ** 1422 ** xcb_void_cookie_t xcb_sync_create_alarm_aux_checked 1423 ** 1424 ** @param xcb_connection_t *c 1425 ** @param xcb_sync_alarm_t id 1426 ** @param uint32_t value_mask 1427 ** @param const xcb_sync_create_alarm_value_list_t *value_list 1428 ** @returns xcb_void_cookie_t 1429 ** 1430 *****************************************************************************/ 1431 1432 xcb_void_cookie_t 1433 xcb_sync_create_alarm_aux_checked (xcb_connection_t *c /**< */, 1434 xcb_sync_alarm_t id /**< */, 1435 uint32_t value_mask /**< */, 1436 const xcb_sync_create_alarm_value_list_t *value_list /**< */) 1437 { 1438 static const xcb_protocol_request_t xcb_req = { 1439 /* count */ 3, 1440 /* ext */ &xcb_sync_id, 1441 /* opcode */ XCB_SYNC_CREATE_ALARM, 1442 /* isvoid */ 1 1443 }; 1444 1445 struct iovec xcb_parts[5]; 1446 xcb_void_cookie_t xcb_ret; 1447 xcb_sync_create_alarm_request_t xcb_out; 1448 void *xcb_aux0 = 0; 1449 1450 xcb_out.id = id; 1451 xcb_out.value_mask = value_mask; 1452 1453 xcb_parts[2].iov_base = (char *) &xcb_out; 1454 xcb_parts[2].iov_len = sizeof(xcb_out); 1455 xcb_parts[3].iov_base = 0; 1456 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1457 /* xcb_sync_create_alarm_value_list_t value_list */ 1458 xcb_parts[4].iov_len = 1459 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1460 xcb_parts[4].iov_base = xcb_aux0; 1461 1462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1463 free(xcb_aux0); 1464 return xcb_ret; 1465 } 1466 1467 1468 /***************************************************************************** 1469 ** 1470 ** xcb_void_cookie_t xcb_sync_create_alarm_aux 1471 ** 1472 ** @param xcb_connection_t *c 1473 ** @param xcb_sync_alarm_t id 1474 ** @param uint32_t value_mask 1475 ** @param const xcb_sync_create_alarm_value_list_t *value_list 1476 ** @returns xcb_void_cookie_t 1477 ** 1478 *****************************************************************************/ 1479 1480 xcb_void_cookie_t 1481 xcb_sync_create_alarm_aux (xcb_connection_t *c /**< */, 1482 xcb_sync_alarm_t id /**< */, 1483 uint32_t value_mask /**< */, 1484 const xcb_sync_create_alarm_value_list_t *value_list /**< */) 1485 { 1486 static const xcb_protocol_request_t xcb_req = { 1487 /* count */ 3, 1488 /* ext */ &xcb_sync_id, 1489 /* opcode */ XCB_SYNC_CREATE_ALARM, 1490 /* isvoid */ 1 1491 }; 1492 1493 struct iovec xcb_parts[5]; 1494 xcb_void_cookie_t xcb_ret; 1495 xcb_sync_create_alarm_request_t xcb_out; 1496 void *xcb_aux0 = 0; 1497 1498 xcb_out.id = id; 1499 xcb_out.value_mask = value_mask; 1500 1501 xcb_parts[2].iov_base = (char *) &xcb_out; 1502 xcb_parts[2].iov_len = sizeof(xcb_out); 1503 xcb_parts[3].iov_base = 0; 1504 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1505 /* xcb_sync_create_alarm_value_list_t value_list */ 1506 xcb_parts[4].iov_len = 1507 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1508 xcb_parts[4].iov_base = xcb_aux0; 1509 1510 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1511 free(xcb_aux0); 1512 return xcb_ret; 1513 } 1514 1515 int 1516 xcb_sync_change_alarm_value_list_serialize (void **_buffer /**< */, 1517 uint32_t value_mask /**< */, 1518 const xcb_sync_change_alarm_value_list_t *_aux /**< */) 1519 { 1520 char *xcb_out = *_buffer; 1521 unsigned int xcb_buffer_len = 0; 1522 unsigned int xcb_align_to = 0; 1523 1524 unsigned int xcb_pad = 0; 1525 char xcb_pad0[3] = {0, 0, 0}; 1526 struct iovec xcb_parts[7]; 1527 unsigned int xcb_parts_idx = 0; 1528 unsigned int xcb_block_len = 0; 1529 unsigned int i; 1530 char *xcb_tmp; 1531 1532 if(value_mask & XCB_SYNC_CA_COUNTER) { 1533 /* xcb_sync_change_alarm_value_list_t.counter */ 1534 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter; 1535 xcb_block_len += sizeof(xcb_sync_counter_t); 1536 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t); 1537 xcb_parts_idx++; 1538 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1539 } 1540 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1541 /* xcb_sync_change_alarm_value_list_t.valueType */ 1542 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType; 1543 xcb_block_len += sizeof(uint32_t); 1544 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1545 xcb_parts_idx++; 1546 xcb_align_to = ALIGNOF(uint32_t); 1547 } 1548 if(value_mask & XCB_SYNC_CA_VALUE) { 1549 /* xcb_sync_change_alarm_value_list_t.value */ 1550 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value; 1551 xcb_block_len += sizeof(xcb_sync_int64_t); 1552 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1553 xcb_parts_idx++; 1554 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1555 } 1556 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1557 /* xcb_sync_change_alarm_value_list_t.testType */ 1558 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType; 1559 xcb_block_len += sizeof(uint32_t); 1560 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1561 xcb_parts_idx++; 1562 xcb_align_to = ALIGNOF(uint32_t); 1563 } 1564 if(value_mask & XCB_SYNC_CA_DELTA) { 1565 /* xcb_sync_change_alarm_value_list_t.delta */ 1566 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta; 1567 xcb_block_len += sizeof(xcb_sync_int64_t); 1568 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1569 xcb_parts_idx++; 1570 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1571 } 1572 if(value_mask & XCB_SYNC_CA_EVENTS) { 1573 /* xcb_sync_change_alarm_value_list_t.events */ 1574 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events; 1575 xcb_block_len += sizeof(uint32_t); 1576 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1577 xcb_parts_idx++; 1578 xcb_align_to = ALIGNOF(uint32_t); 1579 } 1580 /* insert padding */ 1581 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1582 xcb_buffer_len += xcb_block_len + xcb_pad; 1583 if (0 != xcb_pad) { 1584 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 1585 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 1586 xcb_parts_idx++; 1587 xcb_pad = 0; 1588 } 1589 xcb_block_len = 0; 1590 1591 if (NULL == xcb_out) { 1592 /* allocate memory */ 1593 xcb_out = malloc(xcb_buffer_len); 1594 *_buffer = xcb_out; 1595 } 1596 1597 xcb_tmp = xcb_out; 1598 for(i=0; i<xcb_parts_idx; i++) { 1599 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 1600 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 1601 if (0 != xcb_parts[i].iov_len) 1602 xcb_tmp += xcb_parts[i].iov_len; 1603 } 1604 1605 return xcb_buffer_len; 1606 } 1607 1608 int 1609 xcb_sync_change_alarm_value_list_unpack (const void *_buffer /**< */, 1610 uint32_t value_mask /**< */, 1611 xcb_sync_change_alarm_value_list_t *_aux /**< */) 1612 { 1613 char *xcb_tmp = (char *)_buffer; 1614 unsigned int xcb_buffer_len = 0; 1615 unsigned int xcb_block_len = 0; 1616 unsigned int xcb_pad = 0; 1617 unsigned int xcb_align_to = 0; 1618 1619 1620 if(value_mask & XCB_SYNC_CA_COUNTER) { 1621 /* xcb_sync_change_alarm_value_list_t.counter */ 1622 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp; 1623 xcb_block_len += sizeof(xcb_sync_counter_t); 1624 xcb_tmp += sizeof(xcb_sync_counter_t); 1625 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1626 } 1627 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1628 /* xcb_sync_change_alarm_value_list_t.valueType */ 1629 _aux->valueType = *(uint32_t *)xcb_tmp; 1630 xcb_block_len += sizeof(uint32_t); 1631 xcb_tmp += sizeof(uint32_t); 1632 xcb_align_to = ALIGNOF(uint32_t); 1633 } 1634 if(value_mask & XCB_SYNC_CA_VALUE) { 1635 /* xcb_sync_change_alarm_value_list_t.value */ 1636 _aux->value = *(xcb_sync_int64_t *)xcb_tmp; 1637 xcb_block_len += sizeof(xcb_sync_int64_t); 1638 xcb_tmp += sizeof(xcb_sync_int64_t); 1639 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1640 } 1641 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1642 /* xcb_sync_change_alarm_value_list_t.testType */ 1643 _aux->testType = *(uint32_t *)xcb_tmp; 1644 xcb_block_len += sizeof(uint32_t); 1645 xcb_tmp += sizeof(uint32_t); 1646 xcb_align_to = ALIGNOF(uint32_t); 1647 } 1648 if(value_mask & XCB_SYNC_CA_DELTA) { 1649 /* xcb_sync_change_alarm_value_list_t.delta */ 1650 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp; 1651 xcb_block_len += sizeof(xcb_sync_int64_t); 1652 xcb_tmp += sizeof(xcb_sync_int64_t); 1653 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1654 } 1655 if(value_mask & XCB_SYNC_CA_EVENTS) { 1656 /* xcb_sync_change_alarm_value_list_t.events */ 1657 _aux->events = *(uint32_t *)xcb_tmp; 1658 xcb_block_len += sizeof(uint32_t); 1659 xcb_tmp += sizeof(uint32_t); 1660 xcb_align_to = ALIGNOF(uint32_t); 1661 } 1662 /* insert padding */ 1663 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1664 xcb_buffer_len += xcb_block_len + xcb_pad; 1665 if (0 != xcb_pad) { 1666 xcb_tmp += xcb_pad; 1667 xcb_pad = 0; 1668 } 1669 xcb_block_len = 0; 1670 1671 return xcb_buffer_len; 1672 } 1673 1674 int 1675 xcb_sync_change_alarm_value_list_sizeof (const void *_buffer /**< */, 1676 uint32_t value_mask /**< */) 1677 { 1678 xcb_sync_change_alarm_value_list_t _aux; 1679 return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux); 1680 } 1681 1682 1683 /***************************************************************************** 1684 ** 1685 ** xcb_void_cookie_t xcb_sync_change_alarm_checked 1686 ** 1687 ** @param xcb_connection_t *c 1688 ** @param xcb_sync_alarm_t id 1689 ** @param uint32_t value_mask 1690 ** @param const void *value_list 1691 ** @returns xcb_void_cookie_t 1692 ** 1693 *****************************************************************************/ 1694 1695 xcb_void_cookie_t 1696 xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, 1697 xcb_sync_alarm_t id /**< */, 1698 uint32_t value_mask /**< */, 1699 const void *value_list /**< */) 1700 { 1701 static const xcb_protocol_request_t xcb_req = { 1702 /* count */ 3, 1703 /* ext */ &xcb_sync_id, 1704 /* opcode */ XCB_SYNC_CHANGE_ALARM, 1705 /* isvoid */ 1 1706 }; 1707 1708 struct iovec xcb_parts[5]; 1709 xcb_void_cookie_t xcb_ret; 1710 xcb_sync_change_alarm_request_t xcb_out; 1711 1712 xcb_out.id = id; 1713 xcb_out.value_mask = value_mask; 1714 1715 xcb_parts[2].iov_base = (char *) &xcb_out; 1716 xcb_parts[2].iov_len = sizeof(xcb_out); 1717 xcb_parts[3].iov_base = 0; 1718 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1719 /* xcb_sync_change_alarm_value_list_t value_list */ 1720 xcb_parts[4].iov_base = (char *) value_list; 1721 xcb_parts[4].iov_len = 1722 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask); 1723 1724 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1725 return xcb_ret; 1726 } 1727 1728 1729 /***************************************************************************** 1730 ** 1731 ** xcb_void_cookie_t xcb_sync_change_alarm 1732 ** 1733 ** @param xcb_connection_t *c 1734 ** @param xcb_sync_alarm_t id 1735 ** @param uint32_t value_mask 1736 ** @param const void *value_list 1737 ** @returns xcb_void_cookie_t 1738 ** 1739 *****************************************************************************/ 1740 1741 xcb_void_cookie_t 1742 xcb_sync_change_alarm (xcb_connection_t *c /**< */, 1743 xcb_sync_alarm_t id /**< */, 1744 uint32_t value_mask /**< */, 1745 const void *value_list /**< */) 1746 { 1747 static const xcb_protocol_request_t xcb_req = { 1748 /* count */ 3, 1749 /* ext */ &xcb_sync_id, 1750 /* opcode */ XCB_SYNC_CHANGE_ALARM, 1751 /* isvoid */ 1 1752 }; 1753 1754 struct iovec xcb_parts[5]; 1755 xcb_void_cookie_t xcb_ret; 1756 xcb_sync_change_alarm_request_t xcb_out; 1757 1758 xcb_out.id = id; 1759 xcb_out.value_mask = value_mask; 1760 1761 xcb_parts[2].iov_base = (char *) &xcb_out; 1762 xcb_parts[2].iov_len = sizeof(xcb_out); 1763 xcb_parts[3].iov_base = 0; 1764 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1765 /* xcb_sync_change_alarm_value_list_t value_list */ 1766 xcb_parts[4].iov_base = (char *) value_list; 1767 xcb_parts[4].iov_len = 1768 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask); 1769 1770 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1771 return xcb_ret; 1772 } 1773 1774 1775 /***************************************************************************** 1776 ** 1777 ** xcb_void_cookie_t xcb_sync_change_alarm_aux_checked 1778 ** 1779 ** @param xcb_connection_t *c 1780 ** @param xcb_sync_alarm_t id 1781 ** @param uint32_t value_mask 1782 ** @param const xcb_sync_change_alarm_value_list_t *value_list 1783 ** @returns xcb_void_cookie_t 1784 ** 1785 *****************************************************************************/ 1786 1787 xcb_void_cookie_t 1788 xcb_sync_change_alarm_aux_checked (xcb_connection_t *c /**< */, 1789 xcb_sync_alarm_t id /**< */, 1790 uint32_t value_mask /**< */, 1791 const xcb_sync_change_alarm_value_list_t *value_list /**< */) 1792 { 1793 static const xcb_protocol_request_t xcb_req = { 1794 /* count */ 3, 1795 /* ext */ &xcb_sync_id, 1796 /* opcode */ XCB_SYNC_CHANGE_ALARM, 1797 /* isvoid */ 1 1798 }; 1799 1800 struct iovec xcb_parts[5]; 1801 xcb_void_cookie_t xcb_ret; 1802 xcb_sync_change_alarm_request_t xcb_out; 1803 void *xcb_aux0 = 0; 1804 1805 xcb_out.id = id; 1806 xcb_out.value_mask = value_mask; 1807 1808 xcb_parts[2].iov_base = (char *) &xcb_out; 1809 xcb_parts[2].iov_len = sizeof(xcb_out); 1810 xcb_parts[3].iov_base = 0; 1811 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1812 /* xcb_sync_change_alarm_value_list_t value_list */ 1813 xcb_parts[4].iov_len = 1814 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1815 xcb_parts[4].iov_base = xcb_aux0; 1816 1817 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1818 free(xcb_aux0); 1819 return xcb_ret; 1820 } 1821 1822 1823 /***************************************************************************** 1824 ** 1825 ** xcb_void_cookie_t xcb_sync_change_alarm_aux 1826 ** 1827 ** @param xcb_connection_t *c 1828 ** @param xcb_sync_alarm_t id 1829 ** @param uint32_t value_mask 1830 ** @param const xcb_sync_change_alarm_value_list_t *value_list 1831 ** @returns xcb_void_cookie_t 1832 ** 1833 *****************************************************************************/ 1834 1835 xcb_void_cookie_t 1836 xcb_sync_change_alarm_aux (xcb_connection_t *c /**< */, 1837 xcb_sync_alarm_t id /**< */, 1838 uint32_t value_mask /**< */, 1839 const xcb_sync_change_alarm_value_list_t *value_list /**< */) 1840 { 1841 static const xcb_protocol_request_t xcb_req = { 1842 /* count */ 3, 1843 /* ext */ &xcb_sync_id, 1844 /* opcode */ XCB_SYNC_CHANGE_ALARM, 1845 /* isvoid */ 1 1846 }; 1847 1848 struct iovec xcb_parts[5]; 1849 xcb_void_cookie_t xcb_ret; 1850 xcb_sync_change_alarm_request_t xcb_out; 1851 void *xcb_aux0 = 0; 1852 1853 xcb_out.id = id; 1854 xcb_out.value_mask = value_mask; 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 /* xcb_sync_change_alarm_value_list_t value_list */ 1861 xcb_parts[4].iov_len = 1862 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1863 xcb_parts[4].iov_base = xcb_aux0; 1864 1865 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1866 free(xcb_aux0); 1867 return xcb_ret; 1868 } 1869 1870 1871 /***************************************************************************** 1872 ** 1873 ** xcb_void_cookie_t xcb_sync_destroy_alarm_checked 1874 ** 1875 ** @param xcb_connection_t *c 1876 ** @param xcb_sync_alarm_t alarm 1877 ** @returns xcb_void_cookie_t 1878 ** 1879 *****************************************************************************/ 1880 1881 xcb_void_cookie_t 1882 xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, 1883 xcb_sync_alarm_t alarm /**< */) 1884 { 1885 static const xcb_protocol_request_t xcb_req = { 1886 /* count */ 2, 1887 /* ext */ &xcb_sync_id, 1888 /* opcode */ XCB_SYNC_DESTROY_ALARM, 1889 /* isvoid */ 1 1890 }; 1891 1892 struct iovec xcb_parts[4]; 1893 xcb_void_cookie_t xcb_ret; 1894 xcb_sync_destroy_alarm_request_t xcb_out; 1895 1896 xcb_out.alarm = alarm; 1897 1898 xcb_parts[2].iov_base = (char *) &xcb_out; 1899 xcb_parts[2].iov_len = sizeof(xcb_out); 1900 xcb_parts[3].iov_base = 0; 1901 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1902 1903 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1904 return xcb_ret; 1905 } 1906 1907 1908 /***************************************************************************** 1909 ** 1910 ** xcb_void_cookie_t xcb_sync_destroy_alarm 1911 ** 1912 ** @param xcb_connection_t *c 1913 ** @param xcb_sync_alarm_t alarm 1914 ** @returns xcb_void_cookie_t 1915 ** 1916 *****************************************************************************/ 1917 1918 xcb_void_cookie_t 1919 xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, 1920 xcb_sync_alarm_t alarm /**< */) 1921 { 1922 static const xcb_protocol_request_t xcb_req = { 1923 /* count */ 2, 1924 /* ext */ &xcb_sync_id, 1925 /* opcode */ XCB_SYNC_DESTROY_ALARM, 1926 /* isvoid */ 1 1927 }; 1928 1929 struct iovec xcb_parts[4]; 1930 xcb_void_cookie_t xcb_ret; 1931 xcb_sync_destroy_alarm_request_t xcb_out; 1932 1933 xcb_out.alarm = alarm; 1934 1935 xcb_parts[2].iov_base = (char *) &xcb_out; 1936 xcb_parts[2].iov_len = sizeof(xcb_out); 1937 xcb_parts[3].iov_base = 0; 1938 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1939 1940 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1941 return xcb_ret; 1942 } 1943 1944 1945 /***************************************************************************** 1946 ** 1947 ** xcb_sync_query_alarm_cookie_t xcb_sync_query_alarm 1948 ** 1949 ** @param xcb_connection_t *c 1950 ** @param xcb_sync_alarm_t alarm 1951 ** @returns xcb_sync_query_alarm_cookie_t 1952 ** 1953 *****************************************************************************/ 1954 1955 xcb_sync_query_alarm_cookie_t 1956 xcb_sync_query_alarm (xcb_connection_t *c /**< */, 1957 xcb_sync_alarm_t alarm /**< */) 1958 { 1959 static const xcb_protocol_request_t xcb_req = { 1960 /* count */ 2, 1961 /* ext */ &xcb_sync_id, 1962 /* opcode */ XCB_SYNC_QUERY_ALARM, 1963 /* isvoid */ 0 1964 }; 1965 1966 struct iovec xcb_parts[4]; 1967 xcb_sync_query_alarm_cookie_t xcb_ret; 1968 xcb_sync_query_alarm_request_t xcb_out; 1969 1970 xcb_out.alarm = alarm; 1971 1972 xcb_parts[2].iov_base = (char *) &xcb_out; 1973 xcb_parts[2].iov_len = sizeof(xcb_out); 1974 xcb_parts[3].iov_base = 0; 1975 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1976 1977 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1978 return xcb_ret; 1979 } 1980 1981 1982 /***************************************************************************** 1983 ** 1984 ** xcb_sync_query_alarm_cookie_t xcb_sync_query_alarm_unchecked 1985 ** 1986 ** @param xcb_connection_t *c 1987 ** @param xcb_sync_alarm_t alarm 1988 ** @returns xcb_sync_query_alarm_cookie_t 1989 ** 1990 *****************************************************************************/ 1991 1992 xcb_sync_query_alarm_cookie_t 1993 xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, 1994 xcb_sync_alarm_t alarm /**< */) 1995 { 1996 static const xcb_protocol_request_t xcb_req = { 1997 /* count */ 2, 1998 /* ext */ &xcb_sync_id, 1999 /* opcode */ XCB_SYNC_QUERY_ALARM, 2000 /* isvoid */ 0 2001 }; 2002 2003 struct iovec xcb_parts[4]; 2004 xcb_sync_query_alarm_cookie_t xcb_ret; 2005 xcb_sync_query_alarm_request_t xcb_out; 2006 2007 xcb_out.alarm = alarm; 2008 2009 xcb_parts[2].iov_base = (char *) &xcb_out; 2010 xcb_parts[2].iov_len = sizeof(xcb_out); 2011 xcb_parts[3].iov_base = 0; 2012 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2013 2014 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2015 return xcb_ret; 2016 } 2017 2018 2019 /***************************************************************************** 2020 ** 2021 ** xcb_sync_query_alarm_reply_t * xcb_sync_query_alarm_reply 2022 ** 2023 ** @param xcb_connection_t *c 2024 ** @param xcb_sync_query_alarm_cookie_t cookie 2025 ** @param xcb_generic_error_t **e 2026 ** @returns xcb_sync_query_alarm_reply_t * 2027 ** 2028 *****************************************************************************/ 2029 2030 xcb_sync_query_alarm_reply_t * 2031 xcb_sync_query_alarm_reply (xcb_connection_t *c /**< */, 2032 xcb_sync_query_alarm_cookie_t cookie /**< */, 2033 xcb_generic_error_t **e /**< */) 2034 { 2035 return (xcb_sync_query_alarm_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2036 } 2037 2038 2039 /***************************************************************************** 2040 ** 2041 ** xcb_void_cookie_t xcb_sync_set_priority_checked 2042 ** 2043 ** @param xcb_connection_t *c 2044 ** @param uint32_t id 2045 ** @param int32_t priority 2046 ** @returns xcb_void_cookie_t 2047 ** 2048 *****************************************************************************/ 2049 2050 xcb_void_cookie_t 2051 xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, 2052 uint32_t id /**< */, 2053 int32_t priority /**< */) 2054 { 2055 static const xcb_protocol_request_t xcb_req = { 2056 /* count */ 2, 2057 /* ext */ &xcb_sync_id, 2058 /* opcode */ XCB_SYNC_SET_PRIORITY, 2059 /* isvoid */ 1 2060 }; 2061 2062 struct iovec xcb_parts[4]; 2063 xcb_void_cookie_t xcb_ret; 2064 xcb_sync_set_priority_request_t xcb_out; 2065 2066 xcb_out.id = id; 2067 xcb_out.priority = priority; 2068 2069 xcb_parts[2].iov_base = (char *) &xcb_out; 2070 xcb_parts[2].iov_len = sizeof(xcb_out); 2071 xcb_parts[3].iov_base = 0; 2072 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2073 2074 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2075 return xcb_ret; 2076 } 2077 2078 2079 /***************************************************************************** 2080 ** 2081 ** xcb_void_cookie_t xcb_sync_set_priority 2082 ** 2083 ** @param xcb_connection_t *c 2084 ** @param uint32_t id 2085 ** @param int32_t priority 2086 ** @returns xcb_void_cookie_t 2087 ** 2088 *****************************************************************************/ 2089 2090 xcb_void_cookie_t 2091 xcb_sync_set_priority (xcb_connection_t *c /**< */, 2092 uint32_t id /**< */, 2093 int32_t priority /**< */) 2094 { 2095 static const xcb_protocol_request_t xcb_req = { 2096 /* count */ 2, 2097 /* ext */ &xcb_sync_id, 2098 /* opcode */ XCB_SYNC_SET_PRIORITY, 2099 /* isvoid */ 1 2100 }; 2101 2102 struct iovec xcb_parts[4]; 2103 xcb_void_cookie_t xcb_ret; 2104 xcb_sync_set_priority_request_t xcb_out; 2105 2106 xcb_out.id = id; 2107 xcb_out.priority = priority; 2108 2109 xcb_parts[2].iov_base = (char *) &xcb_out; 2110 xcb_parts[2].iov_len = sizeof(xcb_out); 2111 xcb_parts[3].iov_base = 0; 2112 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2113 2114 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2115 return xcb_ret; 2116 } 2117 2118 2119 /***************************************************************************** 2120 ** 2121 ** xcb_sync_get_priority_cookie_t xcb_sync_get_priority 2122 ** 2123 ** @param xcb_connection_t *c 2124 ** @param uint32_t id 2125 ** @returns xcb_sync_get_priority_cookie_t 2126 ** 2127 *****************************************************************************/ 2128 2129 xcb_sync_get_priority_cookie_t 2130 xcb_sync_get_priority (xcb_connection_t *c /**< */, 2131 uint32_t id /**< */) 2132 { 2133 static const xcb_protocol_request_t xcb_req = { 2134 /* count */ 2, 2135 /* ext */ &xcb_sync_id, 2136 /* opcode */ XCB_SYNC_GET_PRIORITY, 2137 /* isvoid */ 0 2138 }; 2139 2140 struct iovec xcb_parts[4]; 2141 xcb_sync_get_priority_cookie_t xcb_ret; 2142 xcb_sync_get_priority_request_t xcb_out; 2143 2144 xcb_out.id = id; 2145 2146 xcb_parts[2].iov_base = (char *) &xcb_out; 2147 xcb_parts[2].iov_len = sizeof(xcb_out); 2148 xcb_parts[3].iov_base = 0; 2149 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2150 2151 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2152 return xcb_ret; 2153 } 2154 2155 2156 /***************************************************************************** 2157 ** 2158 ** xcb_sync_get_priority_cookie_t xcb_sync_get_priority_unchecked 2159 ** 2160 ** @param xcb_connection_t *c 2161 ** @param uint32_t id 2162 ** @returns xcb_sync_get_priority_cookie_t 2163 ** 2164 *****************************************************************************/ 2165 2166 xcb_sync_get_priority_cookie_t 2167 xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, 2168 uint32_t id /**< */) 2169 { 2170 static const xcb_protocol_request_t xcb_req = { 2171 /* count */ 2, 2172 /* ext */ &xcb_sync_id, 2173 /* opcode */ XCB_SYNC_GET_PRIORITY, 2174 /* isvoid */ 0 2175 }; 2176 2177 struct iovec xcb_parts[4]; 2178 xcb_sync_get_priority_cookie_t xcb_ret; 2179 xcb_sync_get_priority_request_t xcb_out; 2180 2181 xcb_out.id = id; 2182 2183 xcb_parts[2].iov_base = (char *) &xcb_out; 2184 xcb_parts[2].iov_len = sizeof(xcb_out); 2185 xcb_parts[3].iov_base = 0; 2186 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2187 2188 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2189 return xcb_ret; 2190 } 2191 2192 2193 /***************************************************************************** 2194 ** 2195 ** xcb_sync_get_priority_reply_t * xcb_sync_get_priority_reply 2196 ** 2197 ** @param xcb_connection_t *c 2198 ** @param xcb_sync_get_priority_cookie_t cookie 2199 ** @param xcb_generic_error_t **e 2200 ** @returns xcb_sync_get_priority_reply_t * 2201 ** 2202 *****************************************************************************/ 2203 2204 xcb_sync_get_priority_reply_t * 2205 xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, 2206 xcb_sync_get_priority_cookie_t cookie /**< */, 2207 xcb_generic_error_t **e /**< */) 2208 { 2209 return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2210 } 2211 2212 2213 /***************************************************************************** 2214 ** 2215 ** xcb_void_cookie_t xcb_sync_create_fence_checked 2216 ** 2217 ** @param xcb_connection_t *c 2218 ** @param xcb_drawable_t drawable 2219 ** @param xcb_sync_fence_t fence 2220 ** @param uint8_t initially_triggered 2221 ** @returns xcb_void_cookie_t 2222 ** 2223 *****************************************************************************/ 2224 2225 xcb_void_cookie_t 2226 xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, 2227 xcb_drawable_t drawable /**< */, 2228 xcb_sync_fence_t fence /**< */, 2229 uint8_t initially_triggered /**< */) 2230 { 2231 static const xcb_protocol_request_t xcb_req = { 2232 /* count */ 2, 2233 /* ext */ &xcb_sync_id, 2234 /* opcode */ XCB_SYNC_CREATE_FENCE, 2235 /* isvoid */ 1 2236 }; 2237 2238 struct iovec xcb_parts[4]; 2239 xcb_void_cookie_t xcb_ret; 2240 xcb_sync_create_fence_request_t xcb_out; 2241 2242 xcb_out.drawable = drawable; 2243 xcb_out.fence = fence; 2244 xcb_out.initially_triggered = initially_triggered; 2245 2246 xcb_parts[2].iov_base = (char *) &xcb_out; 2247 xcb_parts[2].iov_len = sizeof(xcb_out); 2248 xcb_parts[3].iov_base = 0; 2249 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2250 2251 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2252 return xcb_ret; 2253 } 2254 2255 2256 /***************************************************************************** 2257 ** 2258 ** xcb_void_cookie_t xcb_sync_create_fence 2259 ** 2260 ** @param xcb_connection_t *c 2261 ** @param xcb_drawable_t drawable 2262 ** @param xcb_sync_fence_t fence 2263 ** @param uint8_t initially_triggered 2264 ** @returns xcb_void_cookie_t 2265 ** 2266 *****************************************************************************/ 2267 2268 xcb_void_cookie_t 2269 xcb_sync_create_fence (xcb_connection_t *c /**< */, 2270 xcb_drawable_t drawable /**< */, 2271 xcb_sync_fence_t fence /**< */, 2272 uint8_t initially_triggered /**< */) 2273 { 2274 static const xcb_protocol_request_t xcb_req = { 2275 /* count */ 2, 2276 /* ext */ &xcb_sync_id, 2277 /* opcode */ XCB_SYNC_CREATE_FENCE, 2278 /* isvoid */ 1 2279 }; 2280 2281 struct iovec xcb_parts[4]; 2282 xcb_void_cookie_t xcb_ret; 2283 xcb_sync_create_fence_request_t xcb_out; 2284 2285 xcb_out.drawable = drawable; 2286 xcb_out.fence = fence; 2287 xcb_out.initially_triggered = initially_triggered; 2288 2289 xcb_parts[2].iov_base = (char *) &xcb_out; 2290 xcb_parts[2].iov_len = sizeof(xcb_out); 2291 xcb_parts[3].iov_base = 0; 2292 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2293 2294 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2295 return xcb_ret; 2296 } 2297 2298 2299 /***************************************************************************** 2300 ** 2301 ** xcb_void_cookie_t xcb_sync_trigger_fence_checked 2302 ** 2303 ** @param xcb_connection_t *c 2304 ** @param xcb_sync_fence_t fence 2305 ** @returns xcb_void_cookie_t 2306 ** 2307 *****************************************************************************/ 2308 2309 xcb_void_cookie_t 2310 xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, 2311 xcb_sync_fence_t fence /**< */) 2312 { 2313 static const xcb_protocol_request_t xcb_req = { 2314 /* count */ 2, 2315 /* ext */ &xcb_sync_id, 2316 /* opcode */ XCB_SYNC_TRIGGER_FENCE, 2317 /* isvoid */ 1 2318 }; 2319 2320 struct iovec xcb_parts[4]; 2321 xcb_void_cookie_t xcb_ret; 2322 xcb_sync_trigger_fence_request_t xcb_out; 2323 2324 xcb_out.fence = fence; 2325 2326 xcb_parts[2].iov_base = (char *) &xcb_out; 2327 xcb_parts[2].iov_len = sizeof(xcb_out); 2328 xcb_parts[3].iov_base = 0; 2329 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2330 2331 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2332 return xcb_ret; 2333 } 2334 2335 2336 /***************************************************************************** 2337 ** 2338 ** xcb_void_cookie_t xcb_sync_trigger_fence 2339 ** 2340 ** @param xcb_connection_t *c 2341 ** @param xcb_sync_fence_t fence 2342 ** @returns xcb_void_cookie_t 2343 ** 2344 *****************************************************************************/ 2345 2346 xcb_void_cookie_t 2347 xcb_sync_trigger_fence (xcb_connection_t *c /**< */, 2348 xcb_sync_fence_t fence /**< */) 2349 { 2350 static const xcb_protocol_request_t xcb_req = { 2351 /* count */ 2, 2352 /* ext */ &xcb_sync_id, 2353 /* opcode */ XCB_SYNC_TRIGGER_FENCE, 2354 /* isvoid */ 1 2355 }; 2356 2357 struct iovec xcb_parts[4]; 2358 xcb_void_cookie_t xcb_ret; 2359 xcb_sync_trigger_fence_request_t xcb_out; 2360 2361 xcb_out.fence = fence; 2362 2363 xcb_parts[2].iov_base = (char *) &xcb_out; 2364 xcb_parts[2].iov_len = sizeof(xcb_out); 2365 xcb_parts[3].iov_base = 0; 2366 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2367 2368 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2369 return xcb_ret; 2370 } 2371 2372 2373 /***************************************************************************** 2374 ** 2375 ** xcb_void_cookie_t xcb_sync_reset_fence_checked 2376 ** 2377 ** @param xcb_connection_t *c 2378 ** @param xcb_sync_fence_t fence 2379 ** @returns xcb_void_cookie_t 2380 ** 2381 *****************************************************************************/ 2382 2383 xcb_void_cookie_t 2384 xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, 2385 xcb_sync_fence_t fence /**< */) 2386 { 2387 static const xcb_protocol_request_t xcb_req = { 2388 /* count */ 2, 2389 /* ext */ &xcb_sync_id, 2390 /* opcode */ XCB_SYNC_RESET_FENCE, 2391 /* isvoid */ 1 2392 }; 2393 2394 struct iovec xcb_parts[4]; 2395 xcb_void_cookie_t xcb_ret; 2396 xcb_sync_reset_fence_request_t xcb_out; 2397 2398 xcb_out.fence = fence; 2399 2400 xcb_parts[2].iov_base = (char *) &xcb_out; 2401 xcb_parts[2].iov_len = sizeof(xcb_out); 2402 xcb_parts[3].iov_base = 0; 2403 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2404 2405 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2406 return xcb_ret; 2407 } 2408 2409 2410 /***************************************************************************** 2411 ** 2412 ** xcb_void_cookie_t xcb_sync_reset_fence 2413 ** 2414 ** @param xcb_connection_t *c 2415 ** @param xcb_sync_fence_t fence 2416 ** @returns xcb_void_cookie_t 2417 ** 2418 *****************************************************************************/ 2419 2420 xcb_void_cookie_t 2421 xcb_sync_reset_fence (xcb_connection_t *c /**< */, 2422 xcb_sync_fence_t fence /**< */) 2423 { 2424 static const xcb_protocol_request_t xcb_req = { 2425 /* count */ 2, 2426 /* ext */ &xcb_sync_id, 2427 /* opcode */ XCB_SYNC_RESET_FENCE, 2428 /* isvoid */ 1 2429 }; 2430 2431 struct iovec xcb_parts[4]; 2432 xcb_void_cookie_t xcb_ret; 2433 xcb_sync_reset_fence_request_t xcb_out; 2434 2435 xcb_out.fence = fence; 2436 2437 xcb_parts[2].iov_base = (char *) &xcb_out; 2438 xcb_parts[2].iov_len = sizeof(xcb_out); 2439 xcb_parts[3].iov_base = 0; 2440 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2441 2442 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2443 return xcb_ret; 2444 } 2445 2446 2447 /***************************************************************************** 2448 ** 2449 ** xcb_void_cookie_t xcb_sync_destroy_fence_checked 2450 ** 2451 ** @param xcb_connection_t *c 2452 ** @param xcb_sync_fence_t fence 2453 ** @returns xcb_void_cookie_t 2454 ** 2455 *****************************************************************************/ 2456 2457 xcb_void_cookie_t 2458 xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, 2459 xcb_sync_fence_t fence /**< */) 2460 { 2461 static const xcb_protocol_request_t xcb_req = { 2462 /* count */ 2, 2463 /* ext */ &xcb_sync_id, 2464 /* opcode */ XCB_SYNC_DESTROY_FENCE, 2465 /* isvoid */ 1 2466 }; 2467 2468 struct iovec xcb_parts[4]; 2469 xcb_void_cookie_t xcb_ret; 2470 xcb_sync_destroy_fence_request_t xcb_out; 2471 2472 xcb_out.fence = fence; 2473 2474 xcb_parts[2].iov_base = (char *) &xcb_out; 2475 xcb_parts[2].iov_len = sizeof(xcb_out); 2476 xcb_parts[3].iov_base = 0; 2477 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2478 2479 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2480 return xcb_ret; 2481 } 2482 2483 2484 /***************************************************************************** 2485 ** 2486 ** xcb_void_cookie_t xcb_sync_destroy_fence 2487 ** 2488 ** @param xcb_connection_t *c 2489 ** @param xcb_sync_fence_t fence 2490 ** @returns xcb_void_cookie_t 2491 ** 2492 *****************************************************************************/ 2493 2494 xcb_void_cookie_t 2495 xcb_sync_destroy_fence (xcb_connection_t *c /**< */, 2496 xcb_sync_fence_t fence /**< */) 2497 { 2498 static const xcb_protocol_request_t xcb_req = { 2499 /* count */ 2, 2500 /* ext */ &xcb_sync_id, 2501 /* opcode */ XCB_SYNC_DESTROY_FENCE, 2502 /* isvoid */ 1 2503 }; 2504 2505 struct iovec xcb_parts[4]; 2506 xcb_void_cookie_t xcb_ret; 2507 xcb_sync_destroy_fence_request_t xcb_out; 2508 2509 xcb_out.fence = fence; 2510 2511 xcb_parts[2].iov_base = (char *) &xcb_out; 2512 xcb_parts[2].iov_len = sizeof(xcb_out); 2513 xcb_parts[3].iov_base = 0; 2514 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2515 2516 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2517 return xcb_ret; 2518 } 2519 2520 2521 /***************************************************************************** 2522 ** 2523 ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence 2524 ** 2525 ** @param xcb_connection_t *c 2526 ** @param xcb_sync_fence_t fence 2527 ** @returns xcb_sync_query_fence_cookie_t 2528 ** 2529 *****************************************************************************/ 2530 2531 xcb_sync_query_fence_cookie_t 2532 xcb_sync_query_fence (xcb_connection_t *c /**< */, 2533 xcb_sync_fence_t fence /**< */) 2534 { 2535 static const xcb_protocol_request_t xcb_req = { 2536 /* count */ 2, 2537 /* ext */ &xcb_sync_id, 2538 /* opcode */ XCB_SYNC_QUERY_FENCE, 2539 /* isvoid */ 0 2540 }; 2541 2542 struct iovec xcb_parts[4]; 2543 xcb_sync_query_fence_cookie_t xcb_ret; 2544 xcb_sync_query_fence_request_t xcb_out; 2545 2546 xcb_out.fence = fence; 2547 2548 xcb_parts[2].iov_base = (char *) &xcb_out; 2549 xcb_parts[2].iov_len = sizeof(xcb_out); 2550 xcb_parts[3].iov_base = 0; 2551 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2552 2553 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2554 return xcb_ret; 2555 } 2556 2557 2558 /***************************************************************************** 2559 ** 2560 ** xcb_sync_query_fence_cookie_t xcb_sync_query_fence_unchecked 2561 ** 2562 ** @param xcb_connection_t *c 2563 ** @param xcb_sync_fence_t fence 2564 ** @returns xcb_sync_query_fence_cookie_t 2565 ** 2566 *****************************************************************************/ 2567 2568 xcb_sync_query_fence_cookie_t 2569 xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, 2570 xcb_sync_fence_t fence /**< */) 2571 { 2572 static const xcb_protocol_request_t xcb_req = { 2573 /* count */ 2, 2574 /* ext */ &xcb_sync_id, 2575 /* opcode */ XCB_SYNC_QUERY_FENCE, 2576 /* isvoid */ 0 2577 }; 2578 2579 struct iovec xcb_parts[4]; 2580 xcb_sync_query_fence_cookie_t xcb_ret; 2581 xcb_sync_query_fence_request_t xcb_out; 2582 2583 xcb_out.fence = fence; 2584 2585 xcb_parts[2].iov_base = (char *) &xcb_out; 2586 xcb_parts[2].iov_len = sizeof(xcb_out); 2587 xcb_parts[3].iov_base = 0; 2588 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2589 2590 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2591 return xcb_ret; 2592 } 2593 2594 2595 /***************************************************************************** 2596 ** 2597 ** xcb_sync_query_fence_reply_t * xcb_sync_query_fence_reply 2598 ** 2599 ** @param xcb_connection_t *c 2600 ** @param xcb_sync_query_fence_cookie_t cookie 2601 ** @param xcb_generic_error_t **e 2602 ** @returns xcb_sync_query_fence_reply_t * 2603 ** 2604 *****************************************************************************/ 2605 2606 xcb_sync_query_fence_reply_t * 2607 xcb_sync_query_fence_reply (xcb_connection_t *c /**< */, 2608 xcb_sync_query_fence_cookie_t cookie /**< */, 2609 xcb_generic_error_t **e /**< */) 2610 { 2611 return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2612 } 2613 2614 int 2615 xcb_sync_await_fence_sizeof (const void *_buffer /**< */, 2616 uint32_t fence_list_len /**< */) 2617 { 2618 char *xcb_tmp = (char *)_buffer; 2619 unsigned int xcb_buffer_len = 0; 2620 unsigned int xcb_block_len = 0; 2621 unsigned int xcb_pad = 0; 2622 unsigned int xcb_align_to = 0; 2623 2624 2625 xcb_block_len += sizeof(xcb_sync_await_fence_request_t); 2626 xcb_tmp += xcb_block_len; 2627 xcb_buffer_len += xcb_block_len; 2628 xcb_block_len = 0; 2629 /* fence_list */ 2630 xcb_block_len += fence_list_len * sizeof(xcb_sync_fence_t); 2631 xcb_tmp += xcb_block_len; 2632 xcb_align_to = ALIGNOF(xcb_sync_fence_t); 2633 /* insert padding */ 2634 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2635 xcb_buffer_len += xcb_block_len + xcb_pad; 2636 if (0 != xcb_pad) { 2637 xcb_tmp += xcb_pad; 2638 xcb_pad = 0; 2639 } 2640 xcb_block_len = 0; 2641 2642 return xcb_buffer_len; 2643 } 2644 2645 2646 /***************************************************************************** 2647 ** 2648 ** xcb_void_cookie_t xcb_sync_await_fence_checked 2649 ** 2650 ** @param xcb_connection_t *c 2651 ** @param uint32_t fence_list_len 2652 ** @param const xcb_sync_fence_t *fence_list 2653 ** @returns xcb_void_cookie_t 2654 ** 2655 *****************************************************************************/ 2656 2657 xcb_void_cookie_t 2658 xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, 2659 uint32_t fence_list_len /**< */, 2660 const xcb_sync_fence_t *fence_list /**< */) 2661 { 2662 static const xcb_protocol_request_t xcb_req = { 2663 /* count */ 4, 2664 /* ext */ &xcb_sync_id, 2665 /* opcode */ XCB_SYNC_AWAIT_FENCE, 2666 /* isvoid */ 1 2667 }; 2668 2669 struct iovec xcb_parts[6]; 2670 xcb_void_cookie_t xcb_ret; 2671 xcb_sync_await_fence_request_t xcb_out; 2672 2673 2674 xcb_parts[2].iov_base = (char *) &xcb_out; 2675 xcb_parts[2].iov_len = sizeof(xcb_out); 2676 xcb_parts[3].iov_base = 0; 2677 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2678 /* xcb_sync_fence_t fence_list */ 2679 xcb_parts[4].iov_base = (char *) fence_list; 2680 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); 2681 xcb_parts[5].iov_base = 0; 2682 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2683 2684 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2685 return xcb_ret; 2686 } 2687 2688 2689 /***************************************************************************** 2690 ** 2691 ** xcb_void_cookie_t xcb_sync_await_fence 2692 ** 2693 ** @param xcb_connection_t *c 2694 ** @param uint32_t fence_list_len 2695 ** @param const xcb_sync_fence_t *fence_list 2696 ** @returns xcb_void_cookie_t 2697 ** 2698 *****************************************************************************/ 2699 2700 xcb_void_cookie_t 2701 xcb_sync_await_fence (xcb_connection_t *c /**< */, 2702 uint32_t fence_list_len /**< */, 2703 const xcb_sync_fence_t *fence_list /**< */) 2704 { 2705 static const xcb_protocol_request_t xcb_req = { 2706 /* count */ 4, 2707 /* ext */ &xcb_sync_id, 2708 /* opcode */ XCB_SYNC_AWAIT_FENCE, 2709 /* isvoid */ 1 2710 }; 2711 2712 struct iovec xcb_parts[6]; 2713 xcb_void_cookie_t xcb_ret; 2714 xcb_sync_await_fence_request_t xcb_out; 2715 2716 2717 xcb_parts[2].iov_base = (char *) &xcb_out; 2718 xcb_parts[2].iov_len = sizeof(xcb_out); 2719 xcb_parts[3].iov_base = 0; 2720 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2721 /* xcb_sync_fence_t fence_list */ 2722 xcb_parts[4].iov_base = (char *) fence_list; 2723 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); 2724 xcb_parts[5].iov_base = 0; 2725 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2726 2727 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2728 return xcb_ret; 2729 } 2730 2731
Indexes created Wed Mar 04 05:31:52 UTC 2026