andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
34cf559bcf
xserver-multidpi/glx/indirect_dispatch.c
Keith Packard 9838b7032e Introduce a consistent coding style 
This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
2012-03-21 13:54:42 -07:00

5927 lines
165 KiB
C
Raw Blame History

/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <X11/Xmd.h>
#include <GL/gl.h>
#include <GL/glxproto.h>
#include <inttypes.h>
#include "indirect_size.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glxserver.h"
#include "glxbyteorder.h"
#include "indirect_util.h"
#include "singlesize.h"
#include "glapi.h"
#include "glapitable.h"
#include "glthread.h"
#include "dispatch.h"
#define __GLX_PAD(x) (((x) + 3) & ~3)
typedef struct {
__GLX_PIXEL_3D_HDR;
} __GLXpixel3DHeader;
extern GLboolean __glXErrorOccured(void);
extern void __glXClearErrorOccured(void);
static const unsigned dummy_answer[2] = { 0, 0 };
int
__glXDisp_NewList(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
CALL_NewList(GET_DISPATCH(), (*(GLuint *) (pc + 0), *(GLenum *) (pc + 4)
));
error = Success;
}
return error;
}
int
__glXDisp_EndList(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
CALL_EndList(GET_DISPATCH(), ());
error = Success;
}
return error;
}
void
__glXDisp_CallList(GLbyte * pc)
{
CALL_CallList(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_CallLists(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
const GLenum type = *(GLenum *) (pc + 4);
const GLvoid *lists = (const GLvoid *) (pc + 8);
lists = (const GLvoid *) (pc + 8);
CALL_CallLists(GET_DISPATCH(), (n, type, lists));
}
int
__glXDisp_DeleteLists(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
CALL_DeleteLists(GET_DISPATCH(), (*(GLuint *) (pc + 0),
*(GLsizei *) (pc + 4)
));
error = Success;
}
return error;
}
int
__glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLuint retval;
retval = CALL_GenLists(GET_DISPATCH(), (*(GLsizei *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_ListBase(GLbyte * pc)
{
CALL_ListBase(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_Begin(GLbyte * pc)
{
CALL_Begin(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_Bitmap(GLbyte * pc)
{
const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_Bitmap(GET_DISPATCH(), (*(GLsizei *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLfloat *) (pc + 28),
*(GLfloat *) (pc + 32),
*(GLfloat *) (pc + 36),
*(GLfloat *) (pc + 40), bitmap));
}
void
__glXDisp_Color3bv(GLbyte * pc)
{
CALL_Color3bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
));
}
void
__glXDisp_Color3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_Color3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Color3fv(GLbyte * pc)
{
CALL_Color3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Color3iv(GLbyte * pc)
{
CALL_Color3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Color3sv(GLbyte * pc)
{
CALL_Color3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Color3ubv(GLbyte * pc)
{
CALL_Color3ubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
));
}
void
__glXDisp_Color3uiv(GLbyte * pc)
{
CALL_Color3uiv(GET_DISPATCH(), ((const GLuint *) (pc + 0)
));
}
void
__glXDisp_Color3usv(GLbyte * pc)
{
CALL_Color3usv(GET_DISPATCH(), ((const GLushort *) (pc + 0)
));
}
void
__glXDisp_Color4bv(GLbyte * pc)
{
CALL_Color4bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
));
}
void
__glXDisp_Color4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_Color4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Color4fv(GLbyte * pc)
{
CALL_Color4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Color4iv(GLbyte * pc)
{
CALL_Color4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Color4sv(GLbyte * pc)
{
CALL_Color4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Color4ubv(GLbyte * pc)
{
CALL_Color4ubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
));
}
void
__glXDisp_Color4uiv(GLbyte * pc)
{
CALL_Color4uiv(GET_DISPATCH(), ((const GLuint *) (pc + 0)
));
}
void
__glXDisp_Color4usv(GLbyte * pc)
{
CALL_Color4usv(GET_DISPATCH(), ((const GLushort *) (pc + 0)
));
}
void
__glXDisp_EdgeFlagv(GLbyte * pc)
{
CALL_EdgeFlagv(GET_DISPATCH(), ((const GLboolean *) (pc + 0)
));
}
void
__glXDisp_End(GLbyte * pc)
{
CALL_End(GET_DISPATCH(), ());
}
void
__glXDisp_Indexdv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 8);
pc -= 4;
}
#endif
CALL_Indexdv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Indexfv(GLbyte * pc)
{
CALL_Indexfv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Indexiv(GLbyte * pc)
{
CALL_Indexiv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Indexsv(GLbyte * pc)
{
CALL_Indexsv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Normal3bv(GLbyte * pc)
{
CALL_Normal3bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
));
}
void
__glXDisp_Normal3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_Normal3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Normal3fv(GLbyte * pc)
{
CALL_Normal3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Normal3iv(GLbyte * pc)
{
CALL_Normal3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Normal3sv(GLbyte * pc)
{
CALL_Normal3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_RasterPos2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_RasterPos2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_RasterPos2fv(GLbyte * pc)
{
CALL_RasterPos2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_RasterPos2iv(GLbyte * pc)
{
CALL_RasterPos2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_RasterPos2sv(GLbyte * pc)
{
CALL_RasterPos2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_RasterPos3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_RasterPos3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_RasterPos3fv(GLbyte * pc)
{
CALL_RasterPos3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_RasterPos3iv(GLbyte * pc)
{
CALL_RasterPos3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_RasterPos3sv(GLbyte * pc)
{
CALL_RasterPos3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_RasterPos4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_RasterPos4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_RasterPos4fv(GLbyte * pc)
{
CALL_RasterPos4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_RasterPos4iv(GLbyte * pc)
{
CALL_RasterPos4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_RasterPos4sv(GLbyte * pc)
{
CALL_RasterPos4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Rectdv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_Rectdv(GET_DISPATCH(), ((const GLdouble *) (pc + 0),
(const GLdouble *) (pc + 16)
));
}
void
__glXDisp_Rectfv(GLbyte * pc)
{
CALL_Rectfv(GET_DISPATCH(), ((const GLfloat *) (pc + 0),
(const GLfloat *) (pc + 8)
));
}
void
__glXDisp_Rectiv(GLbyte * pc)
{
CALL_Rectiv(GET_DISPATCH(), ((const GLint *) (pc + 0),
(const GLint *) (pc + 8)
));
}
void
__glXDisp_Rectsv(GLbyte * pc)
{
CALL_Rectsv(GET_DISPATCH(), ((const GLshort *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_TexCoord1dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 8);
pc -= 4;
}
#endif
CALL_TexCoord1dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_TexCoord1fv(GLbyte * pc)
{
CALL_TexCoord1fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_TexCoord1iv(GLbyte * pc)
{
CALL_TexCoord1iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_TexCoord1sv(GLbyte * pc)
{
CALL_TexCoord1sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_TexCoord2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_TexCoord2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_TexCoord2fv(GLbyte * pc)
{
CALL_TexCoord2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_TexCoord2iv(GLbyte * pc)
{
CALL_TexCoord2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_TexCoord2sv(GLbyte * pc)
{
CALL_TexCoord2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_TexCoord3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_TexCoord3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_TexCoord3fv(GLbyte * pc)
{
CALL_TexCoord3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_TexCoord3iv(GLbyte * pc)
{
CALL_TexCoord3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_TexCoord3sv(GLbyte * pc)
{
CALL_TexCoord3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_TexCoord4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_TexCoord4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_TexCoord4fv(GLbyte * pc)
{
CALL_TexCoord4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_TexCoord4iv(GLbyte * pc)
{
CALL_TexCoord4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_TexCoord4sv(GLbyte * pc)
{
CALL_TexCoord4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Vertex2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_Vertex2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Vertex2fv(GLbyte * pc)
{
CALL_Vertex2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Vertex2iv(GLbyte * pc)
{
CALL_Vertex2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Vertex2sv(GLbyte * pc)
{
CALL_Vertex2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Vertex3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_Vertex3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Vertex3fv(GLbyte * pc)
{
CALL_Vertex3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Vertex3iv(GLbyte * pc)
{
CALL_Vertex3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Vertex3sv(GLbyte * pc)
{
CALL_Vertex3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_Vertex4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_Vertex4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Vertex4fv(GLbyte * pc)
{
CALL_Vertex4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_Vertex4iv(GLbyte * pc)
{
CALL_Vertex4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_Vertex4sv(GLbyte * pc)
{
CALL_Vertex4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_ClipPlane(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 36);
pc -= 4;
}
#endif
CALL_ClipPlane(GET_DISPATCH(), (*(GLenum *) (pc + 32),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_ColorMaterial(GLbyte * pc)
{
CALL_ColorMaterial(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4)
));
}
void
__glXDisp_CullFace(GLbyte * pc)
{
CALL_CullFace(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_Fogf(GLbyte * pc)
{
CALL_Fogf(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)
));
}
void
__glXDisp_Fogfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLfloat *params;
params = (const GLfloat *) (pc + 4);
CALL_Fogfv(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_Fogi(GLbyte * pc)
{
CALL_Fogi(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLint *) (pc + 4)
));
}
void
__glXDisp_Fogiv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLint *params;
params = (const GLint *) (pc + 4);
CALL_Fogiv(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_FrontFace(GLbyte * pc)
{
CALL_FrontFace(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_Hint(GLbyte * pc)
{
CALL_Hint(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
));
}
void
__glXDisp_Lightf(GLbyte * pc)
{
CALL_Lightf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_Lightfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_Lightfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_Lighti(GLbyte * pc)
{
CALL_Lighti(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLint *) (pc + 8)
));
}
void
__glXDisp_Lightiv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_Lightiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_LightModelf(GLbyte * pc)
{
CALL_LightModelf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLfloat *) (pc + 4)
));
}
void
__glXDisp_LightModelfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLfloat *params;
params = (const GLfloat *) (pc + 4);
CALL_LightModelfv(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_LightModeli(GLbyte * pc)
{
CALL_LightModeli(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLint *) (pc + 4)
));
}
void
__glXDisp_LightModeliv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLint *params;
params = (const GLint *) (pc + 4);
CALL_LightModeliv(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_LineStipple(GLbyte * pc)
{
CALL_LineStipple(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLushort *) (pc + 4)
));
}
void
__glXDisp_LineWidth(GLbyte * pc)
{
CALL_LineWidth(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
));
}
void
__glXDisp_Materialf(GLbyte * pc)
{
CALL_Materialf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_Materialfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_Materialfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_Materiali(GLbyte * pc)
{
CALL_Materiali(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLint *) (pc + 8)
));
}
void
__glXDisp_Materialiv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_Materialiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_PointSize(GLbyte * pc)
{
CALL_PointSize(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
));
}
void
__glXDisp_PolygonMode(GLbyte * pc)
{
CALL_PolygonMode(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
));
}
void
__glXDisp_PolygonStipple(GLbyte * pc)
{
const GLubyte *const mask = (const GLubyte *) ((pc + 20));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_PolygonStipple(GET_DISPATCH(), (mask));
}
void
__glXDisp_Scissor(GLbyte * pc)
{
CALL_Scissor(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLint *) (pc + 4),
*(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)
));
}
void
__glXDisp_ShadeModel(GLbyte * pc)
{
CALL_ShadeModel(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_TexParameterf(GLbyte * pc)
{
CALL_TexParameterf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLfloat *) (pc + 8)
));
}
void
__glXDisp_TexParameterfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_TexParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexParameteri(GLbyte * pc)
{
CALL_TexParameteri(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLint *) (pc + 8)
));
}
void
__glXDisp_TexParameteriv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_TexParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexImage1D(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLint *) (pc + 24),
*(GLint *) (pc + 28),
*(GLsizei *) (pc + 32),
*(GLint *) (pc + 40),
*(GLenum *) (pc + 44),
*(GLenum *) (pc + 48), pixels));
}
void
__glXDisp_TexImage2D(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLint *) (pc + 24),
*(GLint *) (pc + 28),
*(GLsizei *) (pc + 32),
*(GLsizei *) (pc + 36),
*(GLint *) (pc + 40),
*(GLenum *) (pc + 44),
*(GLenum *) (pc + 48), pixels));
}
void
__glXDisp_TexEnvf(GLbyte * pc)
{
CALL_TexEnvf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_TexEnvfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_TexEnvfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexEnvi(GLbyte * pc)
{
CALL_TexEnvi(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLint *) (pc + 8)
));
}
void
__glXDisp_TexEnviv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_TexEnviv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexGend(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_TexGend(GET_DISPATCH(), (*(GLenum *) (pc + 8),
*(GLenum *) (pc + 12), *(GLdouble *) (pc + 0)
));
}
void
__glXDisp_TexGendv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLdouble *params;
#ifdef __GLX_ALIGN64
const GLuint compsize = __glTexGendv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
params = (const GLdouble *) (pc + 8);
CALL_TexGendv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexGenf(GLbyte * pc)
{
CALL_TexGenf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_TexGenfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_TexGenfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_TexGeni(GLbyte * pc)
{
CALL_TexGeni(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLint *) (pc + 8)
));
}
void
__glXDisp_TexGeniv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_TexGeniv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}
void
__glXDisp_InitNames(GLbyte * pc)
{
CALL_InitNames(GET_DISPATCH(), ());
}
void
__glXDisp_LoadName(GLbyte * pc)
{
CALL_LoadName(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_PassThrough(GLbyte * pc)
{
CALL_PassThrough(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
));
}
void
__glXDisp_PopName(GLbyte * pc)
{
CALL_PopName(GET_DISPATCH(), ());
}
void
__glXDisp_PushName(GLbyte * pc)
{
CALL_PushName(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_DrawBuffer(GLbyte * pc)
{
CALL_DrawBuffer(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_Clear(GLbyte * pc)
{
CALL_Clear(GET_DISPATCH(), (*(GLbitfield *) (pc + 0)
));
}
void
__glXDisp_ClearAccum(GLbyte * pc)
{
CALL_ClearAccum(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
*(GLfloat *) (pc + 4),
*(GLfloat *) (pc + 8),
*(GLfloat *) (pc + 12)
));
}
void
__glXDisp_ClearIndex(GLbyte * pc)
{
CALL_ClearIndex(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
));
}
void
__glXDisp_ClearColor(GLbyte * pc)
{
CALL_ClearColor(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
*(GLclampf *) (pc + 4),
*(GLclampf *) (pc + 8),
*(GLclampf *) (pc + 12)
));
}
void
__glXDisp_ClearStencil(GLbyte * pc)
{
CALL_ClearStencil(GET_DISPATCH(), (*(GLint *) (pc + 0)
));
}
void
__glXDisp_ClearDepth(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 8);
pc -= 4;
}
#endif
CALL_ClearDepth(GET_DISPATCH(), (*(GLclampd *) (pc + 0)
));
}
void
__glXDisp_StencilMask(GLbyte * pc)
{
CALL_StencilMask(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_ColorMask(GLbyte * pc)
{
CALL_ColorMask(GET_DISPATCH(), (*(GLboolean *) (pc + 0),
*(GLboolean *) (pc + 1),
*(GLboolean *) (pc + 2),
*(GLboolean *) (pc + 3)
));
}
void
__glXDisp_DepthMask(GLbyte * pc)
{
CALL_DepthMask(GET_DISPATCH(), (*(GLboolean *) (pc + 0)
));
}
void
__glXDisp_IndexMask(GLbyte * pc)
{
CALL_IndexMask(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
}
void
__glXDisp_Accum(GLbyte * pc)
{
CALL_Accum(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)
));
}
void
__glXDisp_Disable(GLbyte * pc)
{
CALL_Disable(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_Enable(GLbyte * pc)
{
CALL_Enable(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_PopAttrib(GLbyte * pc)
{
CALL_PopAttrib(GET_DISPATCH(), ());
}
void
__glXDisp_PushAttrib(GLbyte * pc)
{
CALL_PushAttrib(GET_DISPATCH(), (*(GLbitfield *) (pc + 0)
));
}
void
__glXDisp_MapGrid1d(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 20);
pc -= 4;
}
#endif
CALL_MapGrid1d(GET_DISPATCH(), (*(GLint *) (pc + 16),
*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8)
));
}
void
__glXDisp_MapGrid1f(GLbyte * pc)
{
CALL_MapGrid1f(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_MapGrid2d(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 40);
pc -= 4;
}
#endif
CALL_MapGrid2d(GET_DISPATCH(), (*(GLint *) (pc + 32),
*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8),
*(GLint *) (pc + 36),
*(GLdouble *) (pc + 16),
*(GLdouble *) (pc + 24)
));
}
void
__glXDisp_MapGrid2f(GLbyte * pc)
{
CALL_MapGrid2f(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLfloat *) (pc + 4),
*(GLfloat *) (pc + 8),
*(GLint *) (pc + 12),
*(GLfloat *) (pc + 16),
*(GLfloat *) (pc + 20)
));
}
void
__glXDisp_EvalCoord1dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 8);
pc -= 4;
}
#endif
CALL_EvalCoord1dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_EvalCoord1fv(GLbyte * pc)
{
CALL_EvalCoord1fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_EvalCoord2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_EvalCoord2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_EvalCoord2fv(GLbyte * pc)
{
CALL_EvalCoord2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_EvalMesh1(GLbyte * pc)
{
CALL_EvalMesh1(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4), *(GLint *) (pc + 8)
));
}
void
__glXDisp_EvalPoint1(GLbyte * pc)
{
CALL_EvalPoint1(GET_DISPATCH(), (*(GLint *) (pc + 0)
));
}
void
__glXDisp_EvalMesh2(GLbyte * pc)
{
CALL_EvalMesh2(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12), *(GLint *) (pc + 16)
));
}
void
__glXDisp_EvalPoint2(GLbyte * pc)
{
CALL_EvalPoint2(GET_DISPATCH(), (*(GLint *) (pc + 0), *(GLint *) (pc + 4)
));
}
void
__glXDisp_AlphaFunc(GLbyte * pc)
{
CALL_AlphaFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLclampf *) (pc + 4)
));
}
void
__glXDisp_BlendFunc(GLbyte * pc)
{
CALL_BlendFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
));
}
void
__glXDisp_LogicOp(GLbyte * pc)
{
CALL_LogicOp(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_StencilFunc(GLbyte * pc)
{
CALL_StencilFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4), *(GLuint *) (pc + 8)
));
}
void
__glXDisp_StencilOp(GLbyte * pc)
{
CALL_StencilOp(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLenum *) (pc + 8)
));
}
void
__glXDisp_DepthFunc(GLbyte * pc)
{
CALL_DepthFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_PixelZoom(GLbyte * pc)
{
CALL_PixelZoom(GET_DISPATCH(), (*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4)
));
}
void
__glXDisp_PixelTransferf(GLbyte * pc)
{
CALL_PixelTransferf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLfloat *) (pc + 4)
));
}
void
__glXDisp_PixelTransferi(GLbyte * pc)
{
CALL_PixelTransferi(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4)
));
}
int
__glXDisp_PixelStoref(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
CALL_PixelStoref(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLfloat *) (pc + 4)
));
error = Success;
}
return error;
}
int
__glXDisp_PixelStorei(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
CALL_PixelStorei(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4)
));
error = Success;
}
return error;
}
void
__glXDisp_PixelMapfv(GLbyte * pc)
{
const GLsizei mapsize = *(GLsizei *) (pc + 4);
CALL_PixelMapfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
mapsize, (const GLfloat *) (pc + 8)
));
}
void
__glXDisp_PixelMapuiv(GLbyte * pc)
{
const GLsizei mapsize = *(GLsizei *) (pc + 4);
CALL_PixelMapuiv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
mapsize, (const GLuint *) (pc + 8)
));
}
void
__glXDisp_PixelMapusv(GLbyte * pc)
{
const GLsizei mapsize = *(GLsizei *) (pc + 4);
CALL_PixelMapusv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
mapsize, (const GLushort *) (pc + 8)
));
}
void
__glXDisp_ReadBuffer(GLbyte * pc)
{
CALL_ReadBuffer(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_CopyPixels(GLbyte * pc)
{
CALL_CopyPixels(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLint *) (pc + 4),
*(GLsizei *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLenum *) (pc + 16)
));
}
void
__glXDisp_DrawPixels(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_DrawPixels(GET_DISPATCH(), (*(GLsizei *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLenum *) (pc + 28),
*(GLenum *) (pc + 32), pixels));
}
int
__glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetBooleanv_size(pname);
GLboolean answerBuffer[200];
GLboolean *params =
__glXGetAnswerBuffer(cl, compsize, answerBuffer,
sizeof(answerBuffer), 1);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetBooleanv(GET_DISPATCH(), (pname, params));
__glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLdouble equation[4];
CALL_GetClipPlane(GET_DISPATCH(), (*(GLenum *) (pc + 0), equation));
__glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetDoublev_size(pname);
GLdouble answerBuffer[200];
GLdouble *params =
__glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
sizeof(answerBuffer), 8);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetDoublev(GET_DISPATCH(), (pname, params));
__glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetError(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLenum retval;
retval = CALL_GetError(GET_DISPATCH(), ());
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
int
__glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetFloatv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetFloatv(GET_DISPATCH(), (pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetIntegerv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetIntegerv(GET_DISPATCH(), (pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetLightfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetLightfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetLightiv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetLightiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum target = *(GLenum *) (pc + 0);
const GLenum query = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMapdv_size(target, query);
GLdouble answerBuffer[200];
GLdouble *v =
__glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
sizeof(answerBuffer), 8);
if (v == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMapdv(GET_DISPATCH(), (target, query, v));
__glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum target = *(GLenum *) (pc + 0);
const GLenum query = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMapfv_size(target, query);
GLfloat answerBuffer[200];
GLfloat *v =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (v == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMapfv(GET_DISPATCH(), (target, query, v));
__glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum target = *(GLenum *) (pc + 0);
const GLenum query = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMapiv_size(target, query);
GLint answerBuffer[200];
GLint *v =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (v == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMapiv(GET_DISPATCH(), (target, query, v));
__glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMaterialfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMaterialfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMaterialiv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMaterialiv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum map = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetPixelMapfv_size(map);
GLfloat answerBuffer[200];
GLfloat *values =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (values == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetPixelMapfv(GET_DISPATCH(), (map, values));
__glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum map = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetPixelMapuiv_size(map);
GLuint answerBuffer[200];
GLuint *values =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (values == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetPixelMapuiv(GET_DISPATCH(), (map, values));
__glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum map = *(GLenum *) (pc + 0);
const GLuint compsize = __glGetPixelMapusv_size(map);
GLushort answerBuffer[200];
GLushort *values =
__glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
sizeof(answerBuffer), 2);
if (values == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetPixelMapusv(GET_DISPATCH(), (map, values));
__glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexEnvfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexEnvfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexEnviv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexEnviv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexGendv_size(pname);
GLdouble answerBuffer[200];
GLdouble *params =
__glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
sizeof(answerBuffer), 8);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexGendv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexGenfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexGenfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexGeniv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexGeniv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetTexParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 8);
const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexLevelParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 8);
const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetTexLevelParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsEnabled(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
int
__glXDisp_IsList(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsList(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_DepthRange(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 16);
pc -= 4;
}
#endif
CALL_DepthRange(GET_DISPATCH(), (*(GLclampd *) (pc + 0),
*(GLclampd *) (pc + 8)
));
}
void
__glXDisp_Frustum(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 48);
pc -= 4;
}
#endif
CALL_Frustum(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8),
*(GLdouble *) (pc + 16),
*(GLdouble *) (pc + 24),
*(GLdouble *) (pc + 32),
*(GLdouble *) (pc + 40)
));
}
void
__glXDisp_LoadIdentity(GLbyte * pc)
{
CALL_LoadIdentity(GET_DISPATCH(), ());
}
void
__glXDisp_LoadMatrixf(GLbyte * pc)
{
CALL_LoadMatrixf(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_LoadMatrixd(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 128);
pc -= 4;
}
#endif
CALL_LoadMatrixd(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_MatrixMode(GLbyte * pc)
{
CALL_MatrixMode(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_MultMatrixf(GLbyte * pc)
{
CALL_MultMatrixf(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_MultMatrixd(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 128);
pc -= 4;
}
#endif
CALL_MultMatrixd(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_Ortho(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 48);
pc -= 4;
}
#endif
CALL_Ortho(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8),
*(GLdouble *) (pc + 16),
*(GLdouble *) (pc + 24),
*(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40)
));
}
void
__glXDisp_PopMatrix(GLbyte * pc)
{
CALL_PopMatrix(GET_DISPATCH(), ());
}
void
__glXDisp_PushMatrix(GLbyte * pc)
{
CALL_PushMatrix(GET_DISPATCH(), ());
}
void
__glXDisp_Rotated(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 32);
pc -= 4;
}
#endif
CALL_Rotated(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8),
*(GLdouble *) (pc + 16),
*(GLdouble *) (pc + 24)
));
}
void
__glXDisp_Rotatef(GLbyte * pc)
{
CALL_Rotatef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
*(GLfloat *) (pc + 4),
*(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12)
));
}
void
__glXDisp_Scaled(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_Scaled(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16)
));
}
void
__glXDisp_Scalef(GLbyte * pc)
{
CALL_Scalef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
*(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)
));
}
void
__glXDisp_Translated(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_Translated(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
*(GLdouble *) (pc + 8),
*(GLdouble *) (pc + 16)
));
}
void
__glXDisp_Translatef(GLbyte * pc)
{
CALL_Translatef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
*(GLfloat *) (pc + 4),
*(GLfloat *) (pc + 8)
));
}
void
__glXDisp_Viewport(GLbyte * pc)
{
CALL_Viewport(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLint *) (pc + 4),
*(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)
));
}
void
__glXDisp_BindTexture(GLbyte * pc)
{
CALL_BindTexture(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)
));
}
void
__glXDisp_Indexubv(GLbyte * pc)
{
CALL_Indexubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
));
}
void
__glXDisp_PolygonOffset(GLbyte * pc)
{
CALL_PolygonOffset(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
*(GLfloat *) (pc + 4)
));
}
int
__glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLboolean retval;
GLboolean answerBuffer[200];
GLboolean *residences =
__glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
retval =
CALL_AreTexturesResident(GET_DISPATCH(),
(n, (const GLuint *) (pc + 4),
residences));
__glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
error = Success;
}
return error;
}
int
__glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLboolean retval;
GLboolean answerBuffer[200];
GLboolean *residences =
__glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
retval =
CALL_AreTexturesResident(GET_DISPATCH(),
(n, (const GLuint *) (pc + 4),
residences));
__glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
error = Success;
}
return error;
}
void
__glXDisp_CopyTexImage1D(GLbyte * pc)
{
CALL_CopyTexImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLsizei *) (pc + 20),
*(GLint *) (pc + 24)
));
}
void
__glXDisp_CopyTexImage2D(GLbyte * pc)
{
CALL_CopyTexImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLsizei *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLint *) (pc + 28)
));
}
void
__glXDisp_CopyTexSubImage1D(GLbyte * pc)
{
CALL_CopyTexSubImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLsizei *) (pc + 20)
));
}
void
__glXDisp_CopyTexSubImage2D(GLbyte * pc)
{
CALL_CopyTexSubImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLint *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLsizei *) (pc + 28)
));
}
int
__glXDisp_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteTextures(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
error = Success;
}
return error;
}
int
__glXDisp_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteTextures(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
error = Success;
}
return error;
}
int
__glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *textures =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenTextures(GET_DISPATCH(), (n, textures));
__glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *textures =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenTextures(GET_DISPATCH(), (n, textures));
__glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsTexture(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
int
__glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsTexture(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_PrioritizeTextures(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_PrioritizeTextures(GET_DISPATCH(), (n,
(const GLuint *) (pc + 4),
(const GLclampf *) (pc + 4)
));
}
void
__glXDisp_TexSubImage1D(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexSubImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLint *) (pc + 24),
*(GLint *) (pc + 28),
*(GLsizei *) (pc + 36),
*(GLenum *) (pc + 44),
*(GLenum *) (pc + 48), pixels));
}
void
__glXDisp_TexSubImage2D(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexSubImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLint *) (pc + 24),
*(GLint *) (pc + 28),
*(GLint *) (pc + 32),
*(GLsizei *) (pc + 36),
*(GLsizei *) (pc + 40),
*(GLenum *) (pc + 44),
*(GLenum *) (pc + 48), pixels));
}
void
__glXDisp_BlendColor(GLbyte * pc)
{
CALL_BlendColor(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
*(GLclampf *) (pc + 4),
*(GLclampf *) (pc + 8),
*(GLclampf *) (pc + 12)
));
}
void
__glXDisp_BlendEquation(GLbyte * pc)
{
CALL_BlendEquation(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_ColorTable(GLbyte * pc)
{
const GLvoid *const table = (const GLvoid *) ((pc + 40));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_ColorTable(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLenum *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLenum *) (pc + 32),
*(GLenum *) (pc + 36), table));
}
void
__glXDisp_ColorTableParameterfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_ColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
}
void
__glXDisp_ColorTableParameteriv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_ColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
}
void
__glXDisp_CopyColorTable(GLbyte * pc)
{
CALL_CopyColorTable(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLsizei *) (pc + 16)
));
}
int
__glXDisp_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetColorTableParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetColorTableParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetColorTableParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetColorTableParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
void
__glXDisp_ColorSubTable(GLbyte * pc)
{
const GLvoid *const data = (const GLvoid *) ((pc + 40));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_ColorSubTable(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLenum *) (pc + 32),
*(GLenum *) (pc + 36), data));
}
void
__glXDisp_CopyColorSubTable(GLbyte * pc)
{
CALL_CopyColorSubTable(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLsizei *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLsizei *) (pc + 16)
));
}
void
__glXDisp_ConvolutionFilter1D(GLbyte * pc)
{
const GLvoid *const image = (const GLvoid *) ((pc + 44));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_ConvolutionFilter1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLenum *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLenum *) (pc + 36),
*(GLenum *) (pc + 40), image));
}
void
__glXDisp_ConvolutionFilter2D(GLbyte * pc)
{
const GLvoid *const image = (const GLvoid *) ((pc + 44));
__GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_ConvolutionFilter2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
*(GLenum *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLsizei *) (pc + 32),
*(GLenum *) (pc + 36),
*(GLenum *) (pc + 40), image));
}
void
__glXDisp_ConvolutionParameterf(GLbyte * pc)
{
CALL_ConvolutionParameterf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLfloat *) (pc + 8)
));
}
void
__glXDisp_ConvolutionParameterfv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLfloat *params;
params = (const GLfloat *) (pc + 8);
CALL_ConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
}
void
__glXDisp_ConvolutionParameteri(GLbyte * pc)
{
CALL_ConvolutionParameteri(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLint *) (pc + 8)
));
}
void
__glXDisp_ConvolutionParameteriv(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 4);
const GLint *params;
params = (const GLint *) (pc + 8);
CALL_ConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
}
void
__glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
{
CALL_CopyConvolutionFilter1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLsizei *) (pc + 16)
));
}
void
__glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
{
CALL_CopyConvolutionFilter2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLsizei *) (pc + 16),
*(GLsizei *) (pc + 20)
));
}
int
__glXDisp_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetHistogramParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetHistogramParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetHistogramParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetHistogramParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetHistogramParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetHistogramParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetHistogramParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetHistogramParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMinmaxParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMinmaxParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMinmaxParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetMinmaxParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
void
__glXDisp_Histogram(GLbyte * pc)
{
CALL_Histogram(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLsizei *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLboolean *) (pc + 12)
));
}
void
__glXDisp_Minmax(GLbyte * pc)
{
CALL_Minmax(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), *(GLboolean *) (pc + 8)
));
}
void
__glXDisp_ResetHistogram(GLbyte * pc)
{
CALL_ResetHistogram(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_ResetMinmax(GLbyte * pc)
{
CALL_ResetMinmax(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_TexImage3D(GLbyte * pc)
{
const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
const GLvoid *const pixels =
(const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
__GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 36),
*(GLint *) (pc + 40),
*(GLint *) (pc + 44),
*(GLsizei *) (pc + 48),
*(GLsizei *) (pc + 52),
*(GLsizei *) (pc + 56),
*(GLint *) (pc + 64),
*(GLenum *) (pc + 68),
*(GLenum *) (pc + 72), pixels));
}
void
__glXDisp_TexSubImage3D(GLbyte * pc)
{
const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
__GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
CALL_PixelStorei(GET_DISPATCH(),
(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));
CALL_TexSubImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 36),
*(GLint *) (pc + 40),
*(GLint *) (pc + 44),
*(GLint *) (pc + 48),
*(GLint *) (pc + 52),
*(GLsizei *) (pc + 60),
*(GLsizei *) (pc + 64),
*(GLsizei *) (pc + 68),
*(GLenum *) (pc + 76),
*(GLenum *) (pc + 80), pixels));
}
void
__glXDisp_CopyTexSubImage3D(GLbyte * pc)
{
CALL_CopyTexSubImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLint *) (pc + 20),
*(GLint *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLsizei *) (pc + 32)
));
}
void
__glXDisp_ActiveTextureARB(GLbyte * pc)
{
CALL_ActiveTextureARB(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_MultiTexCoord1dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 12);
pc -= 4;
}
#endif
CALL_MultiTexCoord1dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 8),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
{
CALL_MultiTexCoord1fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord1ivARB(GLbyte * pc)
{
CALL_MultiTexCoord1ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord1svARB(GLbyte * pc)
{
CALL_MultiTexCoord1svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord2dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 20);
pc -= 4;
}
#endif
CALL_MultiTexCoord2dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 16),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
{
CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord2ivARB(GLbyte * pc)
{
CALL_MultiTexCoord2ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord2svARB(GLbyte * pc)
{
CALL_MultiTexCoord2svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord3dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 28);
pc -= 4;
}
#endif
CALL_MultiTexCoord3dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 24),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
{
CALL_MultiTexCoord3fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord3ivARB(GLbyte * pc)
{
CALL_MultiTexCoord3ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord3svARB(GLbyte * pc)
{
CALL_MultiTexCoord3svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 36);
pc -= 4;
}
#endif
CALL_MultiTexCoord4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 32),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
{
CALL_MultiTexCoord4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord4ivARB(GLbyte * pc)
{
CALL_MultiTexCoord4ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_MultiTexCoord4svARB(GLbyte * pc)
{
CALL_MultiTexCoord4svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_SampleCoverageARB(GLbyte * pc)
{
CALL_SampleCoverageARB(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
*(GLboolean *) (pc + 4)
));
}
void
__glXDisp_CompressedTexImage1DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 20);
CALL_CompressedTexImage1DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLint *) (pc + 16),
imageSize,
(const GLvoid *) (pc + 24)
));
}
void
__glXDisp_CompressedTexImage2DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 24);
CALL_CompressedTexImage2DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLsizei *) (pc + 16),
*(GLint *) (pc + 20),
imageSize,
(const GLvoid *) (pc + 28)
));
}
void
__glXDisp_CompressedTexImage3DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 28);
CALL_CompressedTexImage3DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLsizei *) (pc + 16),
*(GLsizei *) (pc + 20),
*(GLint *) (pc + 24),
imageSize,
(const GLvoid *) (pc + 32)
));
}
void
__glXDisp_CompressedTexSubImage1DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 20);
CALL_CompressedTexSubImage1DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLenum *) (pc + 16),
imageSize,
(const GLvoid *) (pc + 24)
));
}
void
__glXDisp_CompressedTexSubImage2DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 28);
CALL_CompressedTexSubImage2DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLsizei *) (pc + 16),
*(GLsizei *) (pc + 20),
*(GLenum *) (pc + 24),
imageSize,
(const GLvoid *) (pc + 32)
));
}
void
__glXDisp_CompressedTexSubImage3DARB(GLbyte * pc)
{
const GLsizei imageSize = *(GLsizei *) (pc + 36);
CALL_CompressedTexSubImage3DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLsizei *) (pc + 20),
*(GLsizei *) (pc + 24),
*(GLsizei *) (pc + 28),
*(GLenum *) (pc + 32),
imageSize,
(const GLvoid *) (pc + 40)
));
}
int
__glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLdouble params[4];
CALL_GetProgramEnvParameterdvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
params));
__glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLfloat params[4];
CALL_GetProgramEnvParameterfvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
params));
__glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLdouble params[4];
CALL_GetProgramLocalParameterdvARB(GET_DISPATCH(),
(*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4), params));
__glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLfloat params[4];
CALL_GetProgramLocalParameterfvARB(GET_DISPATCH(),
(*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4), params));
__glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetProgramivARB_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetProgramivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribdvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
GLdouble answerBuffer[200];
GLdouble *params =
__glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
sizeof(answerBuffer), 8);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribdvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribfvARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribfvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribivARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribivARB_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
void
__glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 40);
pc -= 4;
}
#endif
CALL_ProgramEnvParameter4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
(const GLdouble *) (pc + 8)
));
}
void
__glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
{
CALL_ProgramEnvParameter4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
(const GLfloat *) (pc + 8)
));
}
void
__glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 40);
pc -= 4;
}
#endif
CALL_ProgramLocalParameter4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
(const GLdouble *) (pc +
8)
));
}
void
__glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
{
CALL_ProgramLocalParameter4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
(const GLfloat *) (pc + 8)
));
}
void
__glXDisp_ProgramStringARB(GLbyte * pc)
{
const GLsizei len = *(GLsizei *) (pc + 8);
CALL_ProgramStringARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
len, (const GLvoid *) (pc + 12)
));
}
void
__glXDisp_VertexAttrib1dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 12);
pc -= 4;
}
#endif
CALL_VertexAttrib1dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib1fvARB(GLbyte * pc)
{
CALL_VertexAttrib1fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib1svARB(GLbyte * pc)
{
CALL_VertexAttrib1svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 20);
pc -= 4;
}
#endif
CALL_VertexAttrib2dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2fvARB(GLbyte * pc)
{
CALL_VertexAttrib2fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2svARB(GLbyte * pc)
{
CALL_VertexAttrib2svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 28);
pc -= 4;
}
#endif
CALL_VertexAttrib3dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3fvARB(GLbyte * pc)
{
CALL_VertexAttrib3fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3svARB(GLbyte * pc)
{
CALL_VertexAttrib3svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NbvARB(GLbyte * pc)
{
CALL_VertexAttrib4NbvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLbyte *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NivARB(GLbyte * pc)
{
CALL_VertexAttrib4NivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
{
CALL_VertexAttrib4NsvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NubvARB(GLbyte * pc)
{
CALL_VertexAttrib4NubvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLubyte *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NuivARB(GLbyte * pc)
{
CALL_VertexAttrib4NuivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLuint *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
{
CALL_VertexAttrib4NusvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLushort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4bvARB(GLbyte * pc)
{
CALL_VertexAttrib4bvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLbyte *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 36);
pc -= 4;
}
#endif
CALL_VertexAttrib4dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4fvARB(GLbyte * pc)
{
CALL_VertexAttrib4fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4ivARB(GLbyte * pc)
{
CALL_VertexAttrib4ivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLint *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4svARB(GLbyte * pc)
{
CALL_VertexAttrib4svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
{
CALL_VertexAttrib4ubvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLubyte *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4uivARB(GLbyte * pc)
{
CALL_VertexAttrib4uivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLuint *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4usvARB(GLbyte * pc)
{
CALL_VertexAttrib4usvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLushort *) (pc + 4)
));
}
void
__glXDisp_BeginQueryARB(GLbyte * pc)
{
CALL_BeginQueryARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4)
));
}
int
__glXDisp_DeleteQueriesARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteQueriesARB(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
error = Success;
}
return error;
}
void
__glXDisp_EndQueryARB(GLbyte * pc)
{
CALL_EndQueryARB(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
int
__glXDisp_GenQueriesARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *ids =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenQueriesARB(GET_DISPATCH(), (n, ids));
__glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetQueryObjectivARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetQueryObjectivARB_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetQueryObjectivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetQueryObjectuivARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
GLuint answerBuffer[200];
GLuint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetQueryObjectuivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetQueryivARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetQueryivARB_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetQueryivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_IsQueryARB(__GLXclientState * cl, GLbyte * pc)
{
xGLXSingleReq *const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_SINGLE_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsQueryARB(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_DrawBuffersARB(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DrawBuffersARB(GET_DISPATCH(), (n, (const GLenum *) (pc + 4)
));
}
void
__glXDisp_ClampColorARB(GLbyte * pc)
{
CALL_ClampColorARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4)
));
}
void
__glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
{
CALL_RenderbufferStorageMultisample(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLsizei *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLsizei *) (pc + 16)
));
}
void
__glXDisp_SampleMaskSGIS(GLbyte * pc)
{
CALL_SampleMaskSGIS(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
*(GLboolean *) (pc + 4)
));
}
void
__glXDisp_SamplePatternSGIS(GLbyte * pc)
{
CALL_SamplePatternSGIS(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
void
__glXDisp_PointParameterfEXT(GLbyte * pc)
{
CALL_PointParameterfEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLfloat *) (pc + 4)
));
}
void
__glXDisp_PointParameterfvEXT(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLfloat *params;
params = (const GLfloat *) (pc + 4);
CALL_PointParameterfvEXT(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_SecondaryColor3bvEXT(GLbyte * pc)
{
CALL_SecondaryColor3bvEXT(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3dvEXT(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 24);
pc -= 4;
}
#endif
CALL_SecondaryColor3dvEXT(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
{
CALL_SecondaryColor3fvEXT(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3ivEXT(GLbyte * pc)
{
CALL_SecondaryColor3ivEXT(GET_DISPATCH(), ((const GLint *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3svEXT(GLbyte * pc)
{
CALL_SecondaryColor3svEXT(GET_DISPATCH(), ((const GLshort *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3ubvEXT(GLbyte * pc)
{
CALL_SecondaryColor3ubvEXT(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3uivEXT(GLbyte * pc)
{
CALL_SecondaryColor3uivEXT(GET_DISPATCH(), ((const GLuint *) (pc + 0)
));
}
void
__glXDisp_SecondaryColor3usvEXT(GLbyte * pc)
{
CALL_SecondaryColor3usvEXT(GET_DISPATCH(), ((const GLushort *) (pc + 0)
));
}
void
__glXDisp_FogCoorddvEXT(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 8);
pc -= 4;
}
#endif
CALL_FogCoorddvEXT(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
));
}
void
__glXDisp_FogCoordfvEXT(GLbyte * pc)
{
CALL_FogCoordfvEXT(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
void
__glXDisp_BlendFuncSeparateEXT(GLbyte * pc)
{
CALL_BlendFuncSeparateEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLenum *) (pc + 12)
));
}
void
__glXDisp_WindowPos3fvMESA(GLbyte * pc)
{
CALL_WindowPos3fvMESA(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
));
}
int
__glXDisp_AreProgramsResidentNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLboolean retval;
GLboolean answerBuffer[200];
GLboolean *residences =
__glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
retval =
CALL_AreProgramsResidentNV(GET_DISPATCH(),
(n, (const GLuint *) (pc + 4),
residences));
__glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_BindProgramNV(GLbyte * pc)
{
CALL_BindProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4)
));
}
int
__glXDisp_DeleteProgramsNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteProgramsNV(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
error = Success;
}
return error;
}
void
__glXDisp_ExecuteProgramNV(GLbyte * pc)
{
CALL_ExecuteProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
(const GLfloat *) (pc + 8)
));
}
int
__glXDisp_GenProgramsNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *programs =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenProgramsNV(GET_DISPATCH(), (n, programs));
__glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramParameterdvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLdouble params[4];
CALL_GetProgramParameterdvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
*(GLenum *) (pc + 8),
params));
__glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramParameterfvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLfloat params[4];
CALL_GetProgramParameterfvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
*(GLenum *) (pc + 8),
params));
__glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramivNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetProgramivNV_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetProgramivNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetTrackMatrixivNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLint params[1];
CALL_GetTrackMatrixivNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
*(GLenum *) (pc + 8), params));
__glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribdvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
GLdouble answerBuffer[200];
GLdouble *params =
__glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
sizeof(answerBuffer), 8);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribdvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribfvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
GLfloat answerBuffer[200];
GLfloat *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribfvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetVertexAttribivNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLenum pname = *(GLenum *) (pc + 4);
const GLuint compsize = __glGetVertexAttribivNV_size(pname);
GLint answerBuffer[200];
GLint *params =
__glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
sizeof(answerBuffer), 4);
if (params == NULL)
return BadAlloc;
__glXClearErrorOccured();
CALL_GetVertexAttribivNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
pname, params));
__glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_IsProgramNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsProgramNV(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_LoadProgramNV(GLbyte * pc)
{
const GLsizei len = *(GLsizei *) (pc + 8);
CALL_LoadProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
len, (const GLubyte *) (pc + 12)
));
}
void
__glXDisp_ProgramParameters4dvNV(GLbyte * pc)
{
const GLsizei num = *(GLsizei *) (pc + 8);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_ProgramParameters4dvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
num,
(const GLdouble *) (pc + 12)
));
}
void
__glXDisp_ProgramParameters4fvNV(GLbyte * pc)
{
const GLsizei num = *(GLsizei *) (pc + 8);
CALL_ProgramParameters4fvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
num,
(const GLfloat *) (pc + 12)
));
}
void
__glXDisp_RequestResidentProgramsNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_RequestResidentProgramsNV(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
}
void
__glXDisp_TrackMatrixNV(GLbyte * pc)
{
CALL_TrackMatrixNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLenum *) (pc + 12)
));
}
void
__glXDisp_VertexAttrib1dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 12);
pc -= 4;
}
#endif
CALL_VertexAttrib1dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib1fvNV(GLbyte * pc)
{
CALL_VertexAttrib1fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib1svNV(GLbyte * pc)
{
CALL_VertexAttrib1svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 20);
pc -= 4;
}
#endif
CALL_VertexAttrib2dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2fvNV(GLbyte * pc)
{
CALL_VertexAttrib2fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib2svNV(GLbyte * pc)
{
CALL_VertexAttrib2svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 28);
pc -= 4;
}
#endif
CALL_VertexAttrib3dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3fvNV(GLbyte * pc)
{
CALL_VertexAttrib3fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib3svNV(GLbyte * pc)
{
CALL_VertexAttrib3svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, 36);
pc -= 4;
}
#endif
CALL_VertexAttrib4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLdouble *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4fvNV(GLbyte * pc)
{
CALL_VertexAttrib4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLfloat *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4svNV(GLbyte * pc)
{
CALL_VertexAttrib4svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLshort *) (pc + 4)
));
}
void
__glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
{
CALL_VertexAttrib4ubvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
(const GLubyte *) (pc + 4)
));
}
void
__glXDisp_VertexAttribs1dvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_VertexAttribs1dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLdouble *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs1fvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs1fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLfloat *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs1svNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs1svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLshort *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs2dvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_VertexAttribs2dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLdouble *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs2fvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs2fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLfloat *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs2svNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs2svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLshort *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs3dvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_VertexAttribs3dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLdouble *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs3fvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs3fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLfloat *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs3svNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs3svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLshort *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs4dvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_VertexAttribs4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLdouble *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs4fvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLfloat *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs4svNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs4svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLshort *) (pc + 8)
));
}
void
__glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 4);
CALL_VertexAttribs4ubvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
n, (const GLubyte *) (pc + 8)
));
}
void
__glXDisp_PointParameteriNV(GLbyte * pc)
{
CALL_PointParameteriNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLint *) (pc + 4)
));
}
void
__glXDisp_PointParameterivNV(GLbyte * pc)
{
const GLenum pname = *(GLenum *) (pc + 0);
const GLint *params;
params = (const GLint *) (pc + 4);
CALL_PointParameterivNV(GET_DISPATCH(), (pname, params));
}
void
__glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
{
CALL_ActiveStencilFaceEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
int
__glXDisp_GetProgramNamedParameterdvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei len = *(GLsizei *) (pc + 4);
GLdouble params[4];
CALL_GetProgramNamedParameterdvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
len,
(const GLubyte *) (pc
+
8),
params));
__glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetProgramNamedParameterfvNV(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei len = *(GLsizei *) (pc + 4);
GLfloat params[4];
CALL_GetProgramNamedParameterfvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
len,
(const GLubyte *) (pc
+
8),
params));
__glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
void
__glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
{
const GLsizei len = *(GLsizei *) (pc + 36);
#ifdef __GLX_ALIGN64
const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
if ((unsigned long) (pc) & 7) {
(void) memmove(pc - 4, pc, cmdlen);
pc -= 4;
}
#endif
CALL_ProgramNamedParameter4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 32),
len,
(const GLubyte *) (pc +
40),
(const GLdouble *) (pc + 0)
));
}
void
__glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
{
const GLsizei len = *(GLsizei *) (pc + 4);
CALL_ProgramNamedParameter4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
len,
(const GLubyte *) (pc +
24),
(const GLfloat *) (pc + 8)
));
}
void
__glXDisp_BlendEquationSeparateEXT(GLbyte * pc)
{
CALL_BlendEquationSeparateEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4)
));
}
void
__glXDisp_BindFramebufferEXT(GLbyte * pc)
{
CALL_BindFramebufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4)
));
}
void
__glXDisp_BindRenderbufferEXT(GLbyte * pc)
{
CALL_BindRenderbufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLuint *) (pc + 4)
));
}
int
__glXDisp_CheckFramebufferStatusEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLenum retval;
retval =
CALL_CheckFramebufferStatusEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_DeleteFramebuffersEXT(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteFramebuffersEXT(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
}
void
__glXDisp_DeleteRenderbuffersEXT(GLbyte * pc)
{
const GLsizei n = *(GLsizei *) (pc + 0);
CALL_DeleteRenderbuffersEXT(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
));
}
void
__glXDisp_FramebufferRenderbufferEXT(GLbyte * pc)
{
CALL_FramebufferRenderbufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLuint *) (pc + 12)
));
}
void
__glXDisp_FramebufferTexture1DEXT(GLbyte * pc)
{
CALL_FramebufferTexture1DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLuint *) (pc + 12),
*(GLint *) (pc + 16)
));
}
void
__glXDisp_FramebufferTexture2DEXT(GLbyte * pc)
{
CALL_FramebufferTexture2DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLuint *) (pc + 12),
*(GLint *) (pc + 16)
));
}
void
__glXDisp_FramebufferTexture3DEXT(GLbyte * pc)
{
CALL_FramebufferTexture3DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
*(GLuint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLint *) (pc + 20)
));
}
int
__glXDisp_GenFramebuffersEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *framebuffers =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenFramebuffersEXT(GET_DISPATCH(), (n, framebuffers));
__glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GenRenderbuffersEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
const GLsizei n = *(GLsizei *) (pc + 0);
GLuint answerBuffer[200];
GLuint *renderbuffers =
__glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
4);
CALL_GenRenderbuffersEXT(GET_DISPATCH(), (n, renderbuffers));
__glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
error = Success;
}
return error;
}
void
__glXDisp_GenerateMipmapEXT(GLbyte * pc)
{
CALL_GenerateMipmapEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
));
}
int
__glXDisp_GetFramebufferAttachmentParameterivEXT(__GLXclientState * cl,
GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLint params[1];
CALL_GetFramebufferAttachmentParameterivEXT(GET_DISPATCH(),
(*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLenum *) (pc + 8),
params));
__glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_GetRenderbufferParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLint params[1];
CALL_GetRenderbufferParameterivEXT(GET_DISPATCH(),
(*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4), params));
__glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
error = Success;
}
return error;
}
int
__glXDisp_IsFramebufferEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsFramebufferEXT(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
int
__glXDisp_IsRenderbufferEXT(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
int error;
__GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLboolean retval;
retval = CALL_IsRenderbufferEXT(GET_DISPATCH(), (*(GLuint *) (pc + 0)
));
__glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
error = Success;
}
return error;
}
void
__glXDisp_RenderbufferStorageEXT(GLbyte * pc)
{
CALL_RenderbufferStorageEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLsizei *) (pc + 8),
*(GLsizei *) (pc + 12)
));
}
void
__glXDisp_BlitFramebufferEXT(GLbyte * pc)
{
CALL_BlitFramebufferEXT(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLint *) (pc + 4),
*(GLint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16),
*(GLint *) (pc + 20),
*(GLint *) (pc + 24),
*(GLint *) (pc + 28),
*(GLbitfield *) (pc + 32),
*(GLenum *) (pc + 36)
));
}
void
__glXDisp_FramebufferTextureLayerEXT(GLbyte * pc)
{
CALL_FramebufferTextureLayerEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
*(GLenum *) (pc + 4),
*(GLuint *) (pc + 8),
*(GLint *) (pc + 12),
*(GLint *) (pc + 16)
));
}
Reference in New Issue View Git Blame Copy Permalink