hw/dmx/glxProxy/g_renderswap.c

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 #include "glxserver.h"
  32 #include "glxext.h"
  33 #include "g_disptab.h"
  34 #include "unpack.h"
  35 #include "compsize.h"
  36
  37 void
  38 __glXDispSwap_CallList(GLbyte * pc)
  39 {
  40     __GLX_DECLARE_SWAP_VARIABLES;
  41
  42     __GLX_SWAP_INT(pc + 0);
  43
  44 }
  45
  46 void
  47 __glXDispSwap_ListBase(GLbyte * pc)
  48 {
  49     __GLX_DECLARE_SWAP_VARIABLES;
  50
  51     __GLX_SWAP_INT(pc + 0);
  52
  53 }
  54
  55 void
  56 __glXDispSwap_Begin(GLbyte * pc)
  57 {
  58     __GLX_DECLARE_SWAP_VARIABLES;
  59
  60     __GLX_SWAP_INT(pc + 0);
  61
  62 }
  63
  64 void
  65 __glXDispSwap_Color3bv(GLbyte * pc)
  66 {
  67 }
  68
  69 void
  70 __glXDispSwap_Color3dv(GLbyte * pc)
  71 {
  72     __GLX_DECLARE_SWAP_VARIABLES;
  73     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
  74
  75 #ifdef __GLX_ALIGN64
  76     if ((unsigned long) (pc) & 7) {
  77         __GLX_MEM_COPY(pc - 4, pc, 24);
  78         pc -= 4;
  79     }
  80 #endif
  81     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
  82
  83 }
  84
  85 void
  86 __glXDispSwap_Color3fv(GLbyte * pc)
  87 {
  88     __GLX_DECLARE_SWAP_VARIABLES;
  89     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
  90
  91     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
  92 }
  93
  94 void
  95 __glXDispSwap_Color3iv(GLbyte * pc)
  96 {
  97     __GLX_DECLARE_SWAP_VARIABLES;
  98     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
  99
 100     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 101
 102 }
 103
 104 void
 105 __glXDispSwap_Color3sv(GLbyte * pc)
 106 {
 107     __GLX_DECLARE_SWAP_VARIABLES;
 108     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 109
 110     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 111
 112 }
 113
 114 void
 115 __glXDispSwap_Color3ubv(GLbyte * pc)
 116 {
 117 }
 118
 119 void
 120 __glXDispSwap_Color3uiv(GLbyte * pc)
 121 {
 122     __GLX_DECLARE_SWAP_VARIABLES;
 123     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 124
 125     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 126 }
 127
 128 void
 129 __glXDispSwap_Color3usv(GLbyte * pc)
 130 {
 131     __GLX_DECLARE_SWAP_VARIABLES;
 132     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 133
 134     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 135 }
 136
 137 void
 138 __glXDispSwap_Color4bv(GLbyte * pc)
 139 {
 140 }
 141
 142 void
 143 __glXDispSwap_Color4dv(GLbyte * pc)
 144 {
 145     __GLX_DECLARE_SWAP_VARIABLES;
 146     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 147
 148 #ifdef __GLX_ALIGN64
 149     if ((unsigned long) (pc) & 7) {
 150         __GLX_MEM_COPY(pc - 4, pc, 32);
 151         pc -= 4;
 152     }
 153 #endif
 154     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
 155 }
 156
 157 void
 158 __glXDispSwap_Color4fv(GLbyte * pc)
 159 {
 160     __GLX_DECLARE_SWAP_VARIABLES;
 161     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 162
 163     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
 164
 165 }
 166
 167 void
 168 __glXDispSwap_Color4iv(GLbyte * pc)
 169 {
 170     __GLX_DECLARE_SWAP_VARIABLES;
 171     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 172
 173     __GLX_SWAP_INT_ARRAY(pc + 0, 4);
 174
 175 }
 176
 177 void
 178 __glXDispSwap_Color4sv(GLbyte * pc)
 179 {
 180     __GLX_DECLARE_SWAP_VARIABLES;
 181     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 182
 183     __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
 184
 185 }
 186
 187 void
 188 __glXDispSwap_Color4ubv(GLbyte * pc)
 189 {
 190
 191 }
 192
 193 void
 194 __glXDispSwap_Color4uiv(GLbyte * pc)
 195 {
 196     __GLX_DECLARE_SWAP_VARIABLES;
 197     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 198
 199     __GLX_SWAP_INT_ARRAY(pc + 0, 4);
 200
 201 }
 202
 203 void
 204 __glXDispSwap_Color4usv(GLbyte * pc)
 205 {
 206     __GLX_DECLARE_SWAP_VARIABLES;
 207     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 208
 209     __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
 210
 211 }
 212
 213 void
 214 __glXDispSwap_EdgeFlagv(GLbyte * pc)
 215 {
 216 }
 217
 218 void
 219 __glXDispSwap_End(GLbyte * pc)
 220 {
 221 }
 222
 223 void
 224 __glXDispSwap_Indexdv(GLbyte * pc)
 225 {
 226     __GLX_DECLARE_SWAP_VARIABLES;
 227     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 228
 229 #ifdef __GLX_ALIGN64
 230     if ((unsigned long) (pc) & 7) {
 231         __GLX_MEM_COPY(pc - 4, pc, 8);
 232         pc -= 4;
 233     }
 234 #endif
 235     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
 236
 237 }
 238
 239 void
 240 __glXDispSwap_Indexfv(GLbyte * pc)
 241 {
 242     __GLX_DECLARE_SWAP_VARIABLES;
 243     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 244
 245     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
 246
 247 }
 248
 249 void
 250 __glXDispSwap_Indexiv(GLbyte * pc)
 251 {
 252     __GLX_DECLARE_SWAP_VARIABLES;
 253     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 254
 255     __GLX_SWAP_INT_ARRAY(pc + 0, 1);
 256
 257 }
 258
 259 void
 260 __glXDispSwap_Indexsv(GLbyte * pc)
 261 {
 262     __GLX_DECLARE_SWAP_VARIABLES;
 263     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 264
 265     __GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
 266
 267 }
 268
 269 void
 270 __glXDispSwap_Normal3bv(GLbyte * pc)
 271 {
 272 }
 273
 274 void
 275 __glXDispSwap_Normal3dv(GLbyte * pc)
 276 {
 277     __GLX_DECLARE_SWAP_VARIABLES;
 278     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 279
 280 #ifdef __GLX_ALIGN64
 281     if ((unsigned long) (pc) & 7) {
 282         __GLX_MEM_COPY(pc - 4, pc, 24);
 283         pc -= 4;
 284     }
 285 #endif
 286     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
 287
 288 }
 289
 290 void
 291 __glXDispSwap_Normal3fv(GLbyte * pc)
 292 {
 293     __GLX_DECLARE_SWAP_VARIABLES;
 294     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 295
 296     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
 297
 298 }
 299
 300 void
 301 __glXDispSwap_Normal3iv(GLbyte * pc)
 302 {
 303     __GLX_DECLARE_SWAP_VARIABLES;
 304     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 305
 306     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 307
 308 }
 309
 310 void
 311 __glXDispSwap_Normal3sv(GLbyte * pc)
 312 {
 313     __GLX_DECLARE_SWAP_VARIABLES;
 314     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 315
 316     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 317
 318 }
 319
 320 void
 321 __glXDispSwap_RasterPos2dv(GLbyte * pc)
 322 {
 323     __GLX_DECLARE_SWAP_VARIABLES;
 324     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 325
 326 #ifdef __GLX_ALIGN64
 327     if ((unsigned long) (pc) & 7) {
 328         __GLX_MEM_COPY(pc - 4, pc, 16);
 329         pc -= 4;
 330     }
 331 #endif
 332     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
 333
 334 }
 335
 336 void
 337 __glXDispSwap_RasterPos2fv(GLbyte * pc)
 338 {
 339     __GLX_DECLARE_SWAP_VARIABLES;
 340     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 341
 342     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
 343
 344 }
 345
 346 void
 347 __glXDispSwap_RasterPos2iv(GLbyte * pc)
 348 {
 349     __GLX_DECLARE_SWAP_VARIABLES;
 350     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 351
 352     __GLX_SWAP_INT_ARRAY(pc + 0, 2);
 353
 354 }
 355
 356 void
 357 __glXDispSwap_RasterPos2sv(GLbyte * pc)
 358 {
 359     __GLX_DECLARE_SWAP_VARIABLES;
 360     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 361
 362     __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
 363
 364 }
 365
 366 void
 367 __glXDispSwap_RasterPos3dv(GLbyte * pc)
 368 {
 369     __GLX_DECLARE_SWAP_VARIABLES;
 370     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 371
 372 #ifdef __GLX_ALIGN64
 373     if ((unsigned long) (pc) & 7) {
 374         __GLX_MEM_COPY(pc - 4, pc, 24);
 375         pc -= 4;
 376     }
 377 #endif
 378     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
 379
 380 }
 381
 382 void
 383 __glXDispSwap_RasterPos3fv(GLbyte * pc)
 384 {
 385     __GLX_DECLARE_SWAP_VARIABLES;
 386     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 387
 388     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
 389
 390 }
 391
 392 void
 393 __glXDispSwap_RasterPos3iv(GLbyte * pc)
 394 {
 395     __GLX_DECLARE_SWAP_VARIABLES;
 396     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 397
 398     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 399
 400 }
 401
 402 void
 403 __glXDispSwap_RasterPos3sv(GLbyte * pc)
 404 {
 405     __GLX_DECLARE_SWAP_VARIABLES;
 406     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 407
 408     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 409
 410 }
 411
 412 void
 413 __glXDispSwap_RasterPos4dv(GLbyte * pc)
 414 {
 415     __GLX_DECLARE_SWAP_VARIABLES;
 416     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 417
 418 #ifdef __GLX_ALIGN64
 419     if ((unsigned long) (pc) & 7) {
 420         __GLX_MEM_COPY(pc - 4, pc, 32);
 421         pc -= 4;
 422     }
 423 #endif
 424     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
 425
 426 }
 427
 428 void
 429 __glXDispSwap_RasterPos4fv(GLbyte * pc)
 430 {
 431     __GLX_DECLARE_SWAP_VARIABLES;
 432     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 433
 434     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
 435
 436 }
 437
 438 void
 439 __glXDispSwap_RasterPos4iv(GLbyte * pc)
 440 {
 441     __GLX_DECLARE_SWAP_VARIABLES;
 442     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 443
 444     __GLX_SWAP_INT_ARRAY(pc + 0, 4);
 445
 446 }
 447
 448 void
 449 __glXDispSwap_RasterPos4sv(GLbyte * pc)
 450 {
 451     __GLX_DECLARE_SWAP_VARIABLES;
 452     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 453
 454     __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
 455
 456 }
 457
 458 void
 459 __glXDispSwap_Rectdv(GLbyte * pc)
 460 {
 461     __GLX_DECLARE_SWAP_VARIABLES;
 462     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 463
 464 #ifdef __GLX_ALIGN64
 465     if ((unsigned long) (pc) & 7) {
 466         __GLX_MEM_COPY(pc - 4, pc, 32);
 467         pc -= 4;
 468     }
 469 #endif
 470     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
 471     __GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);
 472
 473 }
 474
 475 void
 476 __glXDispSwap_Rectfv(GLbyte * pc)
 477 {
 478     __GLX_DECLARE_SWAP_VARIABLES;
 479     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 480
 481     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
 482     __GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);
 483
 484 }
 485
 486 void
 487 __glXDispSwap_Rectiv(GLbyte * pc)
 488 {
 489     __GLX_DECLARE_SWAP_VARIABLES;
 490     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 491
 492     __GLX_SWAP_INT_ARRAY(pc + 0, 2);
 493     __GLX_SWAP_INT_ARRAY(pc + 8, 2);
 494
 495 }
 496
 497 void
 498 __glXDispSwap_Rectsv(GLbyte * pc)
 499 {
 500     __GLX_DECLARE_SWAP_VARIABLES;
 501     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 502
 503     __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
 504     __GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
 505
 506 }
 507
 508 void
 509 __glXDispSwap_TexCoord1dv(GLbyte * pc)
 510 {
 511     __GLX_DECLARE_SWAP_VARIABLES;
 512     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 513
 514 #ifdef __GLX_ALIGN64
 515     if ((unsigned long) (pc) & 7) {
 516         __GLX_MEM_COPY(pc - 4, pc, 8);
 517         pc -= 4;
 518     }
 519 #endif
 520     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
 521
 522 }
 523
 524 void
 525 __glXDispSwap_TexCoord1fv(GLbyte * pc)
 526 {
 527     __GLX_DECLARE_SWAP_VARIABLES;
 528     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 529
 530     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
 531
 532 }
 533
 534 void
 535 __glXDispSwap_TexCoord1iv(GLbyte * pc)
 536 {
 537     __GLX_DECLARE_SWAP_VARIABLES;
 538     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 539
 540     __GLX_SWAP_INT_ARRAY(pc + 0, 1);
 541
 542 }
 543
 544 void
 545 __glXDispSwap_TexCoord1sv(GLbyte * pc)
 546 {
 547     __GLX_DECLARE_SWAP_VARIABLES;
 548     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 549
 550     __GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
 551
 552 }
 553
 554 void
 555 __glXDispSwap_TexCoord2dv(GLbyte * pc)
 556 {
 557     __GLX_DECLARE_SWAP_VARIABLES;
 558     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 559
 560 #ifdef __GLX_ALIGN64
 561     if ((unsigned long) (pc) & 7) {
 562         __GLX_MEM_COPY(pc - 4, pc, 16);
 563         pc -= 4;
 564     }
 565 #endif
 566     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
 567
 568 }
 569
 570 void
 571 __glXDispSwap_TexCoord2fv(GLbyte * pc)
 572 {
 573     __GLX_DECLARE_SWAP_VARIABLES;
 574     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 575
 576     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
 577
 578 }
 579
 580 void
 581 __glXDispSwap_TexCoord2iv(GLbyte * pc)
 582 {
 583     __GLX_DECLARE_SWAP_VARIABLES;
 584     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 585
 586     __GLX_SWAP_INT_ARRAY(pc + 0, 2);
 587
 588 }
 589
 590 void
 591 __glXDispSwap_TexCoord2sv(GLbyte * pc)
 592 {
 593     __GLX_DECLARE_SWAP_VARIABLES;
 594     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 595
 596     __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
 597
 598 }
 599
 600 void
 601 __glXDispSwap_TexCoord3dv(GLbyte * pc)
 602 {
 603     __GLX_DECLARE_SWAP_VARIABLES;
 604     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 605
 606 #ifdef __GLX_ALIGN64
 607     if ((unsigned long) (pc) & 7) {
 608         __GLX_MEM_COPY(pc - 4, pc, 24);
 609         pc -= 4;
 610     }
 611 #endif
 612     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
 613
 614 }
 615
 616 void
 617 __glXDispSwap_TexCoord3fv(GLbyte * pc)
 618 {
 619     __GLX_DECLARE_SWAP_VARIABLES;
 620     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 621
 622     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
 623
 624 }
 625
 626 void
 627 __glXDispSwap_TexCoord3iv(GLbyte * pc)
 628 {
 629     __GLX_DECLARE_SWAP_VARIABLES;
 630     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 631
 632     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 633
 634 }
 635
 636 void
 637 __glXDispSwap_TexCoord3sv(GLbyte * pc)
 638 {
 639     __GLX_DECLARE_SWAP_VARIABLES;
 640     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 641
 642     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 643
 644 }
 645
 646 void
 647 __glXDispSwap_TexCoord4dv(GLbyte * pc)
 648 {
 649     __GLX_DECLARE_SWAP_VARIABLES;
 650     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 651
 652 #ifdef __GLX_ALIGN64
 653     if ((unsigned long) (pc) & 7) {
 654         __GLX_MEM_COPY(pc - 4, pc, 32);
 655         pc -= 4;
 656     }
 657 #endif
 658     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
 659
 660 }
 661
 662 void
 663 __glXDispSwap_TexCoord4fv(GLbyte * pc)
 664 {
 665     __GLX_DECLARE_SWAP_VARIABLES;
 666     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 667
 668     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
 669
 670 }
 671
 672 void
 673 __glXDispSwap_TexCoord4iv(GLbyte * pc)
 674 {
 675     __GLX_DECLARE_SWAP_VARIABLES;
 676     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 677
 678     __GLX_SWAP_INT_ARRAY(pc + 0, 4);
 679
 680 }
 681
 682 void
 683 __glXDispSwap_TexCoord4sv(GLbyte * pc)
 684 {
 685     __GLX_DECLARE_SWAP_VARIABLES;
 686     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 687
 688     __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
 689
 690 }
 691
 692 void
 693 __glXDispSwap_Vertex2dv(GLbyte * pc)
 694 {
 695     __GLX_DECLARE_SWAP_VARIABLES;
 696     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 697
 698 #ifdef __GLX_ALIGN64
 699     if ((unsigned long) (pc) & 7) {
 700         __GLX_MEM_COPY(pc - 4, pc, 16);
 701         pc -= 4;
 702     }
 703 #endif
 704     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
 705
 706 }
 707
 708 void
 709 __glXDispSwap_Vertex2fv(GLbyte * pc)
 710 {
 711     __GLX_DECLARE_SWAP_VARIABLES;
 712     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 713
 714     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
 715
 716 }
 717
 718 void
 719 __glXDispSwap_Vertex2iv(GLbyte * pc)
 720 {
 721     __GLX_DECLARE_SWAP_VARIABLES;
 722     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 723
 724     __GLX_SWAP_INT_ARRAY(pc + 0, 2);
 725
 726 }
 727
 728 void
 729 __glXDispSwap_Vertex2sv(GLbyte * pc)
 730 {
 731     __GLX_DECLARE_SWAP_VARIABLES;
 732     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 733
 734     __GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
 735
 736 }
 737
 738 void
 739 __glXDispSwap_Vertex3dv(GLbyte * pc)
 740 {
 741     __GLX_DECLARE_SWAP_VARIABLES;
 742     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 743
 744 #ifdef __GLX_ALIGN64
 745     if ((unsigned long) (pc) & 7) {
 746         __GLX_MEM_COPY(pc - 4, pc, 24);
 747         pc -= 4;
 748     }
 749 #endif
 750     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
 751
 752 }
 753
 754 void
 755 __glXDispSwap_Vertex3fv(GLbyte * pc)
 756 {
 757     __GLX_DECLARE_SWAP_VARIABLES;
 758     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 759
 760     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
 761
 762 }
 763
 764 void
 765 __glXDispSwap_Vertex3iv(GLbyte * pc)
 766 {
 767     __GLX_DECLARE_SWAP_VARIABLES;
 768     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 769
 770     __GLX_SWAP_INT_ARRAY(pc + 0, 3);
 771
 772 }
 773
 774 void
 775 __glXDispSwap_Vertex3sv(GLbyte * pc)
 776 {
 777     __GLX_DECLARE_SWAP_VARIABLES;
 778     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 779
 780     __GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
 781
 782 }
 783
 784 void
 785 __glXDispSwap_Vertex4dv(GLbyte * pc)
 786 {
 787     __GLX_DECLARE_SWAP_VARIABLES;
 788     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 789
 790 #ifdef __GLX_ALIGN64
 791     if ((unsigned long) (pc) & 7) {
 792         __GLX_MEM_COPY(pc - 4, pc, 32);
 793         pc -= 4;
 794     }
 795 #endif
 796     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
 797
 798 }
 799
 800 void
 801 __glXDispSwap_Vertex4fv(GLbyte * pc)
 802 {
 803     __GLX_DECLARE_SWAP_VARIABLES;
 804     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 805
 806     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
 807
 808 }
 809
 810 void
 811 __glXDispSwap_Vertex4iv(GLbyte * pc)
 812 {
 813     __GLX_DECLARE_SWAP_VARIABLES;
 814     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 815
 816     __GLX_SWAP_INT_ARRAY(pc + 0, 4);
 817
 818 }
 819
 820 void
 821 __glXDispSwap_Vertex4sv(GLbyte * pc)
 822 {
 823     __GLX_DECLARE_SWAP_VARIABLES;
 824     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 825
 826     __GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
 827
 828 }
 829
 830 void
 831 __glXDispSwap_ClipPlane(GLbyte * pc)
 832 {
 833     __GLX_DECLARE_SWAP_VARIABLES;
 834     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 835
 836 #ifdef __GLX_ALIGN64
 837     if ((unsigned long) (pc) & 7) {
 838         __GLX_MEM_COPY(pc - 4, pc, 36);
 839         pc -= 4;
 840     }
 841 #endif
 842     __GLX_SWAP_INT(pc + 32);
 843     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
 844
 845 }
 846
 847 void
 848 __glXDispSwap_ColorMaterial(GLbyte * pc)
 849 {
 850     __GLX_DECLARE_SWAP_VARIABLES;
 851
 852     __GLX_SWAP_INT(pc + 0);
 853     __GLX_SWAP_INT(pc + 4);
 854
 855 }
 856
 857 void
 858 __glXDispSwap_CullFace(GLbyte * pc)
 859 {
 860     __GLX_DECLARE_SWAP_VARIABLES;
 861
 862     __GLX_SWAP_INT(pc + 0);
 863
 864 }
 865
 866 void
 867 __glXDispSwap_Fogf(GLbyte * pc)
 868 {
 869     __GLX_DECLARE_SWAP_VARIABLES;
 870
 871     __GLX_SWAP_INT(pc + 0);
 872     __GLX_SWAP_FLOAT(pc + 4);
 873
 874 }
 875
 876 void
 877 __glXDispSwap_Fogfv(GLbyte * pc)
 878 {
 879     GLenum pname;
 880     GLint compsize;
 881
 882     __GLX_DECLARE_SWAP_VARIABLES;
 883     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 884
 885     __GLX_SWAP_INT(pc + 0);
 886     pname = *(GLenum *) (pc + 0);
 887     compsize = __glFogfv_size(pname);
 888     if (compsize < 0)
 889         compsize = 0;
 890     __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
 891
 892 }
 893
 894 void
 895 __glXDispSwap_Fogi(GLbyte * pc)
 896 {
 897     __GLX_DECLARE_SWAP_VARIABLES;
 898
 899     __GLX_SWAP_INT(pc + 0);
 900     __GLX_SWAP_INT(pc + 4);
 901
 902 }
 903
 904 void
 905 __glXDispSwap_Fogiv(GLbyte * pc)
 906 {
 907     GLenum pname;
 908     GLint compsize;
 909
 910     __GLX_DECLARE_SWAP_VARIABLES;
 911     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 912
 913     __GLX_SWAP_INT(pc + 0);
 914     pname = *(GLenum *) (pc + 0);
 915     compsize = __glFogiv_size(pname);
 916     if (compsize < 0)
 917         compsize = 0;
 918     __GLX_SWAP_INT_ARRAY(pc + 4, compsize);
 919
 920 }
 921
 922 void
 923 __glXDispSwap_FrontFace(GLbyte * pc)
 924 {
 925     __GLX_DECLARE_SWAP_VARIABLES;
 926
 927     __GLX_SWAP_INT(pc + 0);
 928
 929 }
 930
 931 void
 932 __glXDispSwap_Hint(GLbyte * pc)
 933 {
 934     __GLX_DECLARE_SWAP_VARIABLES;
 935
 936     __GLX_SWAP_INT(pc + 0);
 937     __GLX_SWAP_INT(pc + 4);
 938
 939 }
 940
 941 void
 942 __glXDispSwap_Lightf(GLbyte * pc)
 943 {
 944     __GLX_DECLARE_SWAP_VARIABLES;
 945
 946     __GLX_SWAP_INT(pc + 0);
 947     __GLX_SWAP_INT(pc + 4);
 948     __GLX_SWAP_FLOAT(pc + 8);
 949
 950 }
 951
 952 void
 953 __glXDispSwap_Lightfv(GLbyte * pc)
 954 {
 955     GLenum pname;
 956     GLint compsize;
 957
 958     __GLX_DECLARE_SWAP_VARIABLES;
 959     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 960
 961     __GLX_SWAP_INT(pc + 4);
 962     pname = *(GLenum *) (pc + 4);
 963     compsize = __glLightfv_size(pname);
 964     if (compsize < 0)
 965         compsize = 0;
 966     __GLX_SWAP_INT(pc + 0);
 967     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
 968
 969 }
 970
 971 void
 972 __glXDispSwap_Lighti(GLbyte * pc)
 973 {
 974     __GLX_DECLARE_SWAP_VARIABLES;
 975
 976     __GLX_SWAP_INT(pc + 0);
 977     __GLX_SWAP_INT(pc + 4);
 978     __GLX_SWAP_INT(pc + 8);
 979
 980 }
 981
 982 void
 983 __glXDispSwap_Lightiv(GLbyte * pc)
 984 {
 985     GLenum pname;
 986     GLint compsize;
 987
 988     __GLX_DECLARE_SWAP_VARIABLES;
 989     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 990
 991     __GLX_SWAP_INT(pc + 4);
 992     pname = *(GLenum *) (pc + 4);
 993     compsize = __glLightiv_size(pname);
 994     if (compsize < 0)
 995         compsize = 0;
 996     __GLX_SWAP_INT(pc + 0);
 997     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
 998
 999 }
1000
1001 void
1002 __glXDispSwap_LightModelf(GLbyte * pc)
1003 {
1004     __GLX_DECLARE_SWAP_VARIABLES;
1005
1006     __GLX_SWAP_INT(pc + 0);
1007     __GLX_SWAP_FLOAT(pc + 4);
1008
1009 }
1010
1011 void
1012 __glXDispSwap_LightModelfv(GLbyte * pc)
1013 {
1014     GLenum pname;
1015     GLint compsize;
1016
1017     __GLX_DECLARE_SWAP_VARIABLES;
1018     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1019
1020     __GLX_SWAP_INT(pc + 0);
1021     pname = *(GLenum *) (pc + 0);
1022     compsize = __glLightModelfv_size(pname);
1023     if (compsize < 0)
1024         compsize = 0;
1025     __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
1026
1027 }
1028
1029 void
1030 __glXDispSwap_LightModeli(GLbyte * pc)
1031 {
1032     __GLX_DECLARE_SWAP_VARIABLES;
1033
1034     __GLX_SWAP_INT(pc + 0);
1035     __GLX_SWAP_INT(pc + 4);
1036
1037 }
1038
1039 void
1040 __glXDispSwap_LightModeliv(GLbyte * pc)
1041 {
1042     GLenum pname;
1043     GLint compsize;
1044
1045     __GLX_DECLARE_SWAP_VARIABLES;
1046     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1047
1048     __GLX_SWAP_INT(pc + 0);
1049     pname = *(GLenum *) (pc + 0);
1050     compsize = __glLightModeliv_size(pname);
1051     if (compsize < 0)
1052         compsize = 0;
1053     __GLX_SWAP_INT_ARRAY(pc + 4, compsize);
1054
1055 }
1056
1057 void
1058 __glXDispSwap_LineStipple(GLbyte * pc)
1059 {
1060     __GLX_DECLARE_SWAP_VARIABLES;
1061
1062     __GLX_SWAP_INT(pc + 0);
1063     __GLX_SWAP_SHORT(pc + 4);
1064
1065 }
1066
1067 void
1068 __glXDispSwap_LineWidth(GLbyte * pc)
1069 {
1070     __GLX_DECLARE_SWAP_VARIABLES;
1071
1072     __GLX_SWAP_FLOAT(pc + 0);
1073
1074 }
1075
1076 void
1077 __glXDispSwap_Materialf(GLbyte * pc)
1078 {
1079     __GLX_DECLARE_SWAP_VARIABLES;
1080
1081     __GLX_SWAP_INT(pc + 0);
1082     __GLX_SWAP_INT(pc + 4);
1083     __GLX_SWAP_FLOAT(pc + 8);
1084
1085 }
1086
1087 void
1088 __glXDispSwap_Materialfv(GLbyte * pc)
1089 {
1090     GLenum pname;
1091     GLint compsize;
1092
1093     __GLX_DECLARE_SWAP_VARIABLES;
1094     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1095
1096     __GLX_SWAP_INT(pc + 4);
1097     pname = *(GLenum *) (pc + 4);
1098     compsize = __glMaterialfv_size(pname);
1099     if (compsize < 0)
1100         compsize = 0;
1101     __GLX_SWAP_INT(pc + 0);
1102     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1103
1104 }
1105
1106 void
1107 __glXDispSwap_Materiali(GLbyte * pc)
1108 {
1109     __GLX_DECLARE_SWAP_VARIABLES;
1110
1111     __GLX_SWAP_INT(pc + 0);
1112     __GLX_SWAP_INT(pc + 4);
1113     __GLX_SWAP_INT(pc + 8);
1114
1115 }
1116
1117 void
1118 __glXDispSwap_Materialiv(GLbyte * pc)
1119 {
1120     GLenum pname;
1121     GLint compsize;
1122
1123     __GLX_DECLARE_SWAP_VARIABLES;
1124     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1125
1126     __GLX_SWAP_INT(pc + 4);
1127     pname = *(GLenum *) (pc + 4);
1128     compsize = __glMaterialiv_size(pname);
1129     if (compsize < 0)
1130         compsize = 0;
1131     __GLX_SWAP_INT(pc + 0);
1132     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1133
1134 }
1135
1136 void
1137 __glXDispSwap_PointSize(GLbyte * pc)
1138 {
1139     __GLX_DECLARE_SWAP_VARIABLES;
1140
1141     __GLX_SWAP_FLOAT(pc + 0);
1142
1143 }
1144
1145 void
1146 __glXDispSwap_PolygonMode(GLbyte * pc)
1147 {
1148     __GLX_DECLARE_SWAP_VARIABLES;
1149
1150     __GLX_SWAP_INT(pc + 0);
1151     __GLX_SWAP_INT(pc + 4);
1152
1153 }
1154
1155 void
1156 __glXDispSwap_Scissor(GLbyte * pc)
1157 {
1158     __GLX_DECLARE_SWAP_VARIABLES;
1159
1160     __GLX_SWAP_INT(pc + 0);
1161     __GLX_SWAP_INT(pc + 4);
1162     __GLX_SWAP_INT(pc + 8);
1163     __GLX_SWAP_INT(pc + 12);
1164
1165 }
1166
1167 void
1168 __glXDispSwap_ShadeModel(GLbyte * pc)
1169 {
1170     __GLX_DECLARE_SWAP_VARIABLES;
1171
1172     __GLX_SWAP_INT(pc + 0);
1173
1174 }
1175
1176 void
1177 __glXDispSwap_TexParameterf(GLbyte * pc)
1178 {
1179     __GLX_DECLARE_SWAP_VARIABLES;
1180
1181     __GLX_SWAP_INT(pc + 0);
1182     __GLX_SWAP_INT(pc + 4);
1183     __GLX_SWAP_FLOAT(pc + 8);
1184
1185 }
1186
1187 void
1188 __glXDispSwap_TexParameterfv(GLbyte * pc)
1189 {
1190     GLenum pname;
1191     GLint compsize;
1192
1193     __GLX_DECLARE_SWAP_VARIABLES;
1194     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1195
1196     __GLX_SWAP_INT(pc + 4);
1197     pname = *(GLenum *) (pc + 4);
1198     compsize = __glTexParameterfv_size(pname);
1199     if (compsize < 0)
1200         compsize = 0;
1201     __GLX_SWAP_INT(pc + 0);
1202     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1203
1204 }
1205
1206 void
1207 __glXDispSwap_TexParameteri(GLbyte * pc)
1208 {
1209     __GLX_DECLARE_SWAP_VARIABLES;
1210
1211     __GLX_SWAP_INT(pc + 0);
1212     __GLX_SWAP_INT(pc + 4);
1213     __GLX_SWAP_INT(pc + 8);
1214
1215 }
1216
1217 void
1218 __glXDispSwap_TexParameteriv(GLbyte * pc)
1219 {
1220     GLenum pname;
1221     GLint compsize;
1222
1223     __GLX_DECLARE_SWAP_VARIABLES;
1224     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1225
1226     __GLX_SWAP_INT(pc + 4);
1227     pname = *(GLenum *) (pc + 4);
1228     compsize = __glTexParameteriv_size(pname);
1229     if (compsize < 0)
1230         compsize = 0;
1231     __GLX_SWAP_INT(pc + 0);
1232     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1233
1234 }
1235
1236 void
1237 __glXDispSwap_TexEnvf(GLbyte * pc)
1238 {
1239     __GLX_DECLARE_SWAP_VARIABLES;
1240
1241     __GLX_SWAP_INT(pc + 0);
1242     __GLX_SWAP_INT(pc + 4);
1243     __GLX_SWAP_FLOAT(pc + 8);
1244
1245 }
1246
1247 void
1248 __glXDispSwap_TexEnvfv(GLbyte * pc)
1249 {
1250     GLenum pname;
1251     GLint compsize;
1252
1253     __GLX_DECLARE_SWAP_VARIABLES;
1254     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1255
1256     __GLX_SWAP_INT(pc + 4);
1257     pname = *(GLenum *) (pc + 4);
1258     compsize = __glTexEnvfv_size(pname);
1259     if (compsize < 0)
1260         compsize = 0;
1261     __GLX_SWAP_INT(pc + 0);
1262     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1263
1264 }
1265
1266 void
1267 __glXDispSwap_TexEnvi(GLbyte * pc)
1268 {
1269     __GLX_DECLARE_SWAP_VARIABLES;
1270
1271     __GLX_SWAP_INT(pc + 0);
1272     __GLX_SWAP_INT(pc + 4);
1273     __GLX_SWAP_INT(pc + 8);
1274
1275 }
1276
1277 void
1278 __glXDispSwap_TexEnviv(GLbyte * pc)
1279 {
1280     GLenum pname;
1281     GLint compsize;
1282
1283     __GLX_DECLARE_SWAP_VARIABLES;
1284     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1285
1286     __GLX_SWAP_INT(pc + 4);
1287     pname = *(GLenum *) (pc + 4);
1288     compsize = __glTexEnviv_size(pname);
1289     if (compsize < 0)
1290         compsize = 0;
1291     __GLX_SWAP_INT(pc + 0);
1292     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1293
1294 }
1295
1296 void
1297 __glXDispSwap_TexGend(GLbyte * pc)
1298 {
1299     __GLX_DECLARE_SWAP_VARIABLES;
1300
1301 #ifdef __GLX_ALIGN64
1302     if ((unsigned long) (pc) & 7) {
1303         __GLX_MEM_COPY(pc - 4, pc, 16);
1304         pc -= 4;
1305     }
1306 #endif
1307     __GLX_SWAP_INT(pc + 8);
1308     __GLX_SWAP_INT(pc + 12);
1309     __GLX_SWAP_DOUBLE(pc + 0);
1310
1311 }
1312
1313 void
1314 __glXDispSwap_TexGendv(GLbyte * pc)
1315 {
1316     GLenum pname;
1317     GLint cmdlen;
1318     GLint compsize;
1319
1320     __GLX_DECLARE_SWAP_VARIABLES;
1321     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1322
1323     __GLX_SWAP_INT(pc + 4);
1324     pname = *(GLenum *) (pc + 4);
1325     compsize = __glTexGendv_size(pname);
1326     if (compsize < 0)
1327         compsize = 0;
1328     cmdlen = __GLX_PAD(8 + compsize * 8);
1329
1330 #ifdef __GLX_ALIGN64
1331     if ((unsigned long) (pc) & 7) {
1332         __GLX_MEM_COPY(pc - 4, pc, cmdlen);
1333         pc -= 4;
1334     }
1335 #endif
1336     __GLX_SWAP_INT(pc + 0);
1337     __GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);
1338
1339 }
1340
1341 void
1342 __glXDispSwap_TexGenf(GLbyte * pc)
1343 {
1344     __GLX_DECLARE_SWAP_VARIABLES;
1345
1346     __GLX_SWAP_INT(pc + 0);
1347     __GLX_SWAP_INT(pc + 4);
1348     __GLX_SWAP_FLOAT(pc + 8);
1349
1350 }
1351
1352 void
1353 __glXDispSwap_TexGenfv(GLbyte * pc)
1354 {
1355     GLenum pname;
1356     GLint compsize;
1357
1358     __GLX_DECLARE_SWAP_VARIABLES;
1359     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1360
1361     __GLX_SWAP_INT(pc + 4);
1362     pname = *(GLenum *) (pc + 4);
1363     compsize = __glTexGenfv_size(pname);
1364     if (compsize < 0)
1365         compsize = 0;
1366     __GLX_SWAP_INT(pc + 0);
1367     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
1368
1369 }
1370
1371 void
1372 __glXDispSwap_TexGeni(GLbyte * pc)
1373 {
1374     __GLX_DECLARE_SWAP_VARIABLES;
1375
1376     __GLX_SWAP_INT(pc + 0);
1377     __GLX_SWAP_INT(pc + 4);
1378     __GLX_SWAP_INT(pc + 8);
1379
1380 }
1381
1382 void
1383 __glXDispSwap_TexGeniv(GLbyte * pc)
1384 {
1385     GLenum pname;
1386     GLint compsize;
1387
1388     __GLX_DECLARE_SWAP_VARIABLES;
1389     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1390
1391     __GLX_SWAP_INT(pc + 4);
1392     pname = *(GLenum *) (pc + 4);
1393     compsize = __glTexGeniv_size(pname);
1394     if (compsize < 0)
1395         compsize = 0;
1396     __GLX_SWAP_INT(pc + 0);
1397     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
1398
1399 }
1400
1401 void
1402 __glXDispSwap_InitNames(GLbyte * pc)
1403 {
1404 }
1405
1406 void
1407 __glXDispSwap_LoadName(GLbyte * pc)
1408 {
1409     __GLX_DECLARE_SWAP_VARIABLES;
1410
1411     __GLX_SWAP_INT(pc + 0);
1412
1413 }
1414
1415 void
1416 __glXDispSwap_PassThrough(GLbyte * pc)
1417 {
1418     __GLX_DECLARE_SWAP_VARIABLES;
1419
1420     __GLX_SWAP_FLOAT(pc + 0);
1421
1422 }
1423
1424 void
1425 __glXDispSwap_PopName(GLbyte * pc)
1426 {
1427 }
1428
1429 void
1430 __glXDispSwap_PushName(GLbyte * pc)
1431 {
1432     __GLX_DECLARE_SWAP_VARIABLES;
1433
1434     __GLX_SWAP_INT(pc + 0);
1435
1436 }
1437
1438 void
1439 __glXDispSwap_DrawBuffer(GLbyte * pc)
1440 {
1441     __GLX_DECLARE_SWAP_VARIABLES;
1442
1443     __GLX_SWAP_INT(pc + 0);
1444
1445 }
1446
1447 void
1448 __glXDispSwap_Clear(GLbyte * pc)
1449 {
1450     __GLX_DECLARE_SWAP_VARIABLES;
1451
1452     __GLX_SWAP_INT(pc + 0);
1453
1454 }
1455
1456 void
1457 __glXDispSwap_ClearAccum(GLbyte * pc)
1458 {
1459     __GLX_DECLARE_SWAP_VARIABLES;
1460
1461     __GLX_SWAP_FLOAT(pc + 0);
1462     __GLX_SWAP_FLOAT(pc + 4);
1463     __GLX_SWAP_FLOAT(pc + 8);
1464     __GLX_SWAP_FLOAT(pc + 12);
1465
1466 }
1467
1468 void
1469 __glXDispSwap_ClearIndex(GLbyte * pc)
1470 {
1471     __GLX_DECLARE_SWAP_VARIABLES;
1472
1473     __GLX_SWAP_FLOAT(pc + 0);
1474
1475 }
1476
1477 void
1478 __glXDispSwap_ClearColor(GLbyte * pc)
1479 {
1480     __GLX_DECLARE_SWAP_VARIABLES;
1481
1482     __GLX_SWAP_FLOAT(pc + 0);
1483     __GLX_SWAP_FLOAT(pc + 4);
1484     __GLX_SWAP_FLOAT(pc + 8);
1485     __GLX_SWAP_FLOAT(pc + 12);
1486
1487 }
1488
1489 void
1490 __glXDispSwap_ClearStencil(GLbyte * pc)
1491 {
1492     __GLX_DECLARE_SWAP_VARIABLES;
1493
1494     __GLX_SWAP_INT(pc + 0);
1495
1496 }
1497
1498 void
1499 __glXDispSwap_ClearDepth(GLbyte * pc)
1500 {
1501     __GLX_DECLARE_SWAP_VARIABLES;
1502
1503 #ifdef __GLX_ALIGN64
1504     if ((unsigned long) (pc) & 7) {
1505         __GLX_MEM_COPY(pc - 4, pc, 8);
1506         pc -= 4;
1507     }
1508 #endif
1509     __GLX_SWAP_DOUBLE(pc + 0);
1510
1511 }
1512
1513 void
1514 __glXDispSwap_StencilMask(GLbyte * pc)
1515 {
1516     __GLX_DECLARE_SWAP_VARIABLES;
1517
1518     __GLX_SWAP_INT(pc + 0);
1519
1520 }
1521
1522 void
1523 __glXDispSwap_ColorMask(GLbyte * pc)
1524 {
1525 }
1526
1527 void
1528 __glXDispSwap_DepthMask(GLbyte * pc)
1529 {
1530 }
1531
1532 void
1533 __glXDispSwap_IndexMask(GLbyte * pc)
1534 {
1535     __GLX_DECLARE_SWAP_VARIABLES;
1536
1537     __GLX_SWAP_INT(pc + 0);
1538
1539 }
1540
1541 void
1542 __glXDispSwap_Accum(GLbyte * pc)
1543 {
1544     __GLX_DECLARE_SWAP_VARIABLES;
1545
1546     __GLX_SWAP_INT(pc + 0);
1547     __GLX_SWAP_FLOAT(pc + 4);
1548
1549 }
1550
1551 void
1552 __glXDispSwap_Disable(GLbyte * pc)
1553 {
1554     __GLX_DECLARE_SWAP_VARIABLES;
1555
1556     __GLX_SWAP_INT(pc + 0);
1557
1558 }
1559
1560 void
1561 __glXDispSwap_Enable(GLbyte * pc)
1562 {
1563     __GLX_DECLARE_SWAP_VARIABLES;
1564
1565     __GLX_SWAP_INT(pc + 0);
1566
1567 }
1568
1569 void
1570 __glXDispSwap_PopAttrib(GLbyte * pc)
1571 {
1572 }
1573
1574 void
1575 __glXDispSwap_PushAttrib(GLbyte * pc)
1576 {
1577     __GLX_DECLARE_SWAP_VARIABLES;
1578
1579     __GLX_SWAP_INT(pc + 0);
1580
1581 }
1582
1583 void
1584 __glXDispSwap_MapGrid1d(GLbyte * pc)
1585 {
1586     __GLX_DECLARE_SWAP_VARIABLES;
1587
1588 #ifdef __GLX_ALIGN64
1589     if ((unsigned long) (pc) & 7) {
1590         __GLX_MEM_COPY(pc - 4, pc, 20);
1591         pc -= 4;
1592     }
1593 #endif
1594     __GLX_SWAP_INT(pc + 16);
1595     __GLX_SWAP_DOUBLE(pc + 0);
1596     __GLX_SWAP_DOUBLE(pc + 8);
1597
1598 }
1599
1600 void
1601 __glXDispSwap_MapGrid1f(GLbyte * pc)
1602 {
1603     __GLX_DECLARE_SWAP_VARIABLES;
1604
1605     __GLX_SWAP_INT(pc + 0);
1606     __GLX_SWAP_FLOAT(pc + 4);
1607     __GLX_SWAP_FLOAT(pc + 8);
1608
1609 }
1610
1611 void
1612 __glXDispSwap_MapGrid2d(GLbyte * pc)
1613 {
1614     __GLX_DECLARE_SWAP_VARIABLES;
1615
1616 #ifdef __GLX_ALIGN64
1617     if ((unsigned long) (pc) & 7) {
1618         __GLX_MEM_COPY(pc - 4, pc, 40);
1619         pc -= 4;
1620     }
1621 #endif
1622     __GLX_SWAP_INT(pc + 32);
1623     __GLX_SWAP_DOUBLE(pc + 0);
1624     __GLX_SWAP_DOUBLE(pc + 8);
1625     __GLX_SWAP_INT(pc + 36);
1626     __GLX_SWAP_DOUBLE(pc + 16);
1627     __GLX_SWAP_DOUBLE(pc + 24);
1628
1629 }
1630
1631 void
1632 __glXDispSwap_MapGrid2f(GLbyte * pc)
1633 {
1634     __GLX_DECLARE_SWAP_VARIABLES;
1635
1636     __GLX_SWAP_INT(pc + 0);
1637     __GLX_SWAP_FLOAT(pc + 4);
1638     __GLX_SWAP_FLOAT(pc + 8);
1639     __GLX_SWAP_INT(pc + 12);
1640     __GLX_SWAP_FLOAT(pc + 16);
1641     __GLX_SWAP_FLOAT(pc + 20);
1642
1643 }
1644
1645 void
1646 __glXDispSwap_EvalCoord1dv(GLbyte * pc)
1647 {
1648     __GLX_DECLARE_SWAP_VARIABLES;
1649     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1650
1651 #ifdef __GLX_ALIGN64
1652     if ((unsigned long) (pc) & 7) {
1653         __GLX_MEM_COPY(pc - 4, pc, 8);
1654         pc -= 4;
1655     }
1656 #endif
1657     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
1658
1659 }
1660
1661 void
1662 __glXDispSwap_EvalCoord1fv(GLbyte * pc)
1663 {
1664     __GLX_DECLARE_SWAP_VARIABLES;
1665     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1666
1667     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
1668
1669 }
1670
1671 void
1672 __glXDispSwap_EvalCoord2dv(GLbyte * pc)
1673 {
1674     __GLX_DECLARE_SWAP_VARIABLES;
1675     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1676
1677 #ifdef __GLX_ALIGN64
1678     if ((unsigned long) (pc) & 7) {
1679         __GLX_MEM_COPY(pc - 4, pc, 16);
1680         pc -= 4;
1681     }
1682 #endif
1683     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
1684
1685 }
1686
1687 void
1688 __glXDispSwap_EvalCoord2fv(GLbyte * pc)
1689 {
1690     __GLX_DECLARE_SWAP_VARIABLES;
1691     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1692
1693     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
1694
1695 }
1696
1697 void
1698 __glXDispSwap_EvalMesh1(GLbyte * pc)
1699 {
1700     __GLX_DECLARE_SWAP_VARIABLES;
1701
1702     __GLX_SWAP_INT(pc + 0);
1703     __GLX_SWAP_INT(pc + 4);
1704     __GLX_SWAP_INT(pc + 8);
1705
1706 }
1707
1708 void
1709 __glXDispSwap_EvalPoint1(GLbyte * pc)
1710 {
1711     __GLX_DECLARE_SWAP_VARIABLES;
1712
1713     __GLX_SWAP_INT(pc + 0);
1714
1715 }
1716
1717 void
1718 __glXDispSwap_EvalMesh2(GLbyte * pc)
1719 {
1720     __GLX_DECLARE_SWAP_VARIABLES;
1721
1722     __GLX_SWAP_INT(pc + 0);
1723     __GLX_SWAP_INT(pc + 4);
1724     __GLX_SWAP_INT(pc + 8);
1725     __GLX_SWAP_INT(pc + 12);
1726     __GLX_SWAP_INT(pc + 16);
1727
1728 }
1729
1730 void
1731 __glXDispSwap_EvalPoint2(GLbyte * pc)
1732 {
1733     __GLX_DECLARE_SWAP_VARIABLES;
1734
1735     __GLX_SWAP_INT(pc + 0);
1736     __GLX_SWAP_INT(pc + 4);
1737
1738 }
1739
1740 void
1741 __glXDispSwap_AlphaFunc(GLbyte * pc)
1742 {
1743     __GLX_DECLARE_SWAP_VARIABLES;
1744
1745     __GLX_SWAP_INT(pc + 0);
1746     __GLX_SWAP_FLOAT(pc + 4);
1747
1748 }
1749
1750 void
1751 __glXDispSwap_BlendFunc(GLbyte * pc)
1752 {
1753     __GLX_DECLARE_SWAP_VARIABLES;
1754
1755     __GLX_SWAP_INT(pc + 0);
1756     __GLX_SWAP_INT(pc + 4);
1757
1758 }
1759
1760 void
1761 __glXDispSwap_LogicOp(GLbyte * pc)
1762 {
1763     __GLX_DECLARE_SWAP_VARIABLES;
1764
1765     __GLX_SWAP_INT(pc + 0);
1766
1767 }
1768
1769 void
1770 __glXDispSwap_StencilFunc(GLbyte * pc)
1771 {
1772     __GLX_DECLARE_SWAP_VARIABLES;
1773
1774     __GLX_SWAP_INT(pc + 0);
1775     __GLX_SWAP_INT(pc + 4);
1776     __GLX_SWAP_INT(pc + 8);
1777
1778 }
1779
1780 void
1781 __glXDispSwap_StencilOp(GLbyte * pc)
1782 {
1783     __GLX_DECLARE_SWAP_VARIABLES;
1784
1785     __GLX_SWAP_INT(pc + 0);
1786     __GLX_SWAP_INT(pc + 4);
1787     __GLX_SWAP_INT(pc + 8);
1788
1789 }
1790
1791 void
1792 __glXDispSwap_DepthFunc(GLbyte * pc)
1793 {
1794     __GLX_DECLARE_SWAP_VARIABLES;
1795
1796     __GLX_SWAP_INT(pc + 0);
1797
1798 }
1799
1800 void
1801 __glXDispSwap_PixelZoom(GLbyte * pc)
1802 {
1803     __GLX_DECLARE_SWAP_VARIABLES;
1804
1805     __GLX_SWAP_FLOAT(pc + 0);
1806     __GLX_SWAP_FLOAT(pc + 4);
1807
1808 }
1809
1810 void
1811 __glXDispSwap_PixelTransferf(GLbyte * pc)
1812 {
1813     __GLX_DECLARE_SWAP_VARIABLES;
1814
1815     __GLX_SWAP_INT(pc + 0);
1816     __GLX_SWAP_FLOAT(pc + 4);
1817
1818 }
1819
1820 void
1821 __glXDispSwap_PixelTransferi(GLbyte * pc)
1822 {
1823     __GLX_DECLARE_SWAP_VARIABLES;
1824
1825     __GLX_SWAP_INT(pc + 0);
1826     __GLX_SWAP_INT(pc + 4);
1827
1828 }
1829
1830 void
1831 __glXDispSwap_PixelMapfv(GLbyte * pc)
1832 {
1833     GLint mapsize;
1834
1835     __GLX_DECLARE_SWAP_VARIABLES;
1836     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1837
1838     __GLX_SWAP_INT(pc + 4);
1839     mapsize = *(GLint *) (pc + 4);
1840     __GLX_SWAP_INT(pc + 0);
1841     __GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);
1842
1843 }
1844
1845 void
1846 __glXDispSwap_PixelMapuiv(GLbyte * pc)
1847 {
1848     GLint mapsize;
1849
1850     __GLX_DECLARE_SWAP_VARIABLES;
1851     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1852
1853     __GLX_SWAP_INT(pc + 4);
1854     mapsize = *(GLint *) (pc + 4);
1855     __GLX_SWAP_INT(pc + 0);
1856     __GLX_SWAP_INT_ARRAY(pc + 8, mapsize);
1857
1858 }
1859
1860 void
1861 __glXDispSwap_PixelMapusv(GLbyte * pc)
1862 {
1863     GLint mapsize;
1864
1865     __GLX_DECLARE_SWAP_VARIABLES;
1866     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1867
1868     __GLX_SWAP_INT(pc + 4);
1869     mapsize = *(GLint *) (pc + 4);
1870     __GLX_SWAP_INT(pc + 0);
1871     __GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);
1872
1873 }
1874
1875 void
1876 __glXDispSwap_ReadBuffer(GLbyte * pc)
1877 {
1878     __GLX_DECLARE_SWAP_VARIABLES;
1879
1880     __GLX_SWAP_INT(pc + 0);
1881
1882 }
1883
1884 void
1885 __glXDispSwap_CopyPixels(GLbyte * pc)
1886 {
1887     __GLX_DECLARE_SWAP_VARIABLES;
1888
1889     __GLX_SWAP_INT(pc + 0);
1890     __GLX_SWAP_INT(pc + 4);
1891     __GLX_SWAP_INT(pc + 8);
1892     __GLX_SWAP_INT(pc + 12);
1893     __GLX_SWAP_INT(pc + 16);
1894
1895 }
1896
1897 void
1898 __glXDispSwap_DepthRange(GLbyte * pc)
1899 {
1900     __GLX_DECLARE_SWAP_VARIABLES;
1901
1902 #ifdef __GLX_ALIGN64
1903     if ((unsigned long) (pc) & 7) {
1904         __GLX_MEM_COPY(pc - 4, pc, 16);
1905         pc -= 4;
1906     }
1907 #endif
1908     __GLX_SWAP_DOUBLE(pc + 0);
1909     __GLX_SWAP_DOUBLE(pc + 8);
1910
1911 }
1912
1913 void
1914 __glXDispSwap_Frustum(GLbyte * pc)
1915 {
1916     __GLX_DECLARE_SWAP_VARIABLES;
1917
1918 #ifdef __GLX_ALIGN64
1919     if ((unsigned long) (pc) & 7) {
1920         __GLX_MEM_COPY(pc - 4, pc, 48);
1921         pc -= 4;
1922     }
1923 #endif
1924     __GLX_SWAP_DOUBLE(pc + 0);
1925     __GLX_SWAP_DOUBLE(pc + 8);
1926     __GLX_SWAP_DOUBLE(pc + 16);
1927     __GLX_SWAP_DOUBLE(pc + 24);
1928     __GLX_SWAP_DOUBLE(pc + 32);
1929     __GLX_SWAP_DOUBLE(pc + 40);
1930
1931 }
1932
1933 void
1934 __glXDispSwap_LoadIdentity(GLbyte * pc)
1935 {
1936 }
1937
1938 void
1939 __glXDispSwap_LoadMatrixf(GLbyte * pc)
1940 {
1941     __GLX_DECLARE_SWAP_VARIABLES;
1942     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1943
1944     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
1945
1946 }
1947
1948 void
1949 __glXDispSwap_LoadMatrixd(GLbyte * pc)
1950 {
1951     __GLX_DECLARE_SWAP_VARIABLES;
1952     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1953
1954 #ifdef __GLX_ALIGN64
1955     if ((unsigned long) (pc) & 7) {
1956         __GLX_MEM_COPY(pc - 4, pc, 128);
1957         pc -= 4;
1958     }
1959 #endif
1960     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
1961
1962 }
1963
1964 void
1965 __glXDispSwap_MatrixMode(GLbyte * pc)
1966 {
1967     __GLX_DECLARE_SWAP_VARIABLES;
1968
1969     __GLX_SWAP_INT(pc + 0);
1970
1971 }
1972
1973 void
1974 __glXDispSwap_MultMatrixf(GLbyte * pc)
1975 {
1976     __GLX_DECLARE_SWAP_VARIABLES;
1977     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1978
1979     __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
1980
1981 }
1982
1983 void
1984 __glXDispSwap_MultMatrixd(GLbyte * pc)
1985 {
1986     __GLX_DECLARE_SWAP_VARIABLES;
1987     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1988
1989 #ifdef __GLX_ALIGN64
1990     if ((unsigned long) (pc) & 7) {
1991         __GLX_MEM_COPY(pc - 4, pc, 128);
1992         pc -= 4;
1993     }
1994 #endif
1995     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
1996
1997 }
1998
1999 void
2000 __glXDispSwap_Ortho(GLbyte * pc)
2001 {
2002     __GLX_DECLARE_SWAP_VARIABLES;
2003
2004 #ifdef __GLX_ALIGN64
2005     if ((unsigned long) (pc) & 7) {
2006         __GLX_MEM_COPY(pc - 4, pc, 48);
2007         pc -= 4;
2008     }
2009 #endif
2010     __GLX_SWAP_DOUBLE(pc + 0);
2011     __GLX_SWAP_DOUBLE(pc + 8);
2012     __GLX_SWAP_DOUBLE(pc + 16);
2013     __GLX_SWAP_DOUBLE(pc + 24);
2014     __GLX_SWAP_DOUBLE(pc + 32);
2015     __GLX_SWAP_DOUBLE(pc + 40);
2016
2017 }
2018
2019 void
2020 __glXDispSwap_PopMatrix(GLbyte * pc)
2021 {
2022 }
2023
2024 void
2025 __glXDispSwap_PushMatrix(GLbyte * pc)
2026 {
2027 }
2028
2029 void
2030 __glXDispSwap_Rotated(GLbyte * pc)
2031 {
2032     __GLX_DECLARE_SWAP_VARIABLES;
2033
2034 #ifdef __GLX_ALIGN64
2035     if ((unsigned long) (pc) & 7) {
2036         __GLX_MEM_COPY(pc - 4, pc, 32);
2037         pc -= 4;
2038     }
2039 #endif
2040     __GLX_SWAP_DOUBLE(pc + 0);
2041     __GLX_SWAP_DOUBLE(pc + 8);
2042     __GLX_SWAP_DOUBLE(pc + 16);
2043     __GLX_SWAP_DOUBLE(pc + 24);
2044
2045 }
2046
2047 void
2048 __glXDispSwap_Rotatef(GLbyte * pc)
2049 {
2050     __GLX_DECLARE_SWAP_VARIABLES;
2051
2052     __GLX_SWAP_FLOAT(pc + 0);
2053     __GLX_SWAP_FLOAT(pc + 4);
2054     __GLX_SWAP_FLOAT(pc + 8);
2055     __GLX_SWAP_FLOAT(pc + 12);
2056
2057 }
2058
2059 void
2060 __glXDispSwap_Scaled(GLbyte * pc)
2061 {
2062     __GLX_DECLARE_SWAP_VARIABLES;
2063
2064 #ifdef __GLX_ALIGN64
2065     if ((unsigned long) (pc) & 7) {
2066         __GLX_MEM_COPY(pc - 4, pc, 24);
2067         pc -= 4;
2068     }
2069 #endif
2070     __GLX_SWAP_DOUBLE(pc + 0);
2071     __GLX_SWAP_DOUBLE(pc + 8);
2072     __GLX_SWAP_DOUBLE(pc + 16);
2073
2074 }
2075
2076 void
2077 __glXDispSwap_Scalef(GLbyte * pc)
2078 {
2079     __GLX_DECLARE_SWAP_VARIABLES;
2080
2081     __GLX_SWAP_FLOAT(pc + 0);
2082     __GLX_SWAP_FLOAT(pc + 4);
2083     __GLX_SWAP_FLOAT(pc + 8);
2084
2085 }
2086
2087 void
2088 __glXDispSwap_Translated(GLbyte * pc)
2089 {
2090     __GLX_DECLARE_SWAP_VARIABLES;
2091
2092 #ifdef __GLX_ALIGN64
2093     if ((unsigned long) (pc) & 7) {
2094         __GLX_MEM_COPY(pc - 4, pc, 24);
2095         pc -= 4;
2096     }
2097 #endif
2098     __GLX_SWAP_DOUBLE(pc + 0);
2099     __GLX_SWAP_DOUBLE(pc + 8);
2100     __GLX_SWAP_DOUBLE(pc + 16);
2101
2102 }
2103
2104 void
2105 __glXDispSwap_Translatef(GLbyte * pc)
2106 {
2107     __GLX_DECLARE_SWAP_VARIABLES;
2108
2109     __GLX_SWAP_FLOAT(pc + 0);
2110     __GLX_SWAP_FLOAT(pc + 4);
2111     __GLX_SWAP_FLOAT(pc + 8);
2112
2113 }
2114
2115 void
2116 __glXDispSwap_Viewport(GLbyte * pc)
2117 {
2118     __GLX_DECLARE_SWAP_VARIABLES;
2119
2120     __GLX_SWAP_INT(pc + 0);
2121     __GLX_SWAP_INT(pc + 4);
2122     __GLX_SWAP_INT(pc + 8);
2123     __GLX_SWAP_INT(pc + 12);
2124
2125 }
2126
2127 void
2128 __glXDispSwap_PolygonOffset(GLbyte * pc)
2129 {
2130     __GLX_DECLARE_SWAP_VARIABLES;
2131
2132     __GLX_SWAP_FLOAT(pc + 0);
2133     __GLX_SWAP_FLOAT(pc + 4);
2134
2135 }
2136
2137 void
2138 __glXDispSwap_CopyTexImage1D(GLbyte * pc)
2139 {
2140     __GLX_DECLARE_SWAP_VARIABLES;
2141
2142     __GLX_SWAP_INT(pc + 0);
2143     __GLX_SWAP_INT(pc + 4);
2144     __GLX_SWAP_INT(pc + 8);
2145     __GLX_SWAP_INT(pc + 12);
2146     __GLX_SWAP_INT(pc + 16);
2147     __GLX_SWAP_INT(pc + 20);
2148     __GLX_SWAP_INT(pc + 24);
2149
2150 }
2151
2152 void
2153 __glXDispSwap_CopyTexImage2D(GLbyte * pc)
2154 {
2155     __GLX_DECLARE_SWAP_VARIABLES;
2156
2157     __GLX_SWAP_INT(pc + 0);
2158     __GLX_SWAP_INT(pc + 4);
2159     __GLX_SWAP_INT(pc + 8);
2160     __GLX_SWAP_INT(pc + 12);
2161     __GLX_SWAP_INT(pc + 16);
2162     __GLX_SWAP_INT(pc + 20);
2163     __GLX_SWAP_INT(pc + 24);
2164     __GLX_SWAP_INT(pc + 28);
2165
2166 }
2167
2168 void
2169 __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
2170 {
2171     __GLX_DECLARE_SWAP_VARIABLES;
2172
2173     __GLX_SWAP_INT(pc + 0);
2174     __GLX_SWAP_INT(pc + 4);
2175     __GLX_SWAP_INT(pc + 8);
2176     __GLX_SWAP_INT(pc + 12);
2177     __GLX_SWAP_INT(pc + 16);
2178     __GLX_SWAP_INT(pc + 20);
2179
2180 }
2181
2182 void
2183 __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
2184 {
2185     __GLX_DECLARE_SWAP_VARIABLES;
2186
2187     __GLX_SWAP_INT(pc + 0);
2188     __GLX_SWAP_INT(pc + 4);
2189     __GLX_SWAP_INT(pc + 8);
2190     __GLX_SWAP_INT(pc + 12);
2191     __GLX_SWAP_INT(pc + 16);
2192     __GLX_SWAP_INT(pc + 20);
2193     __GLX_SWAP_INT(pc + 24);
2194     __GLX_SWAP_INT(pc + 28);
2195
2196 }
2197
2198 void
2199 __glXDispSwap_BindTexture(GLbyte * pc)
2200 {
2201     __GLX_DECLARE_SWAP_VARIABLES;
2202
2203     __GLX_SWAP_INT(pc + 0);
2204     __GLX_SWAP_INT(pc + 4);
2205
2206 }
2207
2208 void
2209 __glXDispSwap_PrioritizeTextures(GLbyte * pc)
2210 {
2211     GLsizei n;
2212
2213     __GLX_DECLARE_SWAP_VARIABLES;
2214     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2215
2216     __GLX_SWAP_INT(pc + 0);
2217     n = *(GLsizei *) (pc + 0);
2218     __GLX_SWAP_INT_ARRAY(pc + 4, n);
2219     __GLX_SWAP_FLOAT_ARRAY(pc + 4 + n * 4, n);
2220
2221 }
2222
2223 void
2224 __glXDispSwap_Indexubv(GLbyte * pc)
2225 {
2226 }
2227
2228 void
2229 __glXDispSwap_BlendColor(GLbyte * pc)
2230 {
2231     __GLX_DECLARE_SWAP_VARIABLES;
2232
2233     __GLX_SWAP_FLOAT(pc + 0);
2234     __GLX_SWAP_FLOAT(pc + 4);
2235     __GLX_SWAP_FLOAT(pc + 8);
2236     __GLX_SWAP_FLOAT(pc + 12);
2237
2238 }
2239
2240 void
2241 __glXDispSwap_BlendEquation(GLbyte * pc)
2242 {
2243     __GLX_DECLARE_SWAP_VARIABLES;
2244
2245     __GLX_SWAP_INT(pc + 0);
2246
2247 }
2248
2249 void
2250 __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
2251 {
2252     GLenum pname;
2253     GLint compsize;
2254
2255     __GLX_DECLARE_SWAP_VARIABLES;
2256     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2257
2258     __GLX_SWAP_INT(pc + 4);
2259     pname = *(GLenum *) (pc + 4);
2260     compsize = __glColorTableParameterfv_size(pname);
2261     if (compsize < 0)
2262         compsize = 0;
2263     __GLX_SWAP_INT(pc + 0);
2264     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
2265
2266 }
2267
2268 void
2269 __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
2270 {
2271     GLenum pname;
2272     GLint compsize;
2273
2274     __GLX_DECLARE_SWAP_VARIABLES;
2275     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2276
2277     __GLX_SWAP_INT(pc + 4);
2278     pname = *(GLenum *) (pc + 4);
2279     compsize = __glColorTableParameteriv_size(pname);
2280     if (compsize < 0)
2281         compsize = 0;
2282     __GLX_SWAP_INT(pc + 0);
2283     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
2284
2285 }
2286
2287 void
2288 __glXDispSwap_CopyColorTable(GLbyte * pc)
2289 {
2290     __GLX_DECLARE_SWAP_VARIABLES;
2291
2292     __GLX_SWAP_INT(pc + 0);
2293     __GLX_SWAP_INT(pc + 4);
2294     __GLX_SWAP_INT(pc + 8);
2295     __GLX_SWAP_INT(pc + 12);
2296     __GLX_SWAP_INT(pc + 16);
2297
2298 }
2299
2300 void
2301 __glXDispSwap_CopyColorSubTable(GLbyte * pc)
2302 {
2303     __GLX_DECLARE_SWAP_VARIABLES;
2304
2305     __GLX_SWAP_INT(pc + 0);
2306     __GLX_SWAP_INT(pc + 4);
2307     __GLX_SWAP_INT(pc + 8);
2308     __GLX_SWAP_INT(pc + 12);
2309     __GLX_SWAP_INT(pc + 16);
2310
2311 }
2312
2313 void
2314 __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
2315 {
2316     __GLX_DECLARE_SWAP_VARIABLES;
2317
2318     __GLX_SWAP_INT(pc + 0);
2319     __GLX_SWAP_INT(pc + 4);
2320     __GLX_SWAP_FLOAT(pc + 8);
2321
2322 }
2323
2324 void
2325 __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
2326 {
2327     GLenum pname;
2328     GLint compsize;
2329
2330     __GLX_DECLARE_SWAP_VARIABLES;
2331     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2332
2333     __GLX_SWAP_INT(pc + 4);
2334     pname = *(GLenum *) (pc + 4);
2335     compsize = __glConvolutionParameterfv_size(pname);
2336     if (compsize < 0)
2337         compsize = 0;
2338     __GLX_SWAP_INT(pc + 0);
2339     __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
2340
2341 }
2342
2343 void
2344 __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
2345 {
2346     __GLX_DECLARE_SWAP_VARIABLES;
2347
2348     __GLX_SWAP_INT(pc + 0);
2349     __GLX_SWAP_INT(pc + 4);
2350     __GLX_SWAP_INT(pc + 8);
2351
2352 }
2353
2354 void
2355 __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
2356 {
2357     GLenum pname;
2358     GLint compsize;
2359
2360     __GLX_DECLARE_SWAP_VARIABLES;
2361     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2362
2363     __GLX_SWAP_INT(pc + 4);
2364     pname = *(GLenum *) (pc + 4);
2365     compsize = __glConvolutionParameteriv_size(pname);
2366     if (compsize < 0)
2367         compsize = 0;
2368     __GLX_SWAP_INT(pc + 0);
2369     __GLX_SWAP_INT_ARRAY(pc + 8, compsize);
2370
2371 }
2372
2373 void
2374 __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
2375 {
2376     __GLX_DECLARE_SWAP_VARIABLES;
2377
2378     __GLX_SWAP_INT(pc + 0);
2379     __GLX_SWAP_INT(pc + 4);
2380     __GLX_SWAP_INT(pc + 8);
2381     __GLX_SWAP_INT(pc + 12);
2382     __GLX_SWAP_INT(pc + 16);
2383
2384 }
2385
2386 void
2387 __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
2388 {
2389     __GLX_DECLARE_SWAP_VARIABLES;
2390
2391     __GLX_SWAP_INT(pc + 0);
2392     __GLX_SWAP_INT(pc + 4);
2393     __GLX_SWAP_INT(pc + 8);
2394     __GLX_SWAP_INT(pc + 12);
2395     __GLX_SWAP_INT(pc + 16);
2396     __GLX_SWAP_INT(pc + 20);
2397
2398 }
2399
2400 void
2401 __glXDispSwap_Histogram(GLbyte * pc)
2402 {
2403     __GLX_DECLARE_SWAP_VARIABLES;
2404
2405     __GLX_SWAP_INT(pc + 0);
2406     __GLX_SWAP_INT(pc + 4);
2407     __GLX_SWAP_INT(pc + 8);
2408
2409 }
2410
2411 void
2412 __glXDispSwap_Minmax(GLbyte * pc)
2413 {
2414     __GLX_DECLARE_SWAP_VARIABLES;
2415
2416     __GLX_SWAP_INT(pc + 0);
2417     __GLX_SWAP_INT(pc + 4);
2418
2419 }
2420
2421 void
2422 __glXDispSwap_ResetHistogram(GLbyte * pc)
2423 {
2424     __GLX_DECLARE_SWAP_VARIABLES;
2425
2426     __GLX_SWAP_INT(pc + 0);
2427
2428 }
2429
2430 void
2431 __glXDispSwap_ResetMinmax(GLbyte * pc)
2432 {
2433     __GLX_DECLARE_SWAP_VARIABLES;
2434
2435     __GLX_SWAP_INT(pc + 0);
2436
2437 }
2438
2439 void
2440 __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
2441 {
2442     __GLX_DECLARE_SWAP_VARIABLES;
2443
2444     __GLX_SWAP_INT(pc + 0);
2445     __GLX_SWAP_INT(pc + 4);
2446     __GLX_SWAP_INT(pc + 8);
2447     __GLX_SWAP_INT(pc + 12);
2448     __GLX_SWAP_INT(pc + 16);
2449     __GLX_SWAP_INT(pc + 20);
2450     __GLX_SWAP_INT(pc + 24);
2451     __GLX_SWAP_INT(pc + 28);
2452     __GLX_SWAP_INT(pc + 32);
2453
2454 }
2455
2456 void
2457 __glXDispSwap_ActiveTextureARB(GLbyte * pc)
2458 {
2459     __GLX_DECLARE_SWAP_VARIABLES;
2460
2461     __GLX_SWAP_INT(pc + 0);
2462
2463 }
2464
2465 void
2466 __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc)
2467 {
2468     __GLX_DECLARE_SWAP_VARIABLES;
2469     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2470
2471 #ifdef __GLX_ALIGN64
2472     if ((unsigned long) (pc) & 7) {
2473         __GLX_MEM_COPY(pc - 4, pc, 12);
2474         pc -= 4;
2475     }
2476 #endif
2477     __GLX_SWAP_INT(pc + 8);
2478     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
2479
2480 }
2481
2482 void
2483 __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
2484 {
2485     __GLX_DECLARE_SWAP_VARIABLES;
2486     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2487
2488     __GLX_SWAP_INT(pc + 0);
2489     __GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);
2490
2491 }
2492
2493 void
2494 __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc)
2495 {
2496     __GLX_DECLARE_SWAP_VARIABLES;
2497     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2498
2499     __GLX_SWAP_INT(pc + 0);
2500     __GLX_SWAP_INT_ARRAY(pc + 4, 1);
2501
2502 }
2503
2504 void
2505 __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc)
2506 {
2507     __GLX_DECLARE_SWAP_VARIABLES;
2508     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2509
2510     __GLX_SWAP_INT(pc + 0);
2511     __GLX_SWAP_SHORT_ARRAY(pc + 4, 1);
2512
2513 }
2514
2515 void
2516 __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc)
2517 {
2518     __GLX_DECLARE_SWAP_VARIABLES;
2519     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2520
2521 #ifdef __GLX_ALIGN64
2522     if ((unsigned long) (pc) & 7) {
2523         __GLX_MEM_COPY(pc - 4, pc, 20);
2524         pc -= 4;
2525     }
2526 #endif
2527     __GLX_SWAP_INT(pc + 16);
2528     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
2529
2530 }
2531
2532 void
2533 __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
2534 {
2535     __GLX_DECLARE_SWAP_VARIABLES;
2536     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2537
2538     __GLX_SWAP_INT(pc + 0);
2539     __GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);
2540
2541 }
2542
2543 void
2544 __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc)
2545 {
2546     __GLX_DECLARE_SWAP_VARIABLES;
2547     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2548
2549     __GLX_SWAP_INT(pc + 0);
2550     __GLX_SWAP_INT_ARRAY(pc + 4, 2);
2551
2552 }
2553
2554 void
2555 __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc)
2556 {
2557     __GLX_DECLARE_SWAP_VARIABLES;
2558     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2559
2560     __GLX_SWAP_INT(pc + 0);
2561     __GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
2562
2563 }
2564
2565 void
2566 __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc)
2567 {
2568     __GLX_DECLARE_SWAP_VARIABLES;
2569     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2570
2571 #ifdef __GLX_ALIGN64
2572     if ((unsigned long) (pc) & 7) {
2573         __GLX_MEM_COPY(pc - 4, pc, 28);
2574         pc -= 4;
2575     }
2576 #endif
2577     __GLX_SWAP_INT(pc + 24);
2578     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
2579
2580 }
2581
2582 void
2583 __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
2584 {
2585     __GLX_DECLARE_SWAP_VARIABLES;
2586     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2587
2588     __GLX_SWAP_INT(pc + 0);
2589     __GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);
2590
2591 }
2592
2593 void
2594 __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc)
2595 {
2596     __GLX_DECLARE_SWAP_VARIABLES;
2597     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2598
2599     __GLX_SWAP_INT(pc + 0);
2600     __GLX_SWAP_INT_ARRAY(pc + 4, 3);
2601
2602 }
2603
2604 void
2605 __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc)
2606 {
2607     __GLX_DECLARE_SWAP_VARIABLES;
2608     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2609
2610     __GLX_SWAP_INT(pc + 0);
2611     __GLX_SWAP_SHORT_ARRAY(pc + 4, 3);
2612
2613 }
2614
2615 void
2616 __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc)
2617 {
2618     __GLX_DECLARE_SWAP_VARIABLES;
2619     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2620
2621 #ifdef __GLX_ALIGN64
2622     if ((unsigned long) (pc) & 7) {
2623         __GLX_MEM_COPY(pc - 4, pc, 36);
2624         pc -= 4;
2625     }
2626 #endif
2627     __GLX_SWAP_INT(pc + 32);
2628     __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
2629
2630 }
2631
2632 void
2633 __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
2634 {
2635     __GLX_DECLARE_SWAP_VARIABLES;
2636     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2637
2638     __GLX_SWAP_INT(pc + 0);
2639     __GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);
2640
2641 }
2642
2643 void
2644 __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc)
2645 {
2646     __GLX_DECLARE_SWAP_VARIABLES;
2647     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2648
2649     __GLX_SWAP_INT(pc + 0);
2650     __GLX_SWAP_INT_ARRAY(pc + 4, 4);
2651
2652 }
2653
2654 void
2655 __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc)
2656 {
2657     __GLX_DECLARE_SWAP_VARIABLES;
2658     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2659
2660     __GLX_SWAP_INT(pc + 0);
2661     __GLX_SWAP_SHORT_ARRAY(pc + 4, 4);
2662
2663 }