diff options
Diffstat (limited to 'xorg-server/glx/indirect_dispatch.c')
| -rw-r--r-- | xorg-server/glx/indirect_dispatch.c | 5926 |
1 files changed, 3387 insertions, 2539 deletions
diff --git a/xorg-server/glx/indirect_dispatch.c b/xorg-server/glx/indirect_dispatch.c index 329b2e61e..67e5280c3 100644 --- a/xorg-server/glx/indirect_dispatch.c +++ b/xorg-server/glx/indirect_dispatch.c @@ -25,14 +25,25 @@ * SOFTWARE. */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif +#include "glheader.h" + +#include <X11/Xmd.h> +#include <GL/gl.h> +#include <GL/glxproto.h> #include <inttypes.h> -#include "glxserver.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 "dispatch.h" #define __GLX_PAD(x) (((x) + 3) & ~3) @@ -40,89 +51,94 @@ typedef struct { __GLX_PIXEL_3D_HDR; } __GLXpixel3DHeader; -extern GLboolean __glXErrorOccured(void); -extern void __glXClearErrorOccured(void); +extern GLboolean __glXErrorOccured( void ); +extern void __glXClearErrorOccured( void ); -static const unsigned dummy_answer[2] = { 0, 0 }; +static const unsigned dummy_answer[2] = {0, 0}; -int -__glXDisp_NewList(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - glNewList(*(GLuint *) (pc + 0), *(GLenum *) (pc + 4)); + if ( cx != NULL ) { + CALL_NewList( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_EndList(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - glEndList(); + if ( cx != NULL ) { + CALL_EndList( GET_DISPATCH(), () ); error = Success; } return error; } -void -__glXDisp_CallList(GLbyte * pc) +void __glXDisp_CallList(GLbyte * pc) { - glCallList(*(GLuint *) (pc + 0)); + CALL_CallList( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_CallLists(GLbyte * pc) +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); + const GLsizei n = *(GLsizei *)(pc + 0); + const GLenum type = *(GLenum *)(pc + 4); + const GLvoid * lists = (const GLvoid *)(pc + 8); - glCallLists(n, type, lists); + CALL_CallLists( GET_DISPATCH(), ( + n, + type, + lists + ) ); } -int -__glXDisp_DeleteLists(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - glDeleteLists(*(GLuint *) (pc + 0), *(GLsizei *) (pc + 4)); + if ( cx != NULL ) { + CALL_DeleteLists( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + *(GLsizei *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLuint retval; - - retval = glGenLists(*(GLsizei *) (pc + 0)); + retval = CALL_GenLists( GET_DISPATCH(), ( + *(GLsizei *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -130,1399 +146,1648 @@ __glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_ListBase(GLbyte * pc) +void __glXDisp_ListBase(GLbyte * pc) { - glListBase(*(GLuint *) (pc + 0)); + CALL_ListBase( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_Begin(GLbyte * pc) +void __glXDisp_Begin(GLbyte * pc) { - glBegin(*(GLenum *) (pc + 0)); + CALL_Begin( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_Bitmap(GLbyte * pc) +void __glXDisp_Bitmap(GLbyte * pc) { - const GLubyte *const bitmap = (const GLubyte *) ((pc + 44)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLubyte * const bitmap = (const GLubyte *) (pc + 44); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glBitmap(*(GLsizei *) (pc + 20), - *(GLsizei *) (pc + 24), - *(GLfloat *) (pc + 28), - *(GLfloat *) (pc + 32), - *(GLfloat *) (pc + 36), *(GLfloat *) (pc + 40), bitmap); + 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) +void __glXDisp_Color3bv(GLbyte * pc) { - glColor3bv((const GLbyte *) (pc + 0)); + CALL_Color3bv( GET_DISPATCH(), ( + (const GLbyte *)(pc + 0) + ) ); } -void -__glXDisp_Color3dv(GLbyte * pc) +void __glXDisp_Color3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glColor3dv((const GLdouble *) (pc + 0)); + CALL_Color3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Color3fv(GLbyte * pc) +void __glXDisp_Color3fv(GLbyte * pc) { - glColor3fv((const GLfloat *) (pc + 0)); + CALL_Color3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Color3iv(GLbyte * pc) +void __glXDisp_Color3iv(GLbyte * pc) { - glColor3iv((const GLint *) (pc + 0)); + CALL_Color3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Color3sv(GLbyte * pc) +void __glXDisp_Color3sv(GLbyte * pc) { - glColor3sv((const GLshort *) (pc + 0)); + CALL_Color3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Color3ubv(GLbyte * pc) +void __glXDisp_Color3ubv(GLbyte * pc) { - glColor3ubv((const GLubyte *) (pc + 0)); + CALL_Color3ubv( GET_DISPATCH(), ( + (const GLubyte *)(pc + 0) + ) ); } -void -__glXDisp_Color3uiv(GLbyte * pc) +void __glXDisp_Color3uiv(GLbyte * pc) { - glColor3uiv((const GLuint *) (pc + 0)); + CALL_Color3uiv( GET_DISPATCH(), ( + (const GLuint *)(pc + 0) + ) ); } -void -__glXDisp_Color3usv(GLbyte * pc) +void __glXDisp_Color3usv(GLbyte * pc) { - glColor3usv((const GLushort *) (pc + 0)); + CALL_Color3usv( GET_DISPATCH(), ( + (const GLushort *)(pc + 0) + ) ); } -void -__glXDisp_Color4bv(GLbyte * pc) +void __glXDisp_Color4bv(GLbyte * pc) { - glColor4bv((const GLbyte *) (pc + 0)); + CALL_Color4bv( GET_DISPATCH(), ( + (const GLbyte *)(pc + 0) + ) ); } -void -__glXDisp_Color4dv(GLbyte * pc) +void __glXDisp_Color4dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glColor4dv((const GLdouble *) (pc + 0)); + CALL_Color4dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Color4fv(GLbyte * pc) +void __glXDisp_Color4fv(GLbyte * pc) { - glColor4fv((const GLfloat *) (pc + 0)); + CALL_Color4fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Color4iv(GLbyte * pc) +void __glXDisp_Color4iv(GLbyte * pc) { - glColor4iv((const GLint *) (pc + 0)); + CALL_Color4iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Color4sv(GLbyte * pc) +void __glXDisp_Color4sv(GLbyte * pc) { - glColor4sv((const GLshort *) (pc + 0)); + CALL_Color4sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Color4ubv(GLbyte * pc) +void __glXDisp_Color4ubv(GLbyte * pc) { - glColor4ubv((const GLubyte *) (pc + 0)); + CALL_Color4ubv( GET_DISPATCH(), ( + (const GLubyte *)(pc + 0) + ) ); } -void -__glXDisp_Color4uiv(GLbyte * pc) +void __glXDisp_Color4uiv(GLbyte * pc) { - glColor4uiv((const GLuint *) (pc + 0)); + CALL_Color4uiv( GET_DISPATCH(), ( + (const GLuint *)(pc + 0) + ) ); } -void -__glXDisp_Color4usv(GLbyte * pc) +void __glXDisp_Color4usv(GLbyte * pc) { - glColor4usv((const GLushort *) (pc + 0)); + CALL_Color4usv( GET_DISPATCH(), ( + (const GLushort *)(pc + 0) + ) ); } -void -__glXDisp_EdgeFlagv(GLbyte * pc) +void __glXDisp_EdgeFlagv(GLbyte * pc) { - glEdgeFlagv((const GLboolean *) (pc + 0)); + CALL_EdgeFlagv( GET_DISPATCH(), ( + (const GLboolean *)(pc + 0) + ) ); } -void -__glXDisp_End(GLbyte * pc) +void __glXDisp_End(GLbyte * pc) { - glEnd(); + CALL_End( GET_DISPATCH(), () ); } -void -__glXDisp_Indexdv(GLbyte * pc) +void __glXDisp_Indexdv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 8); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 8); pc -= 4; } #endif - glIndexdv((const GLdouble *) (pc + 0)); + CALL_Indexdv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Indexfv(GLbyte * pc) +void __glXDisp_Indexfv(GLbyte * pc) { - glIndexfv((const GLfloat *) (pc + 0)); + CALL_Indexfv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Indexiv(GLbyte * pc) +void __glXDisp_Indexiv(GLbyte * pc) { - glIndexiv((const GLint *) (pc + 0)); + CALL_Indexiv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Indexsv(GLbyte * pc) +void __glXDisp_Indexsv(GLbyte * pc) { - glIndexsv((const GLshort *) (pc + 0)); + CALL_Indexsv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Normal3bv(GLbyte * pc) +void __glXDisp_Normal3bv(GLbyte * pc) { - glNormal3bv((const GLbyte *) (pc + 0)); + CALL_Normal3bv( GET_DISPATCH(), ( + (const GLbyte *)(pc + 0) + ) ); } -void -__glXDisp_Normal3dv(GLbyte * pc) +void __glXDisp_Normal3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glNormal3dv((const GLdouble *) (pc + 0)); + CALL_Normal3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Normal3fv(GLbyte * pc) +void __glXDisp_Normal3fv(GLbyte * pc) { - glNormal3fv((const GLfloat *) (pc + 0)); + CALL_Normal3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Normal3iv(GLbyte * pc) +void __glXDisp_Normal3iv(GLbyte * pc) { - glNormal3iv((const GLint *) (pc + 0)); + CALL_Normal3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Normal3sv(GLbyte * pc) +void __glXDisp_Normal3sv(GLbyte * pc) { - glNormal3sv((const GLshort *) (pc + 0)); + CALL_Normal3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos2dv(GLbyte * pc) +void __glXDisp_RasterPos2dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glRasterPos2dv((const GLdouble *) (pc + 0)); + CALL_RasterPos2dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos2fv(GLbyte * pc) +void __glXDisp_RasterPos2fv(GLbyte * pc) { - glRasterPos2fv((const GLfloat *) (pc + 0)); + CALL_RasterPos2fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos2iv(GLbyte * pc) +void __glXDisp_RasterPos2iv(GLbyte * pc) { - glRasterPos2iv((const GLint *) (pc + 0)); + CALL_RasterPos2iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos2sv(GLbyte * pc) +void __glXDisp_RasterPos2sv(GLbyte * pc) { - glRasterPos2sv((const GLshort *) (pc + 0)); + CALL_RasterPos2sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos3dv(GLbyte * pc) +void __glXDisp_RasterPos3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glRasterPos3dv((const GLdouble *) (pc + 0)); + CALL_RasterPos3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos3fv(GLbyte * pc) +void __glXDisp_RasterPos3fv(GLbyte * pc) { - glRasterPos3fv((const GLfloat *) (pc + 0)); + CALL_RasterPos3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos3iv(GLbyte * pc) +void __glXDisp_RasterPos3iv(GLbyte * pc) { - glRasterPos3iv((const GLint *) (pc + 0)); + CALL_RasterPos3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos3sv(GLbyte * pc) +void __glXDisp_RasterPos3sv(GLbyte * pc) { - glRasterPos3sv((const GLshort *) (pc + 0)); + CALL_RasterPos3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos4dv(GLbyte * pc) +void __glXDisp_RasterPos4dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glRasterPos4dv((const GLdouble *) (pc + 0)); + CALL_RasterPos4dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos4fv(GLbyte * pc) +void __glXDisp_RasterPos4fv(GLbyte * pc) { - glRasterPos4fv((const GLfloat *) (pc + 0)); + CALL_RasterPos4fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos4iv(GLbyte * pc) +void __glXDisp_RasterPos4iv(GLbyte * pc) { - glRasterPos4iv((const GLint *) (pc + 0)); + CALL_RasterPos4iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_RasterPos4sv(GLbyte * pc) +void __glXDisp_RasterPos4sv(GLbyte * pc) { - glRasterPos4sv((const GLshort *) (pc + 0)); + CALL_RasterPos4sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Rectdv(GLbyte * pc) +void __glXDisp_Rectdv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glRectdv((const GLdouble *) (pc + 0), (const GLdouble *) (pc + 16)); + CALL_Rectdv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0), + (const GLdouble *)(pc + 16) + ) ); } -void -__glXDisp_Rectfv(GLbyte * pc) +void __glXDisp_Rectfv(GLbyte * pc) { - glRectfv((const GLfloat *) (pc + 0), (const GLfloat *) (pc + 8)); + CALL_Rectfv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0), + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_Rectiv(GLbyte * pc) +void __glXDisp_Rectiv(GLbyte * pc) { - glRectiv((const GLint *) (pc + 0), (const GLint *) (pc + 8)); + CALL_Rectiv( GET_DISPATCH(), ( + (const GLint *)(pc + 0), + (const GLint *)(pc + 8) + ) ); } -void -__glXDisp_Rectsv(GLbyte * pc) +void __glXDisp_Rectsv(GLbyte * pc) { - glRectsv((const GLshort *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_Rectsv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_TexCoord1dv(GLbyte * pc) +void __glXDisp_TexCoord1dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 8); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 8); pc -= 4; } #endif - glTexCoord1dv((const GLdouble *) (pc + 0)); + CALL_TexCoord1dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord1fv(GLbyte * pc) +void __glXDisp_TexCoord1fv(GLbyte * pc) { - glTexCoord1fv((const GLfloat *) (pc + 0)); + CALL_TexCoord1fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord1iv(GLbyte * pc) +void __glXDisp_TexCoord1iv(GLbyte * pc) { - glTexCoord1iv((const GLint *) (pc + 0)); + CALL_TexCoord1iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord1sv(GLbyte * pc) +void __glXDisp_TexCoord1sv(GLbyte * pc) { - glTexCoord1sv((const GLshort *) (pc + 0)); + CALL_TexCoord1sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord2dv(GLbyte * pc) +void __glXDisp_TexCoord2dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glTexCoord2dv((const GLdouble *) (pc + 0)); + CALL_TexCoord2dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord2fv(GLbyte * pc) +void __glXDisp_TexCoord2fv(GLbyte * pc) { - glTexCoord2fv((const GLfloat *) (pc + 0)); + CALL_TexCoord2fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord2iv(GLbyte * pc) +void __glXDisp_TexCoord2iv(GLbyte * pc) { - glTexCoord2iv((const GLint *) (pc + 0)); + CALL_TexCoord2iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord2sv(GLbyte * pc) +void __glXDisp_TexCoord2sv(GLbyte * pc) { - glTexCoord2sv((const GLshort *) (pc + 0)); + CALL_TexCoord2sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord3dv(GLbyte * pc) +void __glXDisp_TexCoord3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glTexCoord3dv((const GLdouble *) (pc + 0)); + CALL_TexCoord3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord3fv(GLbyte * pc) +void __glXDisp_TexCoord3fv(GLbyte * pc) { - glTexCoord3fv((const GLfloat *) (pc + 0)); + CALL_TexCoord3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord3iv(GLbyte * pc) +void __glXDisp_TexCoord3iv(GLbyte * pc) { - glTexCoord3iv((const GLint *) (pc + 0)); + CALL_TexCoord3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord3sv(GLbyte * pc) +void __glXDisp_TexCoord3sv(GLbyte * pc) { - glTexCoord3sv((const GLshort *) (pc + 0)); + CALL_TexCoord3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord4dv(GLbyte * pc) +void __glXDisp_TexCoord4dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glTexCoord4dv((const GLdouble *) (pc + 0)); + CALL_TexCoord4dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord4fv(GLbyte * pc) +void __glXDisp_TexCoord4fv(GLbyte * pc) { - glTexCoord4fv((const GLfloat *) (pc + 0)); + CALL_TexCoord4fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord4iv(GLbyte * pc) +void __glXDisp_TexCoord4iv(GLbyte * pc) { - glTexCoord4iv((const GLint *) (pc + 0)); + CALL_TexCoord4iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_TexCoord4sv(GLbyte * pc) +void __glXDisp_TexCoord4sv(GLbyte * pc) { - glTexCoord4sv((const GLshort *) (pc + 0)); + CALL_TexCoord4sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Vertex2dv(GLbyte * pc) +void __glXDisp_Vertex2dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glVertex2dv((const GLdouble *) (pc + 0)); + CALL_Vertex2dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Vertex2fv(GLbyte * pc) +void __glXDisp_Vertex2fv(GLbyte * pc) { - glVertex2fv((const GLfloat *) (pc + 0)); + CALL_Vertex2fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Vertex2iv(GLbyte * pc) +void __glXDisp_Vertex2iv(GLbyte * pc) { - glVertex2iv((const GLint *) (pc + 0)); + CALL_Vertex2iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Vertex2sv(GLbyte * pc) +void __glXDisp_Vertex2sv(GLbyte * pc) { - glVertex2sv((const GLshort *) (pc + 0)); + CALL_Vertex2sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Vertex3dv(GLbyte * pc) +void __glXDisp_Vertex3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glVertex3dv((const GLdouble *) (pc + 0)); + CALL_Vertex3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Vertex3fv(GLbyte * pc) +void __glXDisp_Vertex3fv(GLbyte * pc) { - glVertex3fv((const GLfloat *) (pc + 0)); + CALL_Vertex3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Vertex3iv(GLbyte * pc) +void __glXDisp_Vertex3iv(GLbyte * pc) { - glVertex3iv((const GLint *) (pc + 0)); + CALL_Vertex3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Vertex3sv(GLbyte * pc) +void __glXDisp_Vertex3sv(GLbyte * pc) { - glVertex3sv((const GLshort *) (pc + 0)); + CALL_Vertex3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_Vertex4dv(GLbyte * pc) +void __glXDisp_Vertex4dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glVertex4dv((const GLdouble *) (pc + 0)); + CALL_Vertex4dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Vertex4fv(GLbyte * pc) +void __glXDisp_Vertex4fv(GLbyte * pc) { - glVertex4fv((const GLfloat *) (pc + 0)); + CALL_Vertex4fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Vertex4iv(GLbyte * pc) +void __glXDisp_Vertex4iv(GLbyte * pc) { - glVertex4iv((const GLint *) (pc + 0)); + CALL_Vertex4iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_Vertex4sv(GLbyte * pc) +void __glXDisp_Vertex4sv(GLbyte * pc) { - glVertex4sv((const GLshort *) (pc + 0)); + CALL_Vertex4sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_ClipPlane(GLbyte * pc) +void __glXDisp_ClipPlane(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 36); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 36); pc -= 4; } #endif - glClipPlane(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0)); + CALL_ClipPlane( GET_DISPATCH(), ( + *(GLenum *)(pc + 32), + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_ColorMaterial(GLbyte * pc) +void __glXDisp_ColorMaterial(GLbyte * pc) { - glColorMaterial(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + CALL_ColorMaterial( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); } -void -__glXDisp_CullFace(GLbyte * pc) +void __glXDisp_CullFace(GLbyte * pc) { - glCullFace(*(GLenum *) (pc + 0)); + CALL_CullFace( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_Fogf(GLbyte * pc) +void __glXDisp_Fogf(GLbyte * pc) { - glFogf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_Fogf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_Fogfv(GLbyte * pc) +void __glXDisp_Fogfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 0); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLfloat * params; params = (const GLfloat *) (pc + 4); - glFogfv(pname, params); + CALL_Fogfv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_Fogi(GLbyte * pc) +void __glXDisp_Fogi(GLbyte * pc) { - glFogi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4)); + CALL_Fogi( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ) ); } -void -__glXDisp_Fogiv(GLbyte * pc) +void __glXDisp_Fogiv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 0); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLint * params; params = (const GLint *) (pc + 4); - glFogiv(pname, params); + CALL_Fogiv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_FrontFace(GLbyte * pc) +void __glXDisp_FrontFace(GLbyte * pc) { - glFrontFace(*(GLenum *) (pc + 0)); + CALL_FrontFace( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_Hint(GLbyte * pc) +void __glXDisp_Hint(GLbyte * pc) { - glHint(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + CALL_Hint( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); } -void -__glXDisp_Lightf(GLbyte * pc) +void __glXDisp_Lightf(GLbyte * pc) { - glLightf(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_Lightf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_Lightfv(GLbyte * pc) +void __glXDisp_Lightfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glLightfv(*(GLenum *) (pc + 0), pname, params); + CALL_Lightfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_Lighti(GLbyte * pc) +void __glXDisp_Lighti(GLbyte * pc) { - glLighti(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_Lighti( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_Lightiv(GLbyte * pc) +void __glXDisp_Lightiv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glLightiv(*(GLenum *) (pc + 0), pname, params); + CALL_Lightiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_LightModelf(GLbyte * pc) +void __glXDisp_LightModelf(GLbyte * pc) { - glLightModelf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_LightModelf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_LightModelfv(GLbyte * pc) +void __glXDisp_LightModelfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 0); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLfloat * params; params = (const GLfloat *) (pc + 4); - glLightModelfv(pname, params); + CALL_LightModelfv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_LightModeli(GLbyte * pc) +void __glXDisp_LightModeli(GLbyte * pc) { - glLightModeli(*(GLenum *) (pc + 0), *(GLint *) (pc + 4)); + CALL_LightModeli( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ) ); } -void -__glXDisp_LightModeliv(GLbyte * pc) +void __glXDisp_LightModeliv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 0); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLint * params; params = (const GLint *) (pc + 4); - glLightModeliv(pname, params); + CALL_LightModeliv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_LineStipple(GLbyte * pc) +void __glXDisp_LineStipple(GLbyte * pc) { - glLineStipple(*(GLint *) (pc + 0), *(GLushort *) (pc + 4)); + CALL_LineStipple( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLushort *)(pc + 4) + ) ); } -void -__glXDisp_LineWidth(GLbyte * pc) +void __glXDisp_LineWidth(GLbyte * pc) { - glLineWidth(*(GLfloat *) (pc + 0)); + CALL_LineWidth( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_Materialf(GLbyte * pc) +void __glXDisp_Materialf(GLbyte * pc) { - glMaterialf(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_Materialf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_Materialfv(GLbyte * pc) +void __glXDisp_Materialfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glMaterialfv(*(GLenum *) (pc + 0), pname, params); + CALL_Materialfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_Materiali(GLbyte * pc) +void __glXDisp_Materiali(GLbyte * pc) { - glMateriali(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_Materiali( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_Materialiv(GLbyte * pc) +void __glXDisp_Materialiv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glMaterialiv(*(GLenum *) (pc + 0), pname, params); + CALL_Materialiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_PointSize(GLbyte * pc) +void __glXDisp_PointSize(GLbyte * pc) { - glPointSize(*(GLfloat *) (pc + 0)); + CALL_PointSize( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_PolygonMode(GLbyte * pc) +void __glXDisp_PolygonMode(GLbyte * pc) { - glPolygonMode(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + CALL_PolygonMode( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); } -void -__glXDisp_PolygonStipple(GLbyte * pc) +void __glXDisp_PolygonStipple(GLbyte * pc) { - const GLubyte *const mask = (const GLubyte *) ((pc + 20)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLubyte * const mask = (const GLubyte *) (pc + 20); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glPolygonStipple(mask); + CALL_PolygonStipple( GET_DISPATCH(), ( + mask + ) ); } -void -__glXDisp_Scissor(GLbyte * pc) +void __glXDisp_Scissor(GLbyte * pc) { - glScissor(*(GLint *) (pc + 0), - *(GLint *) (pc + 4), - *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)); + CALL_Scissor( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12) + ) ); } -void -__glXDisp_ShadeModel(GLbyte * pc) +void __glXDisp_ShadeModel(GLbyte * pc) { - glShadeModel(*(GLenum *) (pc + 0)); + CALL_ShadeModel( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_TexParameterf(GLbyte * pc) +void __glXDisp_TexParameterf(GLbyte * pc) { - glTexParameterf(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_TexParameterf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_TexParameterfv(GLbyte * pc) +void __glXDisp_TexParameterfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glTexParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_TexParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexParameteri(GLbyte * pc) +void __glXDisp_TexParameteri(GLbyte * pc) { - glTexParameteri(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_TexParameteri( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_TexParameteriv(GLbyte * pc) +void __glXDisp_TexParameteriv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glTexParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_TexParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexImage1D(GLbyte * pc) +void __glXDisp_TexImage1D(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 52)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 52); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexImage1D(*(GLenum *) (pc + 20), - *(GLint *) (pc + 24), - *(GLint *) (pc + 28), - *(GLsizei *) (pc + 32), - *(GLint *) (pc + 40), - *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels); + 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) +void __glXDisp_TexImage2D(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 52)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 52); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexImage2D(*(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); + 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) +void __glXDisp_TexEnvf(GLbyte * pc) { - glTexEnvf(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_TexEnvf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_TexEnvfv(GLbyte * pc) +void __glXDisp_TexEnvfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glTexEnvfv(*(GLenum *) (pc + 0), pname, params); + CALL_TexEnvfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexEnvi(GLbyte * pc) +void __glXDisp_TexEnvi(GLbyte * pc) { - glTexEnvi(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_TexEnvi( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_TexEnviv(GLbyte * pc) +void __glXDisp_TexEnviv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glTexEnviv(*(GLenum *) (pc + 0), pname, params); + CALL_TexEnviv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexGend(GLbyte * pc) +void __glXDisp_TexGend(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glTexGend(*(GLenum *) (pc + 8), - *(GLenum *) (pc + 12), *(GLdouble *) (pc + 0)); + CALL_TexGend( GET_DISPATCH(), ( + *(GLenum *)(pc + 8), + *(GLenum *)(pc + 12), + *(GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_TexGendv(GLbyte * pc) +void __glXDisp_TexGendv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLdouble *params; + 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); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif params = (const GLdouble *) (pc + 8); - glTexGendv(*(GLenum *) (pc + 0), pname, params); + CALL_TexGendv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexGenf(GLbyte * pc) +void __glXDisp_TexGenf(GLbyte * pc) { - glTexGenf(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_TexGenf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_TexGenfv(GLbyte * pc) +void __glXDisp_TexGenfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glTexGenfv(*(GLenum *) (pc + 0), pname, params); + CALL_TexGenfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_TexGeni(GLbyte * pc) +void __glXDisp_TexGeni(GLbyte * pc) { - glTexGeni(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_TexGeni( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_TexGeniv(GLbyte * pc) +void __glXDisp_TexGeniv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glTexGeniv(*(GLenum *) (pc + 0), pname, params); + CALL_TexGeniv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_InitNames(GLbyte * pc) +void __glXDisp_InitNames(GLbyte * pc) { - glInitNames(); + CALL_InitNames( GET_DISPATCH(), () ); } -void -__glXDisp_LoadName(GLbyte * pc) +void __glXDisp_LoadName(GLbyte * pc) { - glLoadName(*(GLuint *) (pc + 0)); + CALL_LoadName( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_PassThrough(GLbyte * pc) +void __glXDisp_PassThrough(GLbyte * pc) { - glPassThrough(*(GLfloat *) (pc + 0)); + CALL_PassThrough( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_PopName(GLbyte * pc) +void __glXDisp_PopName(GLbyte * pc) { - glPopName(); + CALL_PopName( GET_DISPATCH(), () ); } -void -__glXDisp_PushName(GLbyte * pc) +void __glXDisp_PushName(GLbyte * pc) { - glPushName(*(GLuint *) (pc + 0)); + CALL_PushName( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_DrawBuffer(GLbyte * pc) +void __glXDisp_DrawBuffer(GLbyte * pc) { - glDrawBuffer(*(GLenum *) (pc + 0)); + CALL_DrawBuffer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_Clear(GLbyte * pc) +void __glXDisp_Clear(GLbyte * pc) { - glClear(*(GLbitfield *) (pc + 0)); + CALL_Clear( GET_DISPATCH(), ( + *(GLbitfield *)(pc + 0) + ) ); } -void -__glXDisp_ClearAccum(GLbyte * pc) +void __glXDisp_ClearAccum(GLbyte * pc) { - glClearAccum(*(GLfloat *) (pc + 0), - *(GLfloat *) (pc + 4), - *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12)); + CALL_ClearAccum( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8), + *(GLfloat *)(pc + 12) + ) ); } -void -__glXDisp_ClearIndex(GLbyte * pc) +void __glXDisp_ClearIndex(GLbyte * pc) { - glClearIndex(*(GLfloat *) (pc + 0)); + CALL_ClearIndex( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_ClearColor(GLbyte * pc) +void __glXDisp_ClearColor(GLbyte * pc) { - glClearColor(*(GLclampf *) (pc + 0), - *(GLclampf *) (pc + 4), - *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12)); + CALL_ClearColor( GET_DISPATCH(), ( + *(GLclampf *)(pc + 0), + *(GLclampf *)(pc + 4), + *(GLclampf *)(pc + 8), + *(GLclampf *)(pc + 12) + ) ); } -void -__glXDisp_ClearStencil(GLbyte * pc) +void __glXDisp_ClearStencil(GLbyte * pc) { - glClearStencil(*(GLint *) (pc + 0)); + CALL_ClearStencil( GET_DISPATCH(), ( + *(GLint *)(pc + 0) + ) ); } -void -__glXDisp_ClearDepth(GLbyte * pc) +void __glXDisp_ClearDepth(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 8); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 8); pc -= 4; } #endif - glClearDepth(*(GLclampd *) (pc + 0)); + CALL_ClearDepth( GET_DISPATCH(), ( + *(GLclampd *)(pc + 0) + ) ); } -void -__glXDisp_StencilMask(GLbyte * pc) +void __glXDisp_StencilMask(GLbyte * pc) { - glStencilMask(*(GLuint *) (pc + 0)); + CALL_StencilMask( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_ColorMask(GLbyte * pc) +void __glXDisp_ColorMask(GLbyte * pc) { - glColorMask(*(GLboolean *) (pc + 0), - *(GLboolean *) (pc + 1), - *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3)); + CALL_ColorMask( GET_DISPATCH(), ( + *(GLboolean *)(pc + 0), + *(GLboolean *)(pc + 1), + *(GLboolean *)(pc + 2), + *(GLboolean *)(pc + 3) + ) ); } -void -__glXDisp_DepthMask(GLbyte * pc) +void __glXDisp_DepthMask(GLbyte * pc) { - glDepthMask(*(GLboolean *) (pc + 0)); + CALL_DepthMask( GET_DISPATCH(), ( + *(GLboolean *)(pc + 0) + ) ); } -void -__glXDisp_IndexMask(GLbyte * pc) +void __glXDisp_IndexMask(GLbyte * pc) { - glIndexMask(*(GLuint *) (pc + 0)); + CALL_IndexMask( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); } -void -__glXDisp_Accum(GLbyte * pc) +void __glXDisp_Accum(GLbyte * pc) { - glAccum(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_Accum( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_Disable(GLbyte * pc) +void __glXDisp_Disable(GLbyte * pc) { - glDisable(*(GLenum *) (pc + 0)); + CALL_Disable( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_Enable(GLbyte * pc) +void __glXDisp_Enable(GLbyte * pc) { - glEnable(*(GLenum *) (pc + 0)); + CALL_Enable( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_PopAttrib(GLbyte * pc) +void __glXDisp_PopAttrib(GLbyte * pc) { - glPopAttrib(); + CALL_PopAttrib( GET_DISPATCH(), () ); } -void -__glXDisp_PushAttrib(GLbyte * pc) +void __glXDisp_PushAttrib(GLbyte * pc) { - glPushAttrib(*(GLbitfield *) (pc + 0)); + CALL_PushAttrib( GET_DISPATCH(), ( + *(GLbitfield *)(pc + 0) + ) ); } -void -__glXDisp_MapGrid1d(GLbyte * pc) +void __glXDisp_MapGrid1d(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 20); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 20); pc -= 4; } #endif - glMapGrid1d(*(GLint *) (pc + 16), - *(GLdouble *) (pc + 0), *(GLdouble *) (pc + 8)); + CALL_MapGrid1d( GET_DISPATCH(), ( + *(GLint *)(pc + 16), + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_MapGrid1f(GLbyte * pc) +void __glXDisp_MapGrid1f(GLbyte * pc) { - glMapGrid1f(*(GLint *) (pc + 0), - *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_MapGrid1f( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_MapGrid2d(GLbyte * pc) +void __glXDisp_MapGrid2d(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 40); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 40); pc -= 4; } #endif - glMapGrid2d(*(GLint *) (pc + 32), - *(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), - *(GLint *) (pc + 36), - *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24)); + 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) +void __glXDisp_MapGrid2f(GLbyte * pc) { - glMapGrid2f(*(GLint *) (pc + 0), - *(GLfloat *) (pc + 4), - *(GLfloat *) (pc + 8), - *(GLint *) (pc + 12), - *(GLfloat *) (pc + 16), *(GLfloat *) (pc + 20)); + 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) +void __glXDisp_EvalCoord1dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 8); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 8); pc -= 4; } #endif - glEvalCoord1dv((const GLdouble *) (pc + 0)); + CALL_EvalCoord1dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_EvalCoord1fv(GLbyte * pc) +void __glXDisp_EvalCoord1fv(GLbyte * pc) { - glEvalCoord1fv((const GLfloat *) (pc + 0)); + CALL_EvalCoord1fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_EvalCoord2dv(GLbyte * pc) +void __glXDisp_EvalCoord2dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glEvalCoord2dv((const GLdouble *) (pc + 0)); + CALL_EvalCoord2dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_EvalCoord2fv(GLbyte * pc) +void __glXDisp_EvalCoord2fv(GLbyte * pc) { - glEvalCoord2fv((const GLfloat *) (pc + 0)); + CALL_EvalCoord2fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_EvalMesh1(GLbyte * pc) +void __glXDisp_EvalMesh1(GLbyte * pc) { - glEvalMesh1(*(GLenum *) (pc + 0), *(GLint *) (pc + 4), *(GLint *) (pc + 8)); + CALL_EvalMesh1( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_EvalPoint1(GLbyte * pc) +void __glXDisp_EvalPoint1(GLbyte * pc) { - glEvalPoint1(*(GLint *) (pc + 0)); + CALL_EvalPoint1( GET_DISPATCH(), ( + *(GLint *)(pc + 0) + ) ); } -void -__glXDisp_EvalMesh2(GLbyte * pc) +void __glXDisp_EvalMesh2(GLbyte * pc) { - glEvalMesh2(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), *(GLint *) (pc + 16)); + CALL_EvalMesh2( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16) + ) ); } -void -__glXDisp_EvalPoint2(GLbyte * pc) +void __glXDisp_EvalPoint2(GLbyte * pc) { - glEvalPoint2(*(GLint *) (pc + 0), *(GLint *) (pc + 4)); + CALL_EvalPoint2( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4) + ) ); } -void -__glXDisp_AlphaFunc(GLbyte * pc) +void __glXDisp_AlphaFunc(GLbyte * pc) { - glAlphaFunc(*(GLenum *) (pc + 0), *(GLclampf *) (pc + 4)); + CALL_AlphaFunc( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLclampf *)(pc + 4) + ) ); } -void -__glXDisp_BlendFunc(GLbyte * pc) +void __glXDisp_BlendFunc(GLbyte * pc) { - glBlendFunc(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + CALL_BlendFunc( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); } -void -__glXDisp_LogicOp(GLbyte * pc) +void __glXDisp_LogicOp(GLbyte * pc) { - glLogicOp(*(GLenum *) (pc + 0)); + CALL_LogicOp( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_StencilFunc(GLbyte * pc) +void __glXDisp_StencilFunc(GLbyte * pc) { - glStencilFunc(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), *(GLuint *) (pc + 8)); + CALL_StencilFunc( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLuint *)(pc + 8) + ) ); } -void -__glXDisp_StencilOp(GLbyte * pc) +void __glXDisp_StencilOp(GLbyte * pc) { - glStencilOp(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLenum *) (pc + 8)); + CALL_StencilOp( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8) + ) ); } -void -__glXDisp_DepthFunc(GLbyte * pc) +void __glXDisp_DepthFunc(GLbyte * pc) { - glDepthFunc(*(GLenum *) (pc + 0)); + CALL_DepthFunc( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_PixelZoom(GLbyte * pc) +void __glXDisp_PixelZoom(GLbyte * pc) { - glPixelZoom(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_PixelZoom( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_PixelTransferf(GLbyte * pc) +void __glXDisp_PixelTransferf(GLbyte * pc) { - glPixelTransferf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_PixelTransferf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_PixelTransferi(GLbyte * pc) +void __glXDisp_PixelTransferi(GLbyte * pc) { - glPixelTransferi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4)); + CALL_PixelTransferi( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ) ); } -int -__glXDisp_PixelStoref(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - glPixelStoref(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + if ( cx != NULL ) { + CALL_PixelStoref( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_PixelStorei(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - glPixelStorei(*(GLenum *) (pc + 0), *(GLint *) (pc + 4)); + if ( cx != NULL ) { + CALL_PixelStorei( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ) ); error = Success; } return error; } -void -__glXDisp_PixelMapfv(GLbyte * pc) +void __glXDisp_PixelMapfv(GLbyte * pc) { - const GLsizei mapsize = *(GLsizei *) (pc + 4); + const GLsizei mapsize = *(GLsizei *)(pc + 4); - glPixelMapfv(*(GLenum *) (pc + 0), mapsize, (const GLfloat *) (pc + 8)); + CALL_PixelMapfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + mapsize, + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_PixelMapuiv(GLbyte * pc) +void __glXDisp_PixelMapuiv(GLbyte * pc) { - const GLsizei mapsize = *(GLsizei *) (pc + 4); + const GLsizei mapsize = *(GLsizei *)(pc + 4); - glPixelMapuiv(*(GLenum *) (pc + 0), mapsize, (const GLuint *) (pc + 8)); + CALL_PixelMapuiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + mapsize, + (const GLuint *)(pc + 8) + ) ); } -void -__glXDisp_PixelMapusv(GLbyte * pc) +void __glXDisp_PixelMapusv(GLbyte * pc) { - const GLsizei mapsize = *(GLsizei *) (pc + 4); + const GLsizei mapsize = *(GLsizei *)(pc + 4); - glPixelMapusv(*(GLenum *) (pc + 0), mapsize, (const GLushort *) (pc + 8)); + CALL_PixelMapusv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + mapsize, + (const GLushort *)(pc + 8) + ) ); } -void -__glXDisp_ReadBuffer(GLbyte * pc) +void __glXDisp_ReadBuffer(GLbyte * pc) { - glReadBuffer(*(GLenum *) (pc + 0)); + CALL_ReadBuffer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_CopyPixels(GLbyte * pc) +void __glXDisp_CopyPixels(GLbyte * pc) { - glCopyPixels(*(GLint *) (pc + 0), - *(GLint *) (pc + 4), - *(GLsizei *) (pc + 8), - *(GLsizei *) (pc + 12), *(GLenum *) (pc + 16)); + CALL_CopyPixels( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12), + *(GLenum *)(pc + 16) + ) ); } -void -__glXDisp_DrawPixels(GLbyte * pc) +void __glXDisp_DrawPixels(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 36)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 36); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glDrawPixels(*(GLsizei *) (pc + 20), - *(GLsizei *) (pc + 24), - *(GLenum *) (pc + 28), *(GLenum *) (pc + 32), pixels); + CALL_DrawPixels( GET_DISPATCH(), ( + *(GLsizei *)(pc + 20), + *(GLsizei *)(pc + 24), + *(GLenum *)(pc + 28), + *(GLenum *)(pc + 32), + pixels + ) ); } -int -__glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 0); + 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); + GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetBooleanv(pname, params); + CALL_GetBooleanv( GET_DISPATCH(), ( + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0); error = Success; } @@ -1530,18 +1795,19 @@ __glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLdouble equation[4]; - - glGetClipPlane(*(GLenum *) (pc + 0), equation); + CALL_GetClipPlane( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + equation + ) ); __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0); error = Success; } @@ -1549,28 +1815,27 @@ __glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 0); + 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); + GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetDoublev(pname, params); + CALL_GetDoublev( GET_DISPATCH(), ( + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); error = Success; } @@ -1578,18 +1843,16 @@ __glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetError(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLenum retval; - - retval = glGetError(); + retval = CALL_GetError( GET_DISPATCH(), () ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -1597,28 +1860,27 @@ __glXDisp_GetError(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 0); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetFloatv(pname, params); + CALL_GetFloatv( GET_DISPATCH(), ( + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1626,28 +1888,27 @@ __glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 0); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetIntegerv(pname, params); + CALL_GetIntegerv( GET_DISPATCH(), ( + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1655,28 +1916,28 @@ __glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetLightfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetLightfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1684,28 +1945,28 @@ __glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetLightiv(*(GLenum *) (pc + 0), pname, params); + CALL_GetLightiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1713,29 +1974,29 @@ __glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &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); + if ( cx != NULL ) { + const GLenum target = *(GLenum *)(pc + 0); + const GLenum query = *(GLenum *)(pc + 4); - const GLuint compsize = __glGetMapdv_size(target, query); + const GLuint compsize = __glGetMapdv_size(target,query); GLdouble answerBuffer[200]; - GLdouble *v = - __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, - sizeof(answerBuffer), 8); + GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); - if (v == NULL) - return BadAlloc; + if (v == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMapdv(target, query, v); + CALL_GetMapdv( GET_DISPATCH(), ( + target, + query, + v + ) ); __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0); error = Success; } @@ -1743,29 +2004,29 @@ __glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &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); + if ( cx != NULL ) { + const GLenum target = *(GLenum *)(pc + 0); + const GLenum query = *(GLenum *)(pc + 4); - const GLuint compsize = __glGetMapfv_size(target, query); + const GLuint compsize = __glGetMapfv_size(target,query); GLfloat answerBuffer[200]; - GLfloat *v = - __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, - sizeof(answerBuffer), 4); + GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (v == NULL) - return BadAlloc; + if (v == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMapfv(target, query, v); + CALL_GetMapfv( GET_DISPATCH(), ( + target, + query, + v + ) ); __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1773,29 +2034,29 @@ __glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &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); + if ( cx != NULL ) { + const GLenum target = *(GLenum *)(pc + 0); + const GLenum query = *(GLenum *)(pc + 4); - const GLuint compsize = __glGetMapiv_size(target, query); + const GLuint compsize = __glGetMapiv_size(target,query); GLint answerBuffer[200]; - GLint *v = - __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, - sizeof(answerBuffer), 4); + GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (v == NULL) - return BadAlloc; + if (v == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMapiv(target, query, v); + CALL_GetMapiv( GET_DISPATCH(), ( + target, + query, + v + ) ); __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1803,28 +2064,28 @@ __glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMaterialfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMaterialfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1832,28 +2093,28 @@ __glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMaterialiv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMaterialiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1861,28 +2122,27 @@ __glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum map = *(GLenum *) (pc + 0); + 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); + GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (values == NULL) - return BadAlloc; + if (values == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetPixelMapfv(map, values); + CALL_GetPixelMapfv( GET_DISPATCH(), ( + map, + values + ) ); __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1890,28 +2150,27 @@ __glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum map = *(GLenum *) (pc + 0); + 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); + GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (values == NULL) - return BadAlloc; + if (values == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetPixelMapuiv(map, values); + CALL_GetPixelMapuiv( GET_DISPATCH(), ( + map, + values + ) ); __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1919,28 +2178,27 @@ __glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum map = *(GLenum *) (pc + 0); + 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); + GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2); - if (values == NULL) - return BadAlloc; + if (values == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetPixelMapusv(map, values); + CALL_GetPixelMapusv( GET_DISPATCH(), ( + map, + values + ) ); __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0); error = Success; } @@ -1948,28 +2206,28 @@ __glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexEnvfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexEnvfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -1977,28 +2235,28 @@ __glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexEnviv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexEnviv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2006,28 +2264,28 @@ __glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexGendv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexGendv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); error = Success; } @@ -2035,28 +2293,28 @@ __glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexGenfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexGenfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2064,28 +2322,28 @@ __glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexGeniv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexGeniv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2093,28 +2351,28 @@ __glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2122,28 +2380,28 @@ __glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetTexParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2151,29 +2409,29 @@ __glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 8); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexLevelParameterfv(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), pname, params); + CALL_GetTexLevelParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2181,29 +2439,29 @@ __glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 8); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetTexLevelParameteriv(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), pname, params); + CALL_GetTexLevelParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2211,18 +2469,18 @@ __glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = glIsEnabled(*(GLenum *) (pc + 0)); + retval = CALL_IsEnabled( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -2230,18 +2488,18 @@ __glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsList(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = glIsList(*(GLuint *) (pc + 0)); + retval = CALL_IsList( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -2249,223 +2507,251 @@ __glXDisp_IsList(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_DepthRange(GLbyte * pc) +void __glXDisp_DepthRange(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 16); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 16); pc -= 4; } #endif - glDepthRange(*(GLclampd *) (pc + 0), *(GLclampd *) (pc + 8)); + CALL_DepthRange( GET_DISPATCH(), ( + *(GLclampd *)(pc + 0), + *(GLclampd *)(pc + 8) + ) ); } -void -__glXDisp_Frustum(GLbyte * pc) +void __glXDisp_Frustum(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 48); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 48); pc -= 4; } #endif - glFrustum(*(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), - *(GLdouble *) (pc + 16), - *(GLdouble *) (pc + 24), - *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40)); + 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) +void __glXDisp_LoadIdentity(GLbyte * pc) { - glLoadIdentity(); + CALL_LoadIdentity( GET_DISPATCH(), () ); } -void -__glXDisp_LoadMatrixf(GLbyte * pc) +void __glXDisp_LoadMatrixf(GLbyte * pc) { - glLoadMatrixf((const GLfloat *) (pc + 0)); + CALL_LoadMatrixf( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_LoadMatrixd(GLbyte * pc) +void __glXDisp_LoadMatrixd(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 128); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 128); pc -= 4; } #endif - glLoadMatrixd((const GLdouble *) (pc + 0)); + CALL_LoadMatrixd( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_MatrixMode(GLbyte * pc) +void __glXDisp_MatrixMode(GLbyte * pc) { - glMatrixMode(*(GLenum *) (pc + 0)); + CALL_MatrixMode( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_MultMatrixf(GLbyte * pc) +void __glXDisp_MultMatrixf(GLbyte * pc) { - glMultMatrixf((const GLfloat *) (pc + 0)); + CALL_MultMatrixf( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_MultMatrixd(GLbyte * pc) +void __glXDisp_MultMatrixd(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 128); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 128); pc -= 4; } #endif - glMultMatrixd((const GLdouble *) (pc + 0)); + CALL_MultMatrixd( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_Ortho(GLbyte * pc) +void __glXDisp_Ortho(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 48); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 48); pc -= 4; } #endif - glOrtho(*(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), - *(GLdouble *) (pc + 16), - *(GLdouble *) (pc + 24), - *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40)); + 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) +void __glXDisp_PopMatrix(GLbyte * pc) { - glPopMatrix(); + CALL_PopMatrix( GET_DISPATCH(), () ); } -void -__glXDisp_PushMatrix(GLbyte * pc) +void __glXDisp_PushMatrix(GLbyte * pc) { - glPushMatrix(); + CALL_PushMatrix( GET_DISPATCH(), () ); } -void -__glXDisp_Rotated(GLbyte * pc) +void __glXDisp_Rotated(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 32); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 32); pc -= 4; } #endif - glRotated(*(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), - *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24)); + CALL_Rotated( GET_DISPATCH(), ( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16), + *(GLdouble *)(pc + 24) + ) ); } -void -__glXDisp_Rotatef(GLbyte * pc) +void __glXDisp_Rotatef(GLbyte * pc) { - glRotatef(*(GLfloat *) (pc + 0), - *(GLfloat *) (pc + 4), - *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12)); + CALL_Rotatef( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8), + *(GLfloat *)(pc + 12) + ) ); } -void -__glXDisp_Scaled(GLbyte * pc) +void __glXDisp_Scaled(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glScaled(*(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16)); + CALL_Scaled( GET_DISPATCH(), ( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16) + ) ); } -void -__glXDisp_Scalef(GLbyte * pc) +void __glXDisp_Scalef(GLbyte * pc) { - glScalef(*(GLfloat *) (pc + 0), - *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_Scalef( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_Translated(GLbyte * pc) +void __glXDisp_Translated(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - glTranslated(*(GLdouble *) (pc + 0), - *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16)); + CALL_Translated( GET_DISPATCH(), ( + *(GLdouble *)(pc + 0), + *(GLdouble *)(pc + 8), + *(GLdouble *)(pc + 16) + ) ); } -void -__glXDisp_Translatef(GLbyte * pc) +void __glXDisp_Translatef(GLbyte * pc) { - glTranslatef(*(GLfloat *) (pc + 0), - *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_Translatef( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_Viewport(GLbyte * pc) +void __glXDisp_Viewport(GLbyte * pc) { - glViewport(*(GLint *) (pc + 0), - *(GLint *) (pc + 4), - *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)); + CALL_Viewport( GET_DISPATCH(), ( + *(GLint *)(pc + 0), + *(GLint *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12) + ) ); } -void -__glXDisp_BindTexture(GLbyte * pc) +void __glXDisp_BindTexture(GLbyte * pc) { - glBindTexture(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)); + CALL_BindTexture( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ) ); } -void -__glXDisp_Indexubv(GLbyte * pc) +void __glXDisp_Indexubv(GLbyte * pc) { - glIndexubv((const GLubyte *) (pc + 0)); + CALL_Indexubv( GET_DISPATCH(), ( + (const GLubyte *)(pc + 0) + ) ); } -void -__glXDisp_PolygonOffset(GLbyte * pc) +void __glXDisp_PolygonOffset(GLbyte * pc) { - glPolygonOffset(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_PolygonOffset( GET_DISPATCH(), ( + *(GLfloat *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -int -__glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLboolean retval; GLboolean answerBuffer[200]; - GLboolean *residences = - __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1); - retval = - glAreTexturesResident(n, (const GLuint *) (pc + 4), residences); + 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; } @@ -2473,23 +2759,24 @@ __glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLboolean retval; GLboolean answerBuffer[200]; - GLboolean *residences = - __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1); - retval = - glAreTexturesResident(n, (const GLuint *) (pc + 4), residences); + 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; } @@ -2497,103 +2784,115 @@ __glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_CopyTexImage1D(GLbyte * pc) +void __glXDisp_CopyTexImage1D(GLbyte * pc) { - glCopyTexImage1D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLenum *) (pc + 8), - *(GLint *) (pc + 12), - *(GLint *) (pc + 16), - *(GLsizei *) (pc + 20), *(GLint *) (pc + 24)); + 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) +void __glXDisp_CopyTexImage2D(GLbyte * pc) { - glCopyTexImage2D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLenum *) (pc + 8), - *(GLint *) (pc + 12), - *(GLint *) (pc + 16), - *(GLsizei *) (pc + 20), - *(GLsizei *) (pc + 24), *(GLint *) (pc + 28)); + 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) +void __glXDisp_CopyTexSubImage1D(GLbyte * pc) { - glCopyTexSubImage1D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), - *(GLint *) (pc + 16), *(GLsizei *) (pc + 20)); + 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) +void __glXDisp_CopyTexSubImage2D(GLbyte * pc) { - glCopyTexSubImage2D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), - *(GLint *) (pc + 16), - *(GLint *) (pc + 20), - *(GLsizei *) (pc + 24), *(GLsizei *) (pc + 28)); + 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) +int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); - glDeleteTextures(n, (const GLuint *) (pc + 4)); + CALL_DeleteTextures( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); - glDeleteTextures(n, (const GLuint *) (pc + 4)); + CALL_DeleteTextures( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *textures = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - glGenTextures(n, textures); + 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; } @@ -2601,22 +2900,22 @@ __glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *textures = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - glGenTextures(n, textures); + 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; } @@ -2624,18 +2923,18 @@ __glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = glIsTexture(*(GLuint *) (pc + 0)); + retval = CALL_IsTexture( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -2643,18 +2942,18 @@ __glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = glIsTexture(*(GLuint *) (pc + 0)); + retval = CALL_IsTexture( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -2662,144 +2961,165 @@ __glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_PrioritizeTextures(GLbyte * pc) +void __glXDisp_PrioritizeTextures(GLbyte * pc) { - const GLsizei n = *(GLsizei *) (pc + 0); + const GLsizei n = *(GLsizei *)(pc + 0); - glPrioritizeTextures(n, - (const GLuint *) (pc + 4), - (const GLclampf *) (pc + 4)); + CALL_PrioritizeTextures( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4), + (const GLclampf *)(pc + 4) + ) ); } -void -__glXDisp_TexSubImage1D(GLbyte * pc) +void __glXDisp_TexSubImage1D(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 56)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 56); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexSubImage1D(*(GLenum *) (pc + 20), - *(GLint *) (pc + 24), - *(GLint *) (pc + 28), - *(GLsizei *) (pc + 36), - *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels); + 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) +void __glXDisp_TexSubImage2D(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 56)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 56); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexSubImage2D(*(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); + 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) +void __glXDisp_BlendColor(GLbyte * pc) { - glBlendColor(*(GLclampf *) (pc + 0), - *(GLclampf *) (pc + 4), - *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12)); + CALL_BlendColor( GET_DISPATCH(), ( + *(GLclampf *)(pc + 0), + *(GLclampf *)(pc + 4), + *(GLclampf *)(pc + 8), + *(GLclampf *)(pc + 12) + ) ); } -void -__glXDisp_BlendEquation(GLbyte * pc) +void __glXDisp_BlendEquation(GLbyte * pc) { - glBlendEquation(*(GLenum *) (pc + 0)); + CALL_BlendEquation( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_ColorTable(GLbyte * pc) +void __glXDisp_ColorTable(GLbyte * pc) { - const GLvoid *const table = (const GLvoid *) ((pc + 40)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const table = (const GLvoid *) (pc + 40); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glColorTable(*(GLenum *) (pc + 20), - *(GLenum *) (pc + 24), - *(GLsizei *) (pc + 28), - *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), table); + 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) +void __glXDisp_ColorTableParameterfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glColorTableParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_ColorTableParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_ColorTableParameteriv(GLbyte * pc) +void __glXDisp_ColorTableParameteriv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glColorTableParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_ColorTableParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_CopyColorTable(GLbyte * pc) +void __glXDisp_CopyColorTable(GLbyte * pc) { - glCopyColorTable(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), *(GLsizei *) (pc + 16)); + 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) +int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetColorTableParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2807,28 +3127,28 @@ __glXDisp_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetColorTableParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2836,28 +3156,28 @@ __glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetColorTableParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2865,28 +3185,28 @@ __glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetColorTableParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -2894,150 +3214,175 @@ __glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_ColorSubTable(GLbyte * pc) +void __glXDisp_ColorSubTable(GLbyte * pc) { - const GLvoid *const data = (const GLvoid *) ((pc + 40)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const data = (const GLvoid *) (pc + 40); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glColorSubTable(*(GLenum *) (pc + 20), - *(GLsizei *) (pc + 24), - *(GLsizei *) (pc + 28), - *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), data); + 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) +void __glXDisp_CopyColorSubTable(GLbyte * pc) { - glCopyColorSubTable(*(GLenum *) (pc + 0), - *(GLsizei *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), *(GLsizei *) (pc + 16)); + CALL_CopyColorSubTable( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLsizei *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16) + ) ); } -void -__glXDisp_ConvolutionFilter1D(GLbyte * pc) +void __glXDisp_ConvolutionFilter1D(GLbyte * pc) { - const GLvoid *const image = (const GLvoid *) ((pc + 44)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const image = (const GLvoid *) (pc + 44); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glConvolutionFilter1D(*(GLenum *) (pc + 20), - *(GLenum *) (pc + 24), - *(GLsizei *) (pc + 28), - *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image); + 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) +void __glXDisp_ConvolutionFilter2D(GLbyte * pc) { - const GLvoid *const image = (const GLvoid *) ((pc + 44)); - __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc); + const GLvoid * const image = (const GLvoid *) (pc + 44); + __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glConvolutionFilter2D(*(GLenum *) (pc + 20), - *(GLenum *) (pc + 24), - *(GLsizei *) (pc + 28), - *(GLsizei *) (pc + 32), - *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image); + 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) +void __glXDisp_ConvolutionParameterf(GLbyte * pc) { - glConvolutionParameterf(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)); + CALL_ConvolutionParameterf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_ConvolutionParameterfv(GLbyte * pc) +void __glXDisp_ConvolutionParameterfv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLfloat * params; params = (const GLfloat *) (pc + 8); - glConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_ConvolutionParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_ConvolutionParameteri(GLbyte * pc) +void __glXDisp_ConvolutionParameteri(GLbyte * pc) { - glConvolutionParameteri(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLint *) (pc + 8)); + CALL_ConvolutionParameteri( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8) + ) ); } -void -__glXDisp_ConvolutionParameteriv(GLbyte * pc) +void __glXDisp_ConvolutionParameteriv(GLbyte * pc) { - const GLenum pname = *(GLenum *) (pc + 4); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 4); + const GLint * params; params = (const GLint *) (pc + 8); - glConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_ConvolutionParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); } -void -__glXDisp_CopyConvolutionFilter1D(GLbyte * pc) +void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc) { - glCopyConvolutionFilter1D(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), *(GLsizei *) (pc + 16)); + CALL_CopyConvolutionFilter1D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLsizei *)(pc + 16) + ) ); } -void -__glXDisp_CopyConvolutionFilter2D(GLbyte * pc) +void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc) { - glCopyConvolutionFilter2D(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), - *(GLint *) (pc + 8), - *(GLint *) (pc + 12), - *(GLsizei *) (pc + 16), *(GLsizei *) (pc + 20)); + 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) +int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetConvolutionParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3045,28 +3390,28 @@ __glXDisp_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetConvolutionParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3074,28 +3419,28 @@ __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetConvolutionParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3103,28 +3448,28 @@ __glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetConvolutionParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3132,28 +3477,28 @@ __glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetHistogramParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3161,28 +3506,28 @@ __glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetHistogramParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3190,28 +3535,28 @@ __glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetHistogramParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3219,28 +3564,28 @@ __glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetHistogramParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3248,28 +3593,28 @@ __glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMinmaxParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3277,28 +3622,28 @@ __glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMinmaxParameterfv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3306,28 +3651,28 @@ __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc) { - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMinmaxParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3335,28 +3680,28 @@ __glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc) { - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params); + CALL_GetMinmaxParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3364,526 +3709,562 @@ __glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_Histogram(GLbyte * pc) -{ - glHistogram(*(GLenum *) (pc + 0), - *(GLsizei *) (pc + 4), - *(GLenum *) (pc + 8), *(GLboolean *) (pc + 12)); +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) +void __glXDisp_Minmax(GLbyte * pc) { - glMinmax(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), *(GLboolean *) (pc + 8)); + CALL_Minmax( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLboolean *)(pc + 8) + ) ); } -void -__glXDisp_ResetHistogram(GLbyte * pc) +void __glXDisp_ResetHistogram(GLbyte * pc) { - glResetHistogram(*(GLenum *) (pc + 0)); + CALL_ResetHistogram( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_ResetMinmax(GLbyte * pc) +void __glXDisp_ResetMinmax(GLbyte * pc) { - glResetMinmax(*(GLenum *) (pc + 0)); + CALL_ResetMinmax( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_TexImage3D(GLbyte * pc) +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); + 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); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexImage3D(*(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); + 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) +void __glXDisp_TexSubImage3D(GLbyte * pc) { - const GLvoid *const pixels = (const GLvoid *) ((pc + 88)); - __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc); + const GLvoid * const pixels = (const GLvoid *) (pc + 88); + __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc); - glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes); - glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst); - glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength); - glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight); - glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows); - glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels); - glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment); + 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) ); - glTexSubImage3D(*(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); + 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) +void __glXDisp_CopyTexSubImage3D(GLbyte * pc) { - glCopyTexSubImage3D(*(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)); + 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_ActiveTexture(GLbyte * pc) +void __glXDisp_ActiveTexture(GLbyte * pc) { - glActiveTextureARB(*(GLenum *) (pc + 0)); + CALL_ActiveTexture( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -void -__glXDisp_MultiTexCoord1dv(GLbyte * pc) +void __glXDisp_MultiTexCoord1dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 12); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 12); pc -= 4; } #endif - glMultiTexCoord1dvARB(*(GLenum *) (pc + 8), (const GLdouble *) (pc + 0)); + CALL_MultiTexCoord1dv( GET_DISPATCH(), ( + *(GLenum *)(pc + 8), + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_MultiTexCoord1fvARB(GLbyte * pc) +void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc) { - glMultiTexCoord1fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_MultiTexCoord1fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord1iv(GLbyte * pc) +void __glXDisp_MultiTexCoord1iv(GLbyte * pc) { - glMultiTexCoord1ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4)); + CALL_MultiTexCoord1iv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord1sv(GLbyte * pc) +void __glXDisp_MultiTexCoord1sv(GLbyte * pc) { - glMultiTexCoord1svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_MultiTexCoord1sv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord2dv(GLbyte * pc) +void __glXDisp_MultiTexCoord2dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 20); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 20); pc -= 4; } #endif - glMultiTexCoord2dvARB(*(GLenum *) (pc + 16), (const GLdouble *) (pc + 0)); + CALL_MultiTexCoord2dv( GET_DISPATCH(), ( + *(GLenum *)(pc + 16), + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_MultiTexCoord2fvARB(GLbyte * pc) +void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc) { - glMultiTexCoord2fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_MultiTexCoord2fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord2iv(GLbyte * pc) +void __glXDisp_MultiTexCoord2iv(GLbyte * pc) { - glMultiTexCoord2ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4)); + CALL_MultiTexCoord2iv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord2sv(GLbyte * pc) +void __glXDisp_MultiTexCoord2sv(GLbyte * pc) { - glMultiTexCoord2svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_MultiTexCoord2sv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord3dv(GLbyte * pc) +void __glXDisp_MultiTexCoord3dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 28); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 28); pc -= 4; } #endif - glMultiTexCoord3dvARB(*(GLenum *) (pc + 24), (const GLdouble *) (pc + 0)); + CALL_MultiTexCoord3dv( GET_DISPATCH(), ( + *(GLenum *)(pc + 24), + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_MultiTexCoord3fvARB(GLbyte * pc) +void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc) { - glMultiTexCoord3fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_MultiTexCoord3fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord3iv(GLbyte * pc) +void __glXDisp_MultiTexCoord3iv(GLbyte * pc) { - glMultiTexCoord3ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4)); + CALL_MultiTexCoord3iv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord3sv(GLbyte * pc) +void __glXDisp_MultiTexCoord3sv(GLbyte * pc) { - glMultiTexCoord3svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_MultiTexCoord3sv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord4dv(GLbyte * pc) +void __glXDisp_MultiTexCoord4dv(GLbyte * pc) { #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 36); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 36); pc -= 4; } #endif - glMultiTexCoord4dvARB(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0)); + CALL_MultiTexCoord4dv( GET_DISPATCH(), ( + *(GLenum *)(pc + 32), + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_MultiTexCoord4fvARB(GLbyte * pc) +void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc) { - glMultiTexCoord4fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_MultiTexCoord4fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord4iv(GLbyte * pc) +void __glXDisp_MultiTexCoord4iv(GLbyte * pc) { - glMultiTexCoord4ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4)); + CALL_MultiTexCoord4iv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_MultiTexCoord4sv(GLbyte * pc) +void __glXDisp_MultiTexCoord4sv(GLbyte * pc) { - glMultiTexCoord4svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_MultiTexCoord4sv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_CompressedTexImage1D(GLbyte * pc) +void __glXDisp_CompressedTexImage1D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D = - __glGetProcAddress("glCompressedTexImage1D"); - const GLsizei imageSize = *(GLsizei *) (pc + 20); + const GLsizei imageSize = *(GLsizei *)(pc + 20); - CompressedTexImage1D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLenum *) (pc + 8), - *(GLsizei *) (pc + 12), - *(GLint *) (pc + 16), - imageSize, (const GLvoid *) (pc + 24)); + CALL_CompressedTexImage1D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLsizei *)(pc + 12), + *(GLint *)(pc + 16), + imageSize, + (const GLvoid *)(pc + 24) + ) ); } -void -__glXDisp_CompressedTexImage2D(GLbyte * pc) +void __glXDisp_CompressedTexImage2D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D = - __glGetProcAddress("glCompressedTexImage2D"); - const GLsizei imageSize = *(GLsizei *) (pc + 24); + const GLsizei imageSize = *(GLsizei *)(pc + 24); - CompressedTexImage2D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLenum *) (pc + 8), - *(GLsizei *) (pc + 12), - *(GLsizei *) (pc + 16), - *(GLint *) (pc + 20), - imageSize, (const GLvoid *) (pc + 28)); + CALL_CompressedTexImage2D( 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_CompressedTexImage3D(GLbyte * pc) +void __glXDisp_CompressedTexImage3D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D = - __glGetProcAddress("glCompressedTexImage3D"); - const GLsizei imageSize = *(GLsizei *) (pc + 28); + const GLsizei imageSize = *(GLsizei *)(pc + 28); - CompressedTexImage3D(*(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)); + CALL_CompressedTexImage3D( 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_CompressedTexSubImage1D(GLbyte * pc) +void __glXDisp_CompressedTexSubImage1D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D = - __glGetProcAddress("glCompressedTexSubImage1D"); - const GLsizei imageSize = *(GLsizei *) (pc + 20); + const GLsizei imageSize = *(GLsizei *)(pc + 20); - CompressedTexSubImage1D(*(GLenum *) (pc + 0), - *(GLint *) (pc + 4), - *(GLint *) (pc + 8), - *(GLsizei *) (pc + 12), - *(GLenum *) (pc + 16), - imageSize, (const GLvoid *) (pc + 24)); + CALL_CompressedTexSubImage1D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4), + *(GLint *)(pc + 8), + *(GLsizei *)(pc + 12), + *(GLenum *)(pc + 16), + imageSize, + (const GLvoid *)(pc + 24) + ) ); } -void -__glXDisp_CompressedTexSubImage2D(GLbyte * pc) +void __glXDisp_CompressedTexSubImage2D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D = - __glGetProcAddress("glCompressedTexSubImage2D"); - const GLsizei imageSize = *(GLsizei *) (pc + 28); + const GLsizei imageSize = *(GLsizei *)(pc + 28); - CompressedTexSubImage2D(*(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)); + CALL_CompressedTexSubImage2D( 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_CompressedTexSubImage3D(GLbyte * pc) +void __glXDisp_CompressedTexSubImage3D(GLbyte * pc) { - PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D = - __glGetProcAddress("glCompressedTexSubImage3D"); - const GLsizei imageSize = *(GLsizei *) (pc + 36); + const GLsizei imageSize = *(GLsizei *)(pc + 36); - CompressedTexSubImage3D(*(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)); + CALL_CompressedTexSubImage3D( 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) + ) ); } -void -__glXDisp_SampleCoverage(GLbyte * pc) +void __glXDisp_SampleCoverage(GLbyte * pc) { - PFNGLSAMPLECOVERAGEPROC SampleCoverage = - __glGetProcAddress("glSampleCoverage"); - SampleCoverage(*(GLclampf *) (pc + 0), *(GLboolean *) (pc + 4)); + CALL_SampleCoverage( GET_DISPATCH(), ( + *(GLclampf *)(pc + 0), + *(GLboolean *)(pc + 4) + ) ); } -void -__glXDisp_BlendFuncSeparate(GLbyte * pc) +void __glXDisp_BlendFuncSeparate(GLbyte * pc) { - PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate = - __glGetProcAddress("glBlendFuncSeparate"); - BlendFuncSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), *(GLenum *) (pc + 12)); + CALL_BlendFuncSeparate( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLenum *)(pc + 12) + ) ); } -void -__glXDisp_FogCoorddv(GLbyte * pc) +void __glXDisp_FogCoorddv(GLbyte * pc) { - PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv"); - #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 8); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 8); pc -= 4; } #endif - FogCoorddv((const GLdouble *) (pc + 0)); + CALL_FogCoorddv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_PointParameterf(GLbyte * pc) +void __glXDisp_PointParameterf(GLbyte * pc) { - PFNGLPOINTPARAMETERFPROC PointParameterf = - __glGetProcAddress("glPointParameterf"); - PointParameterf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)); + CALL_PointParameterf( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_PointParameterfv(GLbyte * pc) +void __glXDisp_PointParameterfv(GLbyte * pc) { - PFNGLPOINTPARAMETERFVPROC PointParameterfv = - __glGetProcAddress("glPointParameterfv"); - const GLenum pname = *(GLenum *) (pc + 0); - const GLfloat *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLfloat * params; params = (const GLfloat *) (pc + 4); - PointParameterfv(pname, params); + CALL_PointParameterfv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_PointParameteri(GLbyte * pc) +void __glXDisp_PointParameteri(GLbyte * pc) { - PFNGLPOINTPARAMETERIPROC PointParameteri = - __glGetProcAddress("glPointParameteri"); - PointParameteri(*(GLenum *) (pc + 0), *(GLint *) (pc + 4)); + CALL_PointParameteri( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLint *)(pc + 4) + ) ); } -void -__glXDisp_PointParameteriv(GLbyte * pc) +void __glXDisp_PointParameteriv(GLbyte * pc) { - PFNGLPOINTPARAMETERIVPROC PointParameteriv = - __glGetProcAddress("glPointParameteriv"); - const GLenum pname = *(GLenum *) (pc + 0); - const GLint *params; + const GLenum pname = *(GLenum *)(pc + 0); + const GLint * params; params = (const GLint *) (pc + 4); - PointParameteriv(pname, params); + CALL_PointParameteriv( GET_DISPATCH(), ( + pname, + params + ) ); } -void -__glXDisp_SecondaryColor3bv(GLbyte * pc) +void __glXDisp_SecondaryColor3bv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv = - __glGetProcAddress("glSecondaryColor3bv"); - SecondaryColor3bv((const GLbyte *) (pc + 0)); + CALL_SecondaryColor3bv( GET_DISPATCH(), ( + (const GLbyte *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3dv(GLbyte * pc) +void __glXDisp_SecondaryColor3dv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv = - __glGetProcAddress("glSecondaryColor3dv"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 24); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 24); pc -= 4; } #endif - SecondaryColor3dv((const GLdouble *) (pc + 0)); + CALL_SecondaryColor3dv( GET_DISPATCH(), ( + (const GLdouble *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3iv(GLbyte * pc) +void __glXDisp_SecondaryColor3iv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv = - __glGetProcAddress("glSecondaryColor3iv"); - SecondaryColor3iv((const GLint *) (pc + 0)); + CALL_SecondaryColor3iv( GET_DISPATCH(), ( + (const GLint *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3sv(GLbyte * pc) +void __glXDisp_SecondaryColor3sv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv = - __glGetProcAddress("glSecondaryColor3sv"); - SecondaryColor3sv((const GLshort *) (pc + 0)); + CALL_SecondaryColor3sv( GET_DISPATCH(), ( + (const GLshort *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3ubv(GLbyte * pc) +void __glXDisp_SecondaryColor3ubv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv = - __glGetProcAddress("glSecondaryColor3ubv"); - SecondaryColor3ubv((const GLubyte *) (pc + 0)); + CALL_SecondaryColor3ubv( GET_DISPATCH(), ( + (const GLubyte *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3uiv(GLbyte * pc) +void __glXDisp_SecondaryColor3uiv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv = - __glGetProcAddress("glSecondaryColor3uiv"); - SecondaryColor3uiv((const GLuint *) (pc + 0)); + CALL_SecondaryColor3uiv( GET_DISPATCH(), ( + (const GLuint *)(pc + 0) + ) ); } -void -__glXDisp_SecondaryColor3usv(GLbyte * pc) +void __glXDisp_SecondaryColor3usv(GLbyte * pc) { - PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv = - __glGetProcAddress("glSecondaryColor3usv"); - SecondaryColor3usv((const GLushort *) (pc + 0)); + CALL_SecondaryColor3usv( GET_DISPATCH(), ( + (const GLushort *)(pc + 0) + ) ); } -void -__glXDisp_WindowPos3fv(GLbyte * pc) +void __glXDisp_WindowPos3fv(GLbyte * pc) { - PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv"); - - WindowPos3fv((const GLfloat *) (pc + 0)); + CALL_WindowPos3fv( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); } -void -__glXDisp_BeginQuery(GLbyte * pc) +void __glXDisp_BeginQuery(GLbyte * pc) { - PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery"); - - BeginQuery(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)); + CALL_BeginQuery( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ) ); } -int -__glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_DeleteQueries(__GLXclientState *cl, GLbyte *pc) { - PFNGLDELETEQUERIESPROC DeleteQueries = - __glGetProcAddress("glDeleteQueries"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); - DeleteQueries(n, (const GLuint *) (pc + 4)); + CALL_DeleteQueries( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); error = Success; } return error; } -void -__glXDisp_EndQuery(GLbyte * pc) +void __glXDisp_EndQuery(GLbyte * pc) { - PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery"); - - EndQuery(*(GLenum *) (pc + 0)); + CALL_EndQuery( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -int -__glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenQueries(__GLXclientState *cl, GLbyte *pc) { - PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *ids = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - GenQueries(n, ids); + GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); + CALL_GenQueries( GET_DISPATCH(), ( + n, + ids + ) ); __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0); error = Success; } @@ -3891,30 +4272,28 @@ __glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetQueryObjectiv(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv = - __glGetProcAddress("glGetQueryObjectiv"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + if ( cx != NULL ) { + const GLenum pname = *(GLenum *)(pc + 4); const GLuint compsize = __glGetQueryObjectiv_size(pname); GLint answerBuffer[200]; - GLint *params = - __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, - sizeof(answerBuffer), 4); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - GetQueryObjectiv(*(GLuint *) (pc + 0), pname, params); + CALL_GetQueryObjectiv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3922,30 +4301,28 @@ __glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetQueryObjectuiv(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv = - __glGetProcAddress("glGetQueryObjectuiv"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + if ( cx != NULL ) { + const GLenum pname = *(GLenum *)(pc + 4); const GLuint compsize = __glGetQueryObjectuiv_size(pname); GLuint answerBuffer[200]; - GLuint *params = - __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, - sizeof(answerBuffer), 4); + GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - GetQueryObjectuiv(*(GLuint *) (pc + 0), pname, params); + CALL_GetQueryObjectuiv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3953,29 +4330,28 @@ __glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetQueryiv(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + if ( cx != NULL ) { + const GLenum pname = *(GLenum *)(pc + 4); const GLuint compsize = __glGetQueryiv_size(pname); GLint answerBuffer[200]; - GLint *params = - __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, - sizeof(answerBuffer), 4); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - GetQueryiv(*(GLenum *) (pc + 0), pname, params); + CALL_GetQueryiv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -3983,19 +4359,18 @@ __glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsQuery(__GLXclientState *cl, GLbyte *pc) { - PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery"); - xGLXSingleReq *const req = (xGLXSingleReq *) pc; + xGLXSingleReq * const req = (xGLXSingleReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_SINGLE_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = IsQuery(*(GLuint *) (pc + 0)); + retval = CALL_IsQuery( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -4003,257 +4378,343 @@ __glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_BlendEquationSeparate(GLbyte * pc) +void __glXDisp_BlendEquationSeparate(GLbyte * pc) +{ + CALL_BlendEquationSeparate( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); +} + +void __glXDisp_DrawBuffers(GLbyte * pc) +{ + const GLsizei n = *(GLsizei *)(pc + 0); + + CALL_DrawBuffers( GET_DISPATCH(), ( + n, + (const GLenum *)(pc + 4) + ) ); +} + +int __glXDisp_GetVertexAttribdv(__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 = __glGetVertexAttribdv_size(pname); + GLdouble answerBuffer[200]; + GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); + + if (params == NULL) return BadAlloc; + __glXClearErrorOccured(); + + CALL_GetVertexAttribdv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + pname, + params + ) ); + __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); + error = Success; + } + + return error; +} + +int __glXDisp_GetVertexAttribfv(__GLXclientState *cl, GLbyte *pc) { - PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate = - __glGetProcAddress("glBlendEquationSeparate"); - BlendEquationSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + 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 = __glGetVertexAttribfv_size(pname); + GLfloat answerBuffer[200]; + GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); + + if (params == NULL) return BadAlloc; + __glXClearErrorOccured(); + + CALL_GetVertexAttribfv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + pname, + params + ) ); + __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); + error = Success; + } + + return error; } -void -__glXDisp_DrawBuffers(GLbyte * pc) +int __glXDisp_GetVertexAttribiv(__GLXclientState *cl, GLbyte *pc) { - PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers"); - const GLsizei n = *(GLsizei *) (pc + 0); + 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 = __glGetVertexAttribiv_size(pname); + GLint answerBuffer[200]; + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - DrawBuffers(n, (const GLenum *) (pc + 4)); + if (params == NULL) return BadAlloc; + __glXClearErrorOccured(); + + CALL_GetVertexAttribiv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + pname, + params + ) ); + __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); + error = Success; + } + + return error; } -void -__glXDisp_VertexAttrib1dv(GLbyte * pc) +void __glXDisp_VertexAttrib1dv(GLbyte * pc) { - PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv = - __glGetProcAddress("glVertexAttrib1dv"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 12); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 12); pc -= 4; } #endif - VertexAttrib1dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib1dv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib1sv(GLbyte * pc) +void __glXDisp_VertexAttrib1sv(GLbyte * pc) { - PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv = - __glGetProcAddress("glVertexAttrib1sv"); - VertexAttrib1sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib1sv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2dv(GLbyte * pc) +void __glXDisp_VertexAttrib2dv(GLbyte * pc) { - PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv = - __glGetProcAddress("glVertexAttrib2dv"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 20); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 20); pc -= 4; } #endif - VertexAttrib2dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib2dv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2sv(GLbyte * pc) +void __glXDisp_VertexAttrib2sv(GLbyte * pc) { - PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv = - __glGetProcAddress("glVertexAttrib2sv"); - VertexAttrib2sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib2sv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3dv(GLbyte * pc) +void __glXDisp_VertexAttrib3dv(GLbyte * pc) { - PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv = - __glGetProcAddress("glVertexAttrib3dv"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 28); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 28); pc -= 4; } #endif - VertexAttrib3dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib3dv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3sv(GLbyte * pc) +void __glXDisp_VertexAttrib3sv(GLbyte * pc) { - PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv = - __glGetProcAddress("glVertexAttrib3sv"); - VertexAttrib3sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib3sv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Nbv(GLbyte * pc) +void __glXDisp_VertexAttrib4Nbv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv = - __glGetProcAddress("glVertexAttrib4Nbv"); - VertexAttrib4Nbv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4)); + CALL_VertexAttrib4Nbv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLbyte *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Niv(GLbyte * pc) +void __glXDisp_VertexAttrib4Niv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv = - __glGetProcAddress("glVertexAttrib4Niv"); - VertexAttrib4Niv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4)); + CALL_VertexAttrib4Niv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Nsv(GLbyte * pc) +void __glXDisp_VertexAttrib4Nsv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv = - __glGetProcAddress("glVertexAttrib4Nsv"); - VertexAttrib4Nsv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib4Nsv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Nubv(GLbyte * pc) +void __glXDisp_VertexAttrib4Nubv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv = - __glGetProcAddress("glVertexAttrib4Nubv"); - VertexAttrib4Nubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4)); + CALL_VertexAttrib4Nubv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLubyte *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Nuiv(GLbyte * pc) +void __glXDisp_VertexAttrib4Nuiv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv = - __glGetProcAddress("glVertexAttrib4Nuiv"); - VertexAttrib4Nuiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4)); + CALL_VertexAttrib4Nuiv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLuint *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4Nusv(GLbyte * pc) +void __glXDisp_VertexAttrib4Nusv(GLbyte * pc) { - PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv = - __glGetProcAddress("glVertexAttrib4Nusv"); - VertexAttrib4Nusv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4)); + CALL_VertexAttrib4Nusv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLushort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4bv(GLbyte * pc) +void __glXDisp_VertexAttrib4bv(GLbyte * pc) { - PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv = - __glGetProcAddress("glVertexAttrib4bv"); - VertexAttrib4bv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4)); + CALL_VertexAttrib4bv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLbyte *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4dv(GLbyte * pc) +void __glXDisp_VertexAttrib4dv(GLbyte * pc) { - PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv = - __glGetProcAddress("glVertexAttrib4dv"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 36); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 36); pc -= 4; } #endif - VertexAttrib4dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib4dv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4iv(GLbyte * pc) +void __glXDisp_VertexAttrib4iv(GLbyte * pc) { - PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv = - __glGetProcAddress("glVertexAttrib4iv"); - VertexAttrib4iv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4)); + CALL_VertexAttrib4iv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLint *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4sv(GLbyte * pc) +void __glXDisp_VertexAttrib4sv(GLbyte * pc) { - PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv = - __glGetProcAddress("glVertexAttrib4sv"); - VertexAttrib4sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib4sv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4ubv(GLbyte * pc) +void __glXDisp_VertexAttrib4ubv(GLbyte * pc) { - PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv = - __glGetProcAddress("glVertexAttrib4ubv"); - VertexAttrib4ubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4)); + CALL_VertexAttrib4ubv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLubyte *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4uiv(GLbyte * pc) +void __glXDisp_VertexAttrib4uiv(GLbyte * pc) { - PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv = - __glGetProcAddress("glVertexAttrib4uiv"); - VertexAttrib4uiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4)); + CALL_VertexAttrib4uiv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLuint *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4usv(GLbyte * pc) +void __glXDisp_VertexAttrib4usv(GLbyte * pc) { - PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv = - __glGetProcAddress("glVertexAttrib4usv"); - VertexAttrib4usv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4)); + CALL_VertexAttrib4usv( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLushort *)(pc + 4) + ) ); } -void -__glXDisp_ClampColor(GLbyte * pc) +void __glXDisp_ClampColor(GLbyte * pc) { - PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor"); - - ClampColor(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)); + CALL_ClampColor( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4) + ) ); } -void -__glXDisp_BindProgramARB(GLbyte * pc) +void __glXDisp_BindProgramARB(GLbyte * pc) { - PFNGLBINDPROGRAMARBPROC BindProgramARB = - __glGetProcAddress("glBindProgramARB"); - BindProgramARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)); + CALL_BindProgramARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ) ); } -int -__glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_DeleteProgramsARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB = - __glGetProcAddress("glDeleteProgramsARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); - DeleteProgramsARB(n, (const GLuint *) (pc + 4)); + CALL_DeleteProgramsARB( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); error = Success; } return error; } -int -__glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenProgramsARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGENPROGRAMSARBPROC GenProgramsARB = - __glGetProcAddress("glGenProgramsARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *programs = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - GenProgramsARB(n, programs); + GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); + CALL_GenProgramsARB( GET_DISPATCH(), ( + n, + programs + ) ); __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0); error = Success; } @@ -4261,21 +4722,20 @@ __glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB = - __glGetProcAddress("glGetProgramEnvParameterdvARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLdouble params[4]; - - GetProgramEnvParameterdvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), params); + CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + params + ) ); __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0); error = Success; } @@ -4283,21 +4743,20 @@ __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB = - __glGetProcAddress("glGetProgramEnvParameterfvARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLfloat params[4]; - - GetProgramEnvParameterfvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), params); + CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + params + ) ); __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0); error = Success; } @@ -4305,21 +4764,20 @@ __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB = - __glGetProcAddress("glGetProgramLocalParameterdvARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLdouble params[4]; - - GetProgramLocalParameterdvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), params); + CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + params + ) ); __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0); error = Success; } @@ -4327,21 +4785,20 @@ __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB = - __glGetProcAddress("glGetProgramLocalParameterfvARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLfloat params[4]; - - GetProgramLocalParameterfvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), params); + CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + params + ) ); __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0); error = Success; } @@ -4349,30 +4806,28 @@ __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETPROGRAMIVARBPROC GetProgramivARB = - __glGetProcAddress("glGetProgramivARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLenum pname = *(GLenum *) (pc + 4); + 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); + GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); - if (params == NULL) - return BadAlloc; + if (params == NULL) return BadAlloc; __glXClearErrorOccured(); - GetProgramivARB(*(GLenum *) (pc + 0), pname, params); + CALL_GetProgramivARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + pname, + params + ) ); __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); error = Success; } @@ -4380,19 +4835,18 @@ __glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsProgramARB(__GLXclientState *cl, GLbyte *pc) { - PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; - - retval = IsProgramARB(*(GLuint *) (pc + 0)); + retval = CALL_IsProgramARB( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -4400,143 +4854,144 @@ __glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc) +void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc) { - PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB = - __glGetProcAddress("glProgramEnvParameter4dvARB"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 40); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 40); pc -= 4; } #endif - ProgramEnvParameter4dvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), - (const GLdouble *) (pc + 8)); + CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc) +void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc) { - PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB = - __glGetProcAddress("glProgramEnvParameter4fvARB"); - ProgramEnvParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4), - (const GLfloat *) (pc + 8)); + CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc) +void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc) { - PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB = - __glGetProcAddress("glProgramLocalParameter4dvARB"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 40); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 40); pc -= 4; } #endif - ProgramLocalParameter4dvARB(*(GLenum *) (pc + 0), - *(GLuint *) (pc + 4), - (const GLdouble *) (pc + 8)); + CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc) +void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc) { - PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB = - __glGetProcAddress("glProgramLocalParameter4fvARB"); - ProgramLocalParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4), - (const GLfloat *) (pc + 8)); + CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_ProgramStringARB(GLbyte * pc) +void __glXDisp_ProgramStringARB(GLbyte * pc) { - PFNGLPROGRAMSTRINGARBPROC ProgramStringARB = - __glGetProcAddress("glProgramStringARB"); - const GLsizei len = *(GLsizei *) (pc + 8); + const GLsizei len = *(GLsizei *)(pc + 8); - ProgramStringARB(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), len, (const GLvoid *) (pc + 12)); + CALL_ProgramStringARB( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + len, + (const GLvoid *)(pc + 12) + ) ); } -void -__glXDisp_VertexAttrib1fvARB(GLbyte * pc) +void __glXDisp_VertexAttrib1fvARB(GLbyte * pc) { - PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB = - __glGetProcAddress("glVertexAttrib1fvARB"); - VertexAttrib1fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib1fvARB( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2fvARB(GLbyte * pc) +void __glXDisp_VertexAttrib2fvARB(GLbyte * pc) { - PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB = - __glGetProcAddress("glVertexAttrib2fvARB"); - VertexAttrib2fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib2fvARB( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3fvARB(GLbyte * pc) +void __glXDisp_VertexAttrib3fvARB(GLbyte * pc) { - PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB = - __glGetProcAddress("glVertexAttrib3fvARB"); - VertexAttrib3fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib3fvARB( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4fvARB(GLbyte * pc) +void __glXDisp_VertexAttrib4fvARB(GLbyte * pc) { - PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB = - __glGetProcAddress("glVertexAttrib4fvARB"); - VertexAttrib4fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib4fvARB( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_BindFramebuffer(GLbyte * pc) +void __glXDisp_BindFramebuffer(GLbyte * pc) { - PFNGLBINDFRAMEBUFFERPROC BindFramebuffer = - __glGetProcAddress("glBindFramebuffer"); - BindFramebuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)); + CALL_BindFramebuffer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ) ); } -void -__glXDisp_BindRenderbuffer(GLbyte * pc) +void __glXDisp_BindRenderbuffer(GLbyte * pc) { - PFNGLBINDRENDERBUFFERPROC BindRenderbuffer = - __glGetProcAddress("glBindRenderbuffer"); - BindRenderbuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)); + CALL_BindRenderbuffer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4) + ) ); } -void -__glXDisp_BlitFramebuffer(GLbyte * pc) +void __glXDisp_BlitFramebuffer(GLbyte * pc) { - PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer = - __glGetProcAddress("glBlitFramebuffer"); - BlitFramebuffer(*(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)); + CALL_BlitFramebuffer( 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) + ) ); } -int -__glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_CheckFramebufferStatus(__GLXclientState *cl, GLbyte *pc) { - PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus = - __glGetProcAddress("glCheckFramebufferStatus"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLenum retval; - - retval = CheckFramebufferStatus(*(GLenum *) (pc + 0)); + retval = CALL_CheckFramebufferStatus( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -4544,93 +4999,97 @@ __glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_DeleteFramebuffers(GLbyte * pc) +void __glXDisp_DeleteFramebuffers(GLbyte * pc) { - PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers = - __glGetProcAddress("glDeleteFramebuffers"); - const GLsizei n = *(GLsizei *) (pc + 0); + const GLsizei n = *(GLsizei *)(pc + 0); - DeleteFramebuffers(n, (const GLuint *) (pc + 4)); + CALL_DeleteFramebuffers( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); } -void -__glXDisp_DeleteRenderbuffers(GLbyte * pc) +void __glXDisp_DeleteRenderbuffers(GLbyte * pc) { - PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers = - __glGetProcAddress("glDeleteRenderbuffers"); - const GLsizei n = *(GLsizei *) (pc + 0); + const GLsizei n = *(GLsizei *)(pc + 0); - DeleteRenderbuffers(n, (const GLuint *) (pc + 4)); + CALL_DeleteRenderbuffers( GET_DISPATCH(), ( + n, + (const GLuint *)(pc + 4) + ) ); } -void -__glXDisp_FramebufferRenderbuffer(GLbyte * pc) +void __glXDisp_FramebufferRenderbuffer(GLbyte * pc) { - PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer = - __glGetProcAddress("glFramebufferRenderbuffer"); - FramebufferRenderbuffer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), *(GLuint *) (pc + 12)); + CALL_FramebufferRenderbuffer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLuint *)(pc + 12) + ) ); } -void -__glXDisp_FramebufferTexture1D(GLbyte * pc) +void __glXDisp_FramebufferTexture1D(GLbyte * pc) { - PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D = - __glGetProcAddress("glFramebufferTexture1D"); - FramebufferTexture1D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), *(GLuint *) (pc + 12), - *(GLint *) (pc + 16)); + CALL_FramebufferTexture1D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLuint *)(pc + 12), + *(GLint *)(pc + 16) + ) ); } -void -__glXDisp_FramebufferTexture2D(GLbyte * pc) +void __glXDisp_FramebufferTexture2D(GLbyte * pc) { - PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D = - __glGetProcAddress("glFramebufferTexture2D"); - FramebufferTexture2D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), *(GLuint *) (pc + 12), - *(GLint *) (pc + 16)); + CALL_FramebufferTexture2D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLuint *)(pc + 12), + *(GLint *)(pc + 16) + ) ); } -void -__glXDisp_FramebufferTexture3D(GLbyte * pc) +void __glXDisp_FramebufferTexture3D(GLbyte * pc) { - PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D = - __glGetProcAddress("glFramebufferTexture3D"); - FramebufferTexture3D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), *(GLuint *) (pc + 12), - *(GLint *) (pc + 16), *(GLint *) (pc + 20)); + CALL_FramebufferTexture3D( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + *(GLuint *)(pc + 12), + *(GLint *)(pc + 16), + *(GLint *)(pc + 20) + ) ); } -void -__glXDisp_FramebufferTextureLayer(GLbyte * pc) +void __glXDisp_FramebufferTextureLayer(GLbyte * pc) { - PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer = - __glGetProcAddress("glFramebufferTextureLayer"); - FramebufferTextureLayer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLuint *) (pc + 8), *(GLint *) (pc + 12), - *(GLint *) (pc + 16)); + CALL_FramebufferTextureLayer( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLuint *)(pc + 8), + *(GLint *)(pc + 12), + *(GLint *)(pc + 16) + ) ); } -int -__glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenFramebuffers(__GLXclientState *cl, GLbyte *pc) { - PFNGLGENFRAMEBUFFERSPROC GenFramebuffers = - __glGetProcAddress("glGenFramebuffers"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *framebuffers = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - GenFramebuffers(n, framebuffers); + GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); + CALL_GenFramebuffers( GET_DISPATCH(), ( + n, + framebuffers + ) ); __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0); error = Success; } @@ -4638,24 +5097,22 @@ __glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc) { - PFNGLGENRENDERBUFFERSPROC GenRenderbuffers = - __glGetProcAddress("glGenRenderbuffers"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { - const GLsizei n = *(GLsizei *) (pc + 0); + if ( cx != NULL ) { + const GLsizei n = *(GLsizei *)(pc + 0); GLuint answerBuffer[200]; - GLuint *renderbuffers = - __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), - 4); - GenRenderbuffers(n, renderbuffers); + GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); + CALL_GenRenderbuffers( GET_DISPATCH(), ( + n, + renderbuffers + ) ); __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0); error = Success; } @@ -4663,32 +5120,28 @@ __glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc) return error; } -void -__glXDisp_GenerateMipmap(GLbyte * pc) +void __glXDisp_GenerateMipmap(GLbyte * pc) { - PFNGLGENERATEMIPMAPPROC GenerateMipmap = - __glGetProcAddress("glGenerateMipmap"); - GenerateMipmap(*(GLenum *) (pc + 0)); + CALL_GenerateMipmap( GET_DISPATCH(), ( + *(GLenum *)(pc + 0) + ) ); } -int -__glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl, - GLbyte * pc) +int __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC - GetFramebufferAttachmentParameteriv = - __glGetProcAddress("glGetFramebufferAttachmentParameteriv"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLint params[1]; - - GetFramebufferAttachmentParameteriv(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), - *(GLenum *) (pc + 8), params); + CALL_GetFramebufferAttachmentParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLenum *)(pc + 8), + params + ) ); __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0); error = Success; } @@ -4696,21 +5149,20 @@ __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl, return error; } -int -__glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_GetRenderbufferParameteriv(__GLXclientState *cl, GLbyte *pc) { - PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv = - __glGetProcAddress("glGetRenderbufferParameteriv"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLint params[1]; - - GetRenderbufferParameteriv(*(GLenum *) (pc + 0), - *(GLenum *) (pc + 4), params); + CALL_GetRenderbufferParameteriv( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + params + ) ); __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0); error = Success; } @@ -4718,20 +5170,37 @@ __glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc) +int __glXDisp_IsFramebuffer(__GLXclientState *cl, GLbyte *pc) { - PFNGLISFRAMEBUFFERPROC IsFramebuffer = - __glGetProcAddress("glIsFramebuffer"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; int error; - __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + if ( cx != NULL ) { GLboolean retval; + retval = CALL_IsFramebuffer( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); + __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); + error = Success; + } + + return error; +} + +int __glXDisp_IsRenderbuffer(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; + int error; + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); - retval = IsFramebuffer(*(GLuint *) (pc + 0)); + pc += __GLX_VENDPRIV_HDR_SIZE; + if ( cx != NULL ) { + GLboolean retval; + retval = CALL_IsRenderbuffer( GET_DISPATCH(), ( + *(GLuint *)(pc + 0) + ) ); __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); error = Success; } @@ -4739,364 +5208,743 @@ __glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc) return error; } -int -__glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc) +void __glXDisp_RenderbufferStorage(GLbyte * pc) +{ + CALL_RenderbufferStorage( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLenum *)(pc + 4), + *(GLsizei *)(pc + 8), + *(GLsizei *)(pc + 12) + ) ); +} + +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_SecondaryColor3fvEXT(GLbyte * pc) +{ + CALL_SecondaryColor3fvEXT( GET_DISPATCH(), ( + (const GLfloat *)(pc + 0) + ) ); +} + +void __glXDisp_FogCoordfvEXT(GLbyte * pc) { - PFNGLISRENDERBUFFERPROC IsRenderbuffer = - __glGetProcAddress("glIsRenderbuffer"); - xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc; + CALL_FogCoordfvEXT( 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); + __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); pc += __GLX_VENDPRIV_HDR_SIZE; - if (cx != NULL) { + 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; + } - retval = IsRenderbuffer(*(GLuint *) (pc + 0)); - __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); + return error; +} + +void __glXDisp_ExecuteProgramNV(GLbyte * pc) +{ + CALL_ExecuteProgramNV( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + (const GLfloat *)(pc + 8) + ) ); +} + +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; } -void -__glXDisp_RenderbufferStorage(GLbyte * pc) +int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc) { - PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage = - __glGetProcAddress("glRenderbufferStorage"); - RenderbufferStorage(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), - *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)); + 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; } -void -__glXDisp_RenderbufferStorageMultisample(GLbyte * pc) +int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc) { - PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample = - __glGetProcAddress("glRenderbufferStorageMultisample"); - RenderbufferStorageMultisample(*(GLenum *) (pc + 0), *(GLsizei *) (pc + 4), - *(GLenum *) (pc + 8), *(GLsizei *) (pc + 12), - *(GLsizei *) (pc + 16)); + 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; } -void -__glXDisp_SecondaryColor3fvEXT(GLbyte * pc) +int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc) { - PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT = - __glGetProcAddress("glSecondaryColor3fvEXT"); - SecondaryColor3fvEXT((const GLfloat *) (pc + 0)); + 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; } -void -__glXDisp_FogCoordfvEXT(GLbyte * pc) +void __glXDisp_LoadProgramNV(GLbyte * pc) { - PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT = - __glGetProcAddress("glFogCoordfvEXT"); - FogCoordfvEXT((const GLfloat *) (pc + 0)); + const GLsizei len = *(GLsizei *)(pc + 8); + + CALL_LoadProgramNV( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + len, + (const GLubyte *)(pc + 12) + ) ); } -void -__glXDisp_VertexAttrib1dvNV(GLbyte * pc) +void __glXDisp_ProgramParameters4dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV = - __glGetProcAddress("glVertexAttrib1dvNV"); + const GLsizei num = *(GLsizei *)(pc + 8); + #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 12); + const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4; + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif - VertexAttrib1dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_ProgramParameters4dvNV( GET_DISPATCH(), ( + *(GLenum *)(pc + 0), + *(GLuint *)(pc + 4), + num, + (const GLdouble *)(pc + 12) + ) ); } -void -__glXDisp_VertexAttrib1fvNV(GLbyte * pc) +void __glXDisp_ProgramParameters4fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV = - __glGetProcAddress("glVertexAttrib1fvNV"); - VertexAttrib1fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + 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) +void __glXDisp_VertexAttrib1svNV(GLbyte * pc) { - PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV = - __glGetProcAddress("glVertexAttrib1svNV"); - VertexAttrib1svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib1svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2dvNV(GLbyte * pc) +void __glXDisp_VertexAttrib2dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV = - __glGetProcAddress("glVertexAttrib2dvNV"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 20); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 20); pc -= 4; } #endif - VertexAttrib2dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib2dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2fvNV(GLbyte * pc) +void __glXDisp_VertexAttrib2fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV = - __glGetProcAddress("glVertexAttrib2fvNV"); - VertexAttrib2fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib2fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib2svNV(GLbyte * pc) +void __glXDisp_VertexAttrib2svNV(GLbyte * pc) { - PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV = - __glGetProcAddress("glVertexAttrib2svNV"); - VertexAttrib2svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib2svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3dvNV(GLbyte * pc) +void __glXDisp_VertexAttrib3dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV = - __glGetProcAddress("glVertexAttrib3dvNV"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 28); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 28); pc -= 4; } #endif - VertexAttrib3dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib3dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3fvNV(GLbyte * pc) +void __glXDisp_VertexAttrib3fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV = - __glGetProcAddress("glVertexAttrib3fvNV"); - VertexAttrib3fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib3fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib3svNV(GLbyte * pc) +void __glXDisp_VertexAttrib3svNV(GLbyte * pc) { - PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV = - __glGetProcAddress("glVertexAttrib3svNV"); - VertexAttrib3svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib3svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4dvNV(GLbyte * pc) +void __glXDisp_VertexAttrib4dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV = - __glGetProcAddress("glVertexAttrib4dvNV"); #ifdef __GLX_ALIGN64 - if ((unsigned long) (pc) & 7) { - (void) memmove(pc - 4, pc, 36); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, 36); pc -= 4; } #endif - VertexAttrib4dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4)); + CALL_VertexAttrib4dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLdouble *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4fvNV(GLbyte * pc) +void __glXDisp_VertexAttrib4fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV = - __glGetProcAddress("glVertexAttrib4fvNV"); - VertexAttrib4fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4)); + CALL_VertexAttrib4fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLfloat *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4svNV(GLbyte * pc) +void __glXDisp_VertexAttrib4svNV(GLbyte * pc) { - PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV = - __glGetProcAddress("glVertexAttrib4svNV"); - VertexAttrib4svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4)); + CALL_VertexAttrib4svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLshort *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttrib4ubvNV(GLbyte * pc) +void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc) { - PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV = - __glGetProcAddress("glVertexAttrib4ubvNV"); - VertexAttrib4ubvNV(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4)); + CALL_VertexAttrib4ubvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + (const GLubyte *)(pc + 4) + ) ); } -void -__glXDisp_VertexAttribs1dvNV(GLbyte * pc) +void __glXDisp_VertexAttribs1dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV = - __glGetProcAddress("glVertexAttribs1dvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + 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); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif - VertexAttribs1dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8)); + CALL_VertexAttribs1dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs1fvNV(GLbyte * pc) +void __glXDisp_VertexAttribs1fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV = - __glGetProcAddress("glVertexAttribs1fvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs1fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8)); + CALL_VertexAttribs1fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs1svNV(GLbyte * pc) +void __glXDisp_VertexAttribs1svNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV = - __glGetProcAddress("glVertexAttribs1svNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs1svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8)); + CALL_VertexAttribs1svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLshort *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs2dvNV(GLbyte * pc) +void __glXDisp_VertexAttribs2dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV = - __glGetProcAddress("glVertexAttribs2dvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + 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); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif - VertexAttribs2dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8)); + CALL_VertexAttribs2dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs2fvNV(GLbyte * pc) +void __glXDisp_VertexAttribs2fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV = - __glGetProcAddress("glVertexAttribs2fvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs2fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8)); + CALL_VertexAttribs2fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs2svNV(GLbyte * pc) +void __glXDisp_VertexAttribs2svNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV = - __glGetProcAddress("glVertexAttribs2svNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs2svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8)); + CALL_VertexAttribs2svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLshort *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs3dvNV(GLbyte * pc) +void __glXDisp_VertexAttribs3dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV = - __glGetProcAddress("glVertexAttribs3dvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + 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); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif - VertexAttribs3dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8)); + CALL_VertexAttribs3dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs3fvNV(GLbyte * pc) +void __glXDisp_VertexAttribs3fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV = - __glGetProcAddress("glVertexAttribs3fvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs3fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8)); + CALL_VertexAttribs3fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs3svNV(GLbyte * pc) +void __glXDisp_VertexAttribs3svNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV = - __glGetProcAddress("glVertexAttribs3svNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs3svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8)); + CALL_VertexAttribs3svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLshort *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs4dvNV(GLbyte * pc) +void __glXDisp_VertexAttribs4dvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV = - __glGetProcAddress("glVertexAttribs4dvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + 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); + if ((unsigned long)(pc) & 7) { + (void) memmove(pc-4, pc, cmdlen); pc -= 4; } #endif - VertexAttribs4dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8)); + CALL_VertexAttribs4dvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLdouble *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs4fvNV(GLbyte * pc) +void __glXDisp_VertexAttribs4fvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV = - __glGetProcAddress("glVertexAttribs4fvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs4fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8)); + CALL_VertexAttribs4fvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLfloat *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs4svNV(GLbyte * pc) +void __glXDisp_VertexAttribs4svNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV = - __glGetProcAddress("glVertexAttribs4svNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs4svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8)); + CALL_VertexAttribs4svNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLshort *)(pc + 8) + ) ); } -void -__glXDisp_VertexAttribs4ubvNV(GLbyte * pc) +void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc) { - PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV = - __glGetProcAddress("glVertexAttribs4ubvNV"); - const GLsizei n = *(GLsizei *) (pc + 4); + const GLsizei n = *(GLsizei *)(pc + 4); - VertexAttribs4ubvNV(*(GLuint *) (pc + 0), n, (const GLubyte *) (pc + 8)); + CALL_VertexAttribs4ubvNV( GET_DISPATCH(), ( + *(GLuint *)(pc + 0), + n, + (const GLubyte *)(pc + 8) + ) ); } -void -__glXDisp_ActiveStencilFaceEXT(GLbyte * pc) +void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc) { - PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT = - __glGetProcAddress("glActiveStencilFaceEXT"); - ActiveStencilFaceEXT(*(GLenum *) (pc + 0)); + 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_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) + ) ); +} + |