src/glx/x11/indirect_reqsize.c

   1 /* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
   2
   3 /*
   4  * (C) Copyright IBM Corporation 2005
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  21  * IBM,
  22  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28
  29 #include <GL/gl.h>
  30 #include "glxserver.h"
  31 #include "glxbyteorder.h"
  32 #include "indirect_size.h"
  33 #include "indirect_reqsize.h"
  34
  35 #define __GLX_PAD(x)  (((x) + 3) & ~3)
  36
  37 #if defined(__CYGWIN__) || defined(__MINGW32__)
  38 #  undef HAVE_ALIAS
  39 #endif
  40 #ifdef HAVE_ALIAS
  41 #  define ALIAS2(from,to) \
  42     GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
  43         __attribute__ ((alias( # to )));
  44 #  define ALIAS(from,to) ALIAS2( from, __glX ## to ## ReqSize )
  45 #else
  46 #  define ALIAS(from,to) \
  47     GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
  48     { return __glX ## to ## ReqSize( pc, swap ); }
  49 #endif
  50
  51
  52 int
  53 __glXCallListsReqSize(const GLbyte *pc, Bool swap)
  54 {
  55     GLsizei n = *(GLsizei *) (pc + 0);
  56     GLenum type = *(GLenum *) (pc + 4);
  57     GLsizei compsize;
  58
  59     if (swap) {
  60         n = bswap_32(n);
  61         type = bswap_32(type);
  62     }
  63
  64     compsize = __glCallLists_size(type);
  65     return __GLX_PAD((compsize * n));
  66 }
  67
  68 int
  69 __glXBitmapReqSize(const GLbyte *pc, Bool swap)
  70 {
  71     GLint row_length = *(GLint *) (pc + 4);
  72     GLint image_height = 0;
  73     GLint skip_images = 0;
  74     GLint skip_rows = *(GLint *) (pc + 8);
  75     GLint alignment = *(GLint *) (pc + 16);
  76     GLsizei width = *(GLsizei *) (pc + 20);
  77     GLsizei height = *(GLsizei *) (pc + 24);
  78
  79     if (swap) {
  80         row_length = bswap_32(row_length);
  81         skip_rows = bswap_32(skip_rows);
  82         alignment = bswap_32(alignment);
  83         width = bswap_32(width);
  84         height = bswap_32(height);
  85     }
  86
  87     return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, width, height, 1,
  88                           image_height, row_length, skip_images,
  89                           skip_rows, alignment);
  90 }
  91
  92 int
  93 __glXFogfvReqSize(const GLbyte *pc, Bool swap)
  94 {
  95     GLenum pname = *(GLenum *) (pc + 0);
  96     GLsizei compsize;
  97
  98     if (swap) {
  99         pname = bswap_32(pname);
 100     }
 101
 102     compsize = __glFogfv_size(pname);
 103     return __GLX_PAD((compsize * 4));
 104 }
 105
 106 int
 107 __glXLightfvReqSize(const GLbyte *pc, Bool swap)
 108 {
 109     GLenum pname = *(GLenum *) (pc + 4);
 110     GLsizei compsize;
 111
 112     if (swap) {
 113         pname = bswap_32(pname);
 114     }
 115
 116     compsize = __glLightfv_size(pname);
 117     return __GLX_PAD((compsize * 4));
 118 }
 119
 120 int
 121 __glXLightModelfvReqSize(const GLbyte *pc, Bool swap)
 122 {
 123     GLenum pname = *(GLenum *) (pc + 0);
 124     GLsizei compsize;
 125
 126     if (swap) {
 127         pname = bswap_32(pname);
 128     }
 129
 130     compsize = __glLightModelfv_size(pname);
 131     return __GLX_PAD((compsize * 4));
 132 }
 133
 134 int
 135 __glXMaterialfvReqSize(const GLbyte *pc, Bool swap)
 136 {
 137     GLenum pname = *(GLenum *) (pc + 4);
 138     GLsizei compsize;
 139
 140     if (swap) {
 141         pname = bswap_32(pname);
 142     }
 143
 144     compsize = __glMaterialfv_size(pname);
 145     return __GLX_PAD((compsize * 4));
 146 }
 147
 148 int
 149 __glXPolygonStippleReqSize(const GLbyte *pc, Bool swap)
 150 {
 151     GLint row_length = *(GLint *) (pc + 4);
 152     GLint image_height = 0;
 153     GLint skip_images = 0;
 154     GLint skip_rows = *(GLint *) (pc + 8);
 155     GLint alignment = *(GLint *) (pc + 16);
 156
 157     if (swap) {
 158         row_length = bswap_32(row_length);
 159         skip_rows = bswap_32(skip_rows);
 160         alignment = bswap_32(alignment);
 161     }
 162
 163     return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, 32, 32, 1,
 164                           image_height, row_length, skip_images,
 165                           skip_rows, alignment);
 166 }
 167
 168 int
 169 __glXTexParameterfvReqSize(const GLbyte *pc, Bool swap)
 170 {
 171     GLenum pname = *(GLenum *) (pc + 4);
 172     GLsizei compsize;
 173
 174     if (swap) {
 175         pname = bswap_32(pname);
 176     }
 177
 178     compsize = __glTexParameterfv_size(pname);
 179     return __GLX_PAD((compsize * 4));
 180 }
 181
 182 int
 183 __glXTexImage1DReqSize(const GLbyte *pc, Bool swap)
 184 {
 185     GLint row_length = *(GLint *) (pc + 4);
 186     GLint image_height = 0;
 187     GLint skip_images = 0;
 188     GLint skip_rows = *(GLint *) (pc + 8);
 189     GLint alignment = *(GLint *) (pc + 16);
 190     GLenum target = *(GLenum *) (pc + 20);
 191     GLsizei width = *(GLsizei *) (pc + 32);
 192     GLenum format = *(GLenum *) (pc + 44);
 193     GLenum type = *(GLenum *) (pc + 48);
 194
 195     if (swap) {
 196         row_length = bswap_32(row_length);
 197         skip_rows = bswap_32(skip_rows);
 198         alignment = bswap_32(alignment);
 199         target = bswap_32(target);
 200         width = bswap_32(width);
 201         format = bswap_32(format);
 202         type = bswap_32(type);
 203     }
 204
 205     return __glXImageSize(format, type, target, width, 1, 1,
 206                           image_height, row_length, skip_images,
 207                           skip_rows, alignment);
 208 }
 209
 210 int
 211 __glXTexImage2DReqSize(const GLbyte *pc, Bool swap)
 212 {
 213     GLint row_length = *(GLint *) (pc + 4);
 214     GLint image_height = 0;
 215     GLint skip_images = 0;
 216     GLint skip_rows = *(GLint *) (pc + 8);
 217     GLint alignment = *(GLint *) (pc + 16);
 218     GLenum target = *(GLenum *) (pc + 20);
 219     GLsizei width = *(GLsizei *) (pc + 32);
 220     GLsizei height = *(GLsizei *) (pc + 36);
 221     GLenum format = *(GLenum *) (pc + 44);
 222     GLenum type = *(GLenum *) (pc + 48);
 223
 224     if (swap) {
 225         row_length = bswap_32(row_length);
 226         skip_rows = bswap_32(skip_rows);
 227         alignment = bswap_32(alignment);
 228         target = bswap_32(target);
 229         width = bswap_32(width);
 230         height = bswap_32(height);
 231         format = bswap_32(format);
 232         type = bswap_32(type);
 233     }
 234
 235     return __glXImageSize(format, type, target, width, height, 1,
 236                           image_height, row_length, skip_images,
 237                           skip_rows, alignment);
 238 }
 239
 240 int
 241 __glXTexEnvfvReqSize(const GLbyte *pc, Bool swap)
 242 {
 243     GLenum pname = *(GLenum *) (pc + 4);
 244     GLsizei compsize;
 245
 246     if (swap) {
 247         pname = bswap_32(pname);
 248     }
 249
 250     compsize = __glTexEnvfv_size(pname);
 251     return __GLX_PAD((compsize * 4));
 252 }
 253
 254 int
 255 __glXTexGendvReqSize(const GLbyte *pc, Bool swap)
 256 {
 257     GLenum pname = *(GLenum *) (pc + 4);
 258     GLsizei compsize;
 259
 260     if (swap) {
 261         pname = bswap_32(pname);
 262     }
 263
 264     compsize = __glTexGendv_size(pname);
 265     return __GLX_PAD((compsize * 8));
 266 }
 267
 268 int
 269 __glXTexGenfvReqSize(const GLbyte *pc, Bool swap)
 270 {
 271     GLenum pname = *(GLenum *) (pc + 4);
 272     GLsizei compsize;
 273
 274     if (swap) {
 275         pname = bswap_32(pname);
 276     }
 277
 278     compsize = __glTexGenfv_size(pname);
 279     return __GLX_PAD((compsize * 4));
 280 }
 281
 282 int
 283 __glXPixelMapfvReqSize(const GLbyte *pc, Bool swap)
 284 {
 285     GLsizei mapsize = *(GLsizei *) (pc + 4);
 286
 287     if (swap) {
 288         mapsize = bswap_32(mapsize);
 289     }
 290
 291     return __GLX_PAD((mapsize * 4));
 292 }
 293
 294 int
 295 __glXPixelMapusvReqSize(const GLbyte *pc, Bool swap)
 296 {
 297     GLsizei mapsize = *(GLsizei *) (pc + 4);
 298
 299     if (swap) {
 300         mapsize = bswap_32(mapsize);
 301     }
 302
 303     return __GLX_PAD((mapsize * 2));
 304 }
 305
 306 int
 307 __glXDrawPixelsReqSize(const GLbyte *pc, Bool swap)
 308 {
 309     GLint row_length = *(GLint *) (pc + 4);
 310     GLint image_height = 0;
 311     GLint skip_images = 0;
 312     GLint skip_rows = *(GLint *) (pc + 8);
 313     GLint alignment = *(GLint *) (pc + 16);
 314     GLsizei width = *(GLsizei *) (pc + 20);
 315     GLsizei height = *(GLsizei *) (pc + 24);
 316     GLenum format = *(GLenum *) (pc + 28);
 317     GLenum type = *(GLenum *) (pc + 32);
 318
 319     if (swap) {
 320         row_length = bswap_32(row_length);
 321         skip_rows = bswap_32(skip_rows);
 322         alignment = bswap_32(alignment);
 323         width = bswap_32(width);
 324         height = bswap_32(height);
 325         format = bswap_32(format);
 326         type = bswap_32(type);
 327     }
 328
 329     return __glXImageSize(format, type, 0, width, height, 1,
 330                           image_height, row_length, skip_images,
 331                           skip_rows, alignment);
 332 }
 333
 334 int
 335 __glXPrioritizeTexturesReqSize(const GLbyte *pc, Bool swap)
 336 {
 337     GLsizei n = *(GLsizei *) (pc + 0);
 338
 339     if (swap) {
 340         n = bswap_32(n);
 341     }
 342
 343     return __GLX_PAD((n * 4) + (n * 4));
 344 }
 345
 346 int
 347 __glXTexSubImage1DReqSize(const GLbyte *pc, Bool swap)
 348 {
 349     GLint row_length = *(GLint *) (pc + 4);
 350     GLint image_height = 0;
 351     GLint skip_images = 0;
 352     GLint skip_rows = *(GLint *) (pc + 8);
 353     GLint alignment = *(GLint *) (pc + 16);
 354     GLenum target = *(GLenum *) (pc + 20);
 355     GLsizei width = *(GLsizei *) (pc + 36);
 356     GLenum format = *(GLenum *) (pc + 44);
 357     GLenum type = *(GLenum *) (pc + 48);
 358
 359     if (swap) {
 360         row_length = bswap_32(row_length);
 361         skip_rows = bswap_32(skip_rows);
 362         alignment = bswap_32(alignment);
 363         target = bswap_32(target);
 364         width = bswap_32(width);
 365         format = bswap_32(format);
 366         type = bswap_32(type);
 367     }
 368
 369     return __glXImageSize(format, type, target, width, 1, 1,
 370                           image_height, row_length, skip_images,
 371                           skip_rows, alignment);
 372 }
 373
 374 int
 375 __glXTexSubImage2DReqSize(const GLbyte *pc, Bool swap)
 376 {
 377     GLint row_length = *(GLint *) (pc + 4);
 378     GLint image_height = 0;
 379     GLint skip_images = 0;
 380     GLint skip_rows = *(GLint *) (pc + 8);
 381     GLint alignment = *(GLint *) (pc + 16);
 382     GLenum target = *(GLenum *) (pc + 20);
 383     GLsizei width = *(GLsizei *) (pc + 36);
 384     GLsizei height = *(GLsizei *) (pc + 40);
 385     GLenum format = *(GLenum *) (pc + 44);
 386     GLenum type = *(GLenum *) (pc + 48);
 387
 388     if (swap) {
 389         row_length = bswap_32(row_length);
 390         skip_rows = bswap_32(skip_rows);
 391         alignment = bswap_32(alignment);
 392         target = bswap_32(target);
 393         width = bswap_32(width);
 394         height = bswap_32(height);
 395         format = bswap_32(format);
 396         type = bswap_32(type);
 397     }
 398
 399     return __glXImageSize(format, type, target, width, height, 1,
 400                           image_height, row_length, skip_images,
 401                           skip_rows, alignment);
 402 }
 403
 404 int
 405 __glXColorTableReqSize(const GLbyte *pc, Bool swap)
 406 {
 407     GLint row_length = *(GLint *) (pc + 4);
 408     GLint image_height = 0;
 409     GLint skip_images = 0;
 410     GLint skip_rows = *(GLint *) (pc + 8);
 411     GLint alignment = *(GLint *) (pc + 16);
 412     GLenum target = *(GLenum *) (pc + 20);
 413     GLsizei width = *(GLsizei *) (pc + 28);
 414     GLenum format = *(GLenum *) (pc + 32);
 415     GLenum type = *(GLenum *) (pc + 36);
 416
 417     if (swap) {
 418         row_length = bswap_32(row_length);
 419         skip_rows = bswap_32(skip_rows);
 420         alignment = bswap_32(alignment);
 421         target = bswap_32(target);
 422         width = bswap_32(width);
 423         format = bswap_32(format);
 424         type = bswap_32(type);
 425     }
 426
 427     return __glXImageSize(format, type, target, width, 1, 1,
 428                           image_height, row_length, skip_images,
 429                           skip_rows, alignment);
 430 }
 431
 432 int
 433 __glXColorTableParameterfvReqSize(const GLbyte *pc, Bool swap)
 434 {
 435     GLenum pname = *(GLenum *) (pc + 4);
 436     GLsizei compsize;
 437
 438     if (swap) {
 439         pname = bswap_32(pname);
 440     }
 441
 442     compsize = __glColorTableParameterfv_size(pname);
 443     return __GLX_PAD((compsize * 4));
 444 }
 445
 446 int
 447 __glXColorSubTableReqSize(const GLbyte *pc, Bool swap)
 448 {
 449     GLint row_length = *(GLint *) (pc + 4);
 450     GLint image_height = 0;
 451     GLint skip_images = 0;
 452     GLint skip_rows = *(GLint *) (pc + 8);
 453     GLint alignment = *(GLint *) (pc + 16);
 454     GLenum target = *(GLenum *) (pc + 20);
 455     GLsizei count = *(GLsizei *) (pc + 28);
 456     GLenum format = *(GLenum *) (pc + 32);
 457     GLenum type = *(GLenum *) (pc + 36);
 458
 459     if (swap) {
 460         row_length = bswap_32(row_length);
 461         skip_rows = bswap_32(skip_rows);
 462         alignment = bswap_32(alignment);
 463         target = bswap_32(target);
 464         count = bswap_32(count);
 465         format = bswap_32(format);
 466         type = bswap_32(type);
 467     }
 468
 469     return __glXImageSize(format, type, target, count, 1, 1,
 470                           image_height, row_length, skip_images,
 471                           skip_rows, alignment);
 472 }
 473
 474 int
 475 __glXConvolutionFilter1DReqSize(const GLbyte *pc, Bool swap)
 476 {
 477     GLint row_length = *(GLint *) (pc + 4);
 478     GLint image_height = 0;
 479     GLint skip_images = 0;
 480     GLint skip_rows = *(GLint *) (pc + 8);
 481     GLint alignment = *(GLint *) (pc + 16);
 482     GLenum target = *(GLenum *) (pc + 20);
 483     GLsizei width = *(GLsizei *) (pc + 28);
 484     GLenum format = *(GLenum *) (pc + 36);
 485     GLenum type = *(GLenum *) (pc + 40);
 486
 487     if (swap) {
 488         row_length = bswap_32(row_length);
 489         skip_rows = bswap_32(skip_rows);
 490         alignment = bswap_32(alignment);
 491         target = bswap_32(target);
 492         width = bswap_32(width);
 493         format = bswap_32(format);
 494         type = bswap_32(type);
 495     }
 496
 497     return __glXImageSize(format, type, target, width, 1, 1,
 498                           image_height, row_length, skip_images,
 499                           skip_rows, alignment);
 500 }
 501
 502 int
 503 __glXConvolutionFilter2DReqSize(const GLbyte *pc, Bool swap)
 504 {
 505     GLint row_length = *(GLint *) (pc + 4);
 506     GLint image_height = 0;
 507     GLint skip_images = 0;
 508     GLint skip_rows = *(GLint *) (pc + 8);
 509     GLint alignment = *(GLint *) (pc + 16);
 510     GLenum target = *(GLenum *) (pc + 20);
 511     GLsizei width = *(GLsizei *) (pc + 28);
 512     GLsizei height = *(GLsizei *) (pc + 32);
 513     GLenum format = *(GLenum *) (pc + 36);
 514     GLenum type = *(GLenum *) (pc + 40);
 515
 516     if (swap) {
 517         row_length = bswap_32(row_length);
 518         skip_rows = bswap_32(skip_rows);
 519         alignment = bswap_32(alignment);
 520         target = bswap_32(target);
 521         width = bswap_32(width);
 522         height = bswap_32(height);
 523         format = bswap_32(format);
 524         type = bswap_32(type);
 525     }
 526
 527     return __glXImageSize(format, type, target, width, height, 1,
 528                           image_height, row_length, skip_images,
 529                           skip_rows, alignment);
 530 }
 531
 532 int
 533 __glXConvolutionParameterfvReqSize(const GLbyte *pc, Bool swap)
 534 {
 535     GLenum pname = *(GLenum *) (pc + 4);
 536     GLsizei compsize;
 537
 538     if (swap) {
 539         pname = bswap_32(pname);
 540     }
 541
 542     compsize = __glConvolutionParameterfv_size(pname);
 543     return __GLX_PAD((compsize * 4));
 544 }
 545
 546 int
 547 __glXTexImage3DReqSize(const GLbyte *pc, Bool swap)
 548 {
 549     GLint row_length = *(GLint *) (pc + 4);
 550     GLint image_height = *(GLint *) (pc + 8);
 551     GLint skip_rows = *(GLint *) (pc + 16);
 552     GLint skip_images = *(GLint *) (pc + 20);
 553     GLint alignment = *(GLint *) (pc + 32);
 554     GLenum target = *(GLenum *) (pc + 36);
 555     GLsizei width = *(GLsizei *) (pc + 48);
 556     GLsizei height = *(GLsizei *) (pc + 52);
 557     GLsizei depth = *(GLsizei *) (pc + 56);
 558     GLenum format = *(GLenum *) (pc + 68);
 559     GLenum type = *(GLenum *) (pc + 72);
 560
 561     if (swap) {
 562         row_length = bswap_32(row_length);
 563         image_height = bswap_32(image_height);
 564         skip_rows = bswap_32(skip_rows);
 565         skip_images = bswap_32(skip_images);
 566         alignment = bswap_32(alignment);
 567         target = bswap_32(target);
 568         width = bswap_32(width);
 569         height = bswap_32(height);
 570         depth = bswap_32(depth);
 571         format = bswap_32(format);
 572         type = bswap_32(type);
 573     }
 574
 575     return __glXImageSize(format, type, target, width, height, depth,
 576                           image_height, row_length, skip_images,
 577                           skip_rows, alignment);
 578 }
 579
 580 int
 581 __glXTexSubImage3DReqSize(const GLbyte *pc, Bool swap)
 582 {
 583     GLint row_length = *(GLint *) (pc + 4);
 584     GLint image_height = *(GLint *) (pc + 8);
 585     GLint skip_rows = *(GLint *) (pc + 16);
 586     GLint skip_images = *(GLint *) (pc + 20);
 587     GLint alignment = *(GLint *) (pc + 32);
 588     GLenum target = *(GLenum *) (pc + 36);
 589     GLsizei width = *(GLsizei *) (pc + 60);
 590     GLsizei height = *(GLsizei *) (pc + 64);
 591     GLsizei depth = *(GLsizei *) (pc + 68);
 592     GLenum format = *(GLenum *) (pc + 76);
 593     GLenum type = *(GLenum *) (pc + 80);
 594
 595     if (swap) {
 596         row_length = bswap_32(row_length);
 597         image_height = bswap_32(image_height);
 598         skip_rows = bswap_32(skip_rows);
 599         skip_images = bswap_32(skip_images);
 600         alignment = bswap_32(alignment);
 601         target = bswap_32(target);
 602         width = bswap_32(width);
 603         height = bswap_32(height);
 604         depth = bswap_32(depth);
 605         format = bswap_32(format);
 606         type = bswap_32(type);
 607     }
 608
 609     return __glXImageSize(format, type, target, width, height, depth,
 610                           image_height, row_length, skip_images,
 611                           skip_rows, alignment);
 612 }
 613
 614 int
 615 __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap)
 616 {
 617     GLsizei imageSize = *(GLsizei *) (pc + 20);
 618
 619     if (swap) {
 620         imageSize = bswap_32(imageSize);
 621     }
 622
 623     return __GLX_PAD(imageSize);
 624 }
 625
 626 int
 627 __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap)
 628 {
 629     GLsizei imageSize = *(GLsizei *) (pc + 24);
 630
 631     if (swap) {
 632         imageSize = bswap_32(imageSize);
 633     }
 634
 635     return __GLX_PAD(imageSize);
 636 }
 637
 638 int
 639 __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap)
 640 {
 641     GLsizei imageSize = *(GLsizei *) (pc + 28);
 642
 643     if (swap) {
 644         imageSize = bswap_32(imageSize);
 645     }
 646
 647     return __GLX_PAD(imageSize);
 648 }
 649
 650 int
 651 __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap)
 652 {
 653     GLsizei imageSize = *(GLsizei *) (pc + 36);
 654
 655     if (swap) {
 656         imageSize = bswap_32(imageSize);
 657     }
 658
 659     return __GLX_PAD(imageSize);
 660 }
 661
 662 int
 663 __glXProgramStringARBReqSize(const GLbyte *pc, Bool swap)
 664 {
 665     GLsizei len = *(GLsizei *) (pc + 8);
 666
 667     if (swap) {
 668         len = bswap_32(len);
 669     }
 670
 671     return __GLX_PAD(len);
 672 }
 673
 674 int
 675 __glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap)
 676 {
 677     GLsizei n = *(GLsizei *) (pc + 0);
 678
 679     if (swap) {
 680         n = bswap_32(n);
 681     }
 682
 683     return __GLX_PAD((n * 4));
 684 }
 685
 686 int
 687 __glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap)
 688 {
 689     GLenum pname = *(GLenum *) (pc + 0);
 690     GLsizei compsize;
 691
 692     if (swap) {
 693         pname = bswap_32(pname);
 694     }
 695
 696     compsize = __glPointParameterfvEXT_size(pname);
 697     return __GLX_PAD((compsize * 4));
 698 }
 699
 700 int
 701 __glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap)
 702 {
 703     GLuint num = *(GLuint *) (pc + 8);
 704
 705     if (swap) {
 706         num = bswap_32(num);
 707     }
 708
 709     return __GLX_PAD((num * 32));
 710 }
 711
 712 int
 713 __glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap)
 714 {
 715     GLuint num = *(GLuint *) (pc + 8);
 716
 717     if (swap) {
 718         num = bswap_32(num);
 719     }
 720
 721     return __GLX_PAD((num * 16));
 722 }
 723
 724 int
 725 __glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap)
 726 {
 727     GLsizei n = *(GLsizei *) (pc + 4);
 728
 729     if (swap) {
 730         n = bswap_32(n);
 731     }
 732
 733     return __GLX_PAD((n * 8));
 734 }
 735
 736 int
 737 __glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap)
 738 {
 739     GLsizei n = *(GLsizei *) (pc + 4);
 740
 741     if (swap) {
 742         n = bswap_32(n);
 743     }
 744
 745     return __GLX_PAD((n * 16));
 746 }
 747
 748 int
 749 __glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap)
 750 {
 751     GLsizei n = *(GLsizei *) (pc + 4);
 752
 753     if (swap) {
 754         n = bswap_32(n);
 755     }
 756
 757     return __GLX_PAD((n * 24));
 758 }
 759
 760 int
 761 __glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap)
 762 {
 763     GLsizei n = *(GLsizei *) (pc + 4);
 764
 765     if (swap) {
 766         n = bswap_32(n);
 767     }
 768
 769     return __GLX_PAD((n * 12));
 770 }
 771
 772 int
 773 __glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap)
 774 {
 775     GLsizei n = *(GLsizei *) (pc + 4);
 776
 777     if (swap) {
 778         n = bswap_32(n);
 779     }
 780
 781     return __GLX_PAD((n * 6));
 782 }
 783
 784 int
 785 __glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap)
 786 {
 787     GLsizei n = *(GLsizei *) (pc + 4);
 788
 789     if (swap) {
 790         n = bswap_32(n);
 791     }
 792
 793     return __GLX_PAD((n * 32));
 794 }
 795
 796 int
 797 __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap)
 798 {
 799     GLsizei len = *(GLsizei *) (pc + 4);
 800
 801     if (swap) {
 802         len = bswap_32(len);
 803     }
 804
 805     return __GLX_PAD(len);
 806 }
 807
 808 ALIAS(Fogiv, Fogfv)
 809     ALIAS(Lightiv, Lightfv)
 810     ALIAS(LightModeliv, LightModelfv)
 811     ALIAS(Materialiv, Materialfv)
 812     ALIAS(TexParameteriv, TexParameterfv)
 813     ALIAS(TexEnviv, TexEnvfv)
 814     ALIAS(TexGeniv, TexGenfv)
 815     ALIAS(PixelMapuiv, PixelMapfv)
 816     ALIAS(ColorTableParameteriv, ColorTableParameterfv)
 817     ALIAS(ConvolutionParameteriv, ConvolutionParameterfv)
 818     ALIAS(CompressedTexSubImage1DARB, CompressedTexImage1DARB)
 819     ALIAS(CompressedTexSubImage2DARB, CompressedTexImage3DARB)
 820     ALIAS(LoadProgramNV, ProgramStringARB)
 821     ALIAS(RequestResidentProgramsNV, DrawBuffersARB)
 822     ALIAS(VertexAttribs1fvNV, PixelMapfv)
 823     ALIAS(VertexAttribs1svNV, PixelMapusv)
 824     ALIAS(VertexAttribs2fvNV, VertexAttribs1dvNV)
 825     ALIAS(VertexAttribs2svNV, PixelMapfv)
 826     ALIAS(VertexAttribs4fvNV, VertexAttribs2dvNV)
 827     ALIAS(VertexAttribs4svNV, VertexAttribs1dvNV)
 828     ALIAS(VertexAttribs4ubvNV, PixelMapfv)
 829     ALIAS(PointParameterivNV, PointParameterfvEXT)
 830     ALIAS(ProgramNamedParameter4dvNV, CompressedTexSubImage3DARB)
 831     ALIAS(DeleteFramebuffersEXT, DrawBuffersARB)
 832     ALIAS(DeleteRenderbuffersEXT, DrawBuffersARB)