int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; ClientPtr client = cl->client; int error; GLdouble answer[4]; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; __GLX_SWAP_INT(pc + 0); __glXClearErrorOccured(); glGetClipPlane(*(GLenum *)(pc + 0), answer); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_SWAP_REPLY_HEADER(); __GLX_SEND_HEADER(); } else { __GLX_SWAP_DOUBLE_ARRAY((GLbyte *)answer, 4); __GLX_BEGIN_REPLY(32); __GLX_SWAP_REPLY_HEADER(); __GLX_SEND_HEADER(); __GLX_SEND_DOUBLE_ARRAY(4); } return Success; }
int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc) { GLsizei size; GLenum type; __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; size = *(GLsizei *)(pc+0); type = *(GLenum *)(pc+4); if (cx->feedbackBufSize < size) { cx->feedbackBuf = (GLfloat *) __glXRealloc(cx->feedbackBuf, (size_t)size * __GLX_SIZE_FLOAT32); if (!cx->feedbackBuf) { cl->client->errorValue = size; return BadAlloc; } cx->feedbackBufSize = size; } glFeedbackBuffer(size, type, cx->feedbackBuf); __GLX_NOTE_UNFLUSHED_CMDS(cx); return Success; }
int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc) { ClientPtr client = cl->client; GLsizei size; GLenum type; __GLX_DECLARE_SWAP_VARIABLES; __GLXcontext *cx; int error; REQUEST_FIXED_SIZE(xGLXSingleReq, 8); __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; __GLX_SWAP_INT(pc+0); __GLX_SWAP_INT(pc+4); size = *(GLsizei *)(pc+0); type = *(GLenum *)(pc+4); if (cx->feedbackBufSize < size) { cx->feedbackBuf = (GLfloat *) __glXRealloc(cx->feedbackBuf, (size_t) size * __GLX_SIZE_FLOAT32); if (!cx->feedbackBuf) { cl->client->errorValue = size; return BadAlloc; } cx->feedbackBufSize = size; } glFeedbackBuffer(size, type, cx->feedbackBuf); __GLX_NOTE_UNFLUSHED_CMDS(cx); return Success; }
int __glXDisp_FeedbackBuffer(__GLXclientState * cl, GLbyte * pc) { GLsizei size; GLenum type; __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; size = *(GLsizei *) (pc + 0); type = *(GLenum *) (pc + 4); if (cx->feedbackBufSize < size) { cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf, (size_t) size * __GLX_SIZE_FLOAT32); if (!cx->feedbackBuf) { cl->client->errorValue = size; return BadAlloc; } cx->feedbackBufSize = size; } CALL_FeedbackBuffer(GET_DISPATCH(), (size, type, cx->feedbackBuf)); cx->hasUnflushedCommands = GL_TRUE; return Success; }
int __glXDisp_SelectBuffer(__GLXclientState * cl, GLbyte * pc) { __GLXcontext *cx; GLsizei size; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; size = *(GLsizei *) (pc + 0); if (cx->selectBufSize < size) { cx->selectBuf = (GLuint *) realloc(cx->selectBuf, (size_t) size * __GLX_SIZE_CARD32); if (!cx->selectBuf) { cl->client->errorValue = size; return BadAlloc; } cx->selectBufSize = size; } CALL_SelectBuffer(GET_DISPATCH(), (size, cx->selectBuf)); cx->hasUnflushedCommands = GL_TRUE; return Success; }
int __glXDispSwap_SelectBuffer(__GLXclientState * cl, GLbyte * pc) { ClientPtr client = cl->client; __GLXcontext *cx; GLsizei size; __GLX_DECLARE_SWAP_VARIABLES; int error; REQUEST_FIXED_SIZE(xGLXSingleReq, 4); __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; __GLX_SWAP_INT(pc + 0); size = *(GLsizei *) (pc + 0); if (cx->selectBufSize < size) { cx->selectBuf = reallocarray(cx->selectBuf, (size_t) size, __GLX_SIZE_CARD32); if (!cx->selectBuf) { cl->client->errorValue = size; return BadAlloc; } cx->selectBufSize = size; } glSelectBuffer(size, cx->selectBuf); cx->hasUnflushedCommands = GL_TRUE; return Success; }
int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; ClientPtr client = cl->client; int error; GLdouble answer[4]; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; __glXClearErrorOccured(); glGetClipPlane(*(GLenum *)(pc + 0), answer); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(32); __GLX_SEND_HEADER(); __GLX_SEND_DOUBLE_ARRAY(4); } return Success; }
int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc) { GLsizei n; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLuint answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; n = *(GLsizei *)(pc + 0); __GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4); glGenTextures( *(GLsizei *)(pc + 0), (GLuint *) answer ); __GLX_BEGIN_REPLY(n*4); __GLX_SEND_HEADER(); __GLX_SEND_INT_ARRAY(n); return Success; }
int __glXDisp_GetColorTable(__GLXclientState * cl, GLbyte * pc) { const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); return GetColorTable(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); }
int __glXDisp_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc) { GLboolean lsbFirst; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLubyte answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; lsbFirst = *(GLboolean *) (pc + 0); CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst)); __GLX_GET_ANSWER_BUFFER(answer, cl, 128, 1); __glXClearErrorOccured(); CALL_GetPolygonStipple(GET_DISPATCH(), ((GLubyte *) answer)); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(128); __GLX_SEND_HEADER(); __GLX_SEND_BYTE_ARRAY(128); } return Success; }
int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc) { GLsizei n; GLboolean retval; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLboolean answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; n = *(GLsizei *)(pc + 0); __GLX_GET_ANSWER_BUFFER(answer,cl,n,1); retval = glAreTexturesResident( *(GLsizei *)(pc + 0), (GLuint *)(pc + 4), (GLboolean *) answer ); __GLX_PUT_RETVAL(retval); __GLX_BEGIN_REPLY(n); __GLX_SEND_HEADER(); __GLX_SEND_BYTE_ARRAY(n); return Success; }
int __glXDispSwap_Finish(__GLXclientState * cl, GLbyte * pc) { ClientPtr client = cl->client; __GLXcontext *cx; int error; __GLX_DECLARE_SWAP_VARIABLES; REQUEST_SIZE_MATCH(xGLXSingleReq); __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } /* Do a local glFinish */ glFinish(); cx->hasUnflushedCommands = GL_FALSE; /* Send empty reply packet to indicate finish is finished */ __GLX_BEGIN_REPLY(0); __GLX_PUT_RETVAL(0); __GLX_SWAP_REPLY_HEADER(); __GLX_SEND_HEADER(); return Success; }
int __glXDispSwap_GetColorTable(__GLXclientState * cl, GLbyte * pc) { const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); ClientPtr client = cl->client; REQUEST_FIXED_SIZE(xGLXSingleReq, 16); return GetColorTable(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); }
int __glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc) { GLsizei width, height; GLenum format, type; GLboolean swapBytes, lsbFirst; GLint compsize; __GLXcontext *cx; ClientPtr client = cl->client; int error; char *answer, answerBuffer[200]; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; width = *(GLsizei *) (pc + 8); height = *(GLsizei *) (pc + 12); format = *(GLenum *) (pc + 16); type = *(GLenum *) (pc + 20); swapBytes = *(GLboolean *) (pc + 24); lsbFirst = *(GLboolean *) (pc + 25); compsize = __glReadPixels_size(format, type, width, height); if (compsize < 0) compsize = 0; CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes)); CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst)); __GLX_GET_ANSWER_BUFFER(answer, cl, compsize, 1); __glXClearErrorOccured(); CALL_ReadPixels(GET_DISPATCH(), (*(GLint *) (pc + 0), *(GLint *) (pc + 4), *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12), *(GLenum *) (pc + 16), *(GLenum *) (pc + 20), answer)); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(compsize); __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } cx->hasUnflushedCommands = GL_FALSE; return Success; }
int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } glEndList( ); return Success; }
int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } CALL_Flush( GET_DISPATCH(), () ); cx->hasUnflushedCommands = GL_FALSE; return Success; }
int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } glFlush(); __GLX_NOTE_FLUSHED_CMDS(cx); return Success; }
static int ephyrGLXGetStringReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap) { ClientPtr client=NULL ; int context_tag=0, name=0, res=BadImplementation, length=0 ; char *string=NULL; __GLX_DECLARE_SWAP_VARIABLES; EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, BadValue) ; EPHYR_LOG ("enter\n") ; client = a_cl->client ; if (a_do_swap) { __GLX_SWAP_INT (a_pc + 4); __GLX_SWAP_INT (a_pc + __GLX_SINGLE_HDR_SIZE); } context_tag = __GLX_GET_SINGLE_CONTEXT_TAG (a_pc) ; a_pc += __GLX_SINGLE_HDR_SIZE; name = *(GLenum*)(a_pc + 0); EPHYR_LOG ("context_tag:%d, name:%d\n", context_tag, name) ; if (!ephyrHostGLXGetStringFromServer (context_tag, name, EPHYR_HOST_GLX_GetString, &string)) { EPHYR_LOG_ERROR ("failed to get string from server\n") ; goto out ; } if (string) { length = strlen (string) + 1; EPHYR_LOG ("got string:'%s', size:%d\n", string, length) ; } else { EPHYR_LOG ("got string: string (null)\n") ; } __GLX_BEGIN_REPLY (length); __GLX_PUT_SIZE (length); __GLX_SEND_HEADER (); if (a_do_swap) { __GLX_SWAP_REPLY_SIZE (); __GLX_SWAP_REPLY_HEADER (); } WriteToClient (client, length, (char *)string); res = Success ; out: EPHYR_LOG ("leave\n") ; return res ; }
int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; __GLX_DECLARE_SWAP_VARIABLES; __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } CALL_Flush( GET_DISPATCH(), () ); __GLX_NOTE_FLUSHED_CMDS(cx); return Success; }
int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc) { GLenum target; GLenum query; GLint compsize; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLint answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; target = *(GLenum *)(pc + 0); query = *(GLenum *)(pc + 4); compsize = __glGetMapiv_size(target,query); if (compsize < 0) compsize = 0; __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4); __glXClearErrorOccured(); glGetMapiv( *(GLenum *)(pc + 0), *(GLenum *)(pc + 4), (GLint *) answer ); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(0); __GLX_SEND_HEADER(); } else if (compsize == 1) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(1); __GLX_PUT_INT(); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(compsize*4); __GLX_PUT_SIZE(compsize); __GLX_SEND_HEADER(); __GLX_SEND_INT_ARRAY(compsize); } return Success; }
int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; glPixelStorei( *(GLenum *)(pc + 0), *(GLint *)(pc + 4) ); __GLX_NOTE_UNFLUSHED_CMDS(cx); return Success; }
int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; glDeleteLists( *(GLuint *)(pc + 0), *(GLsizei *)(pc + 4) ); __GLX_NOTE_UNFLUSHED_CMDS(cx); return Success; }
int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc) { ClientPtr client = cl->client; __GLXcontext *cx; int error; __GLX_DECLARE_SWAP_VARIABLES; REQUEST_SIZE_MATCH(xGLXSingleReq); __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } glFlush(); __GLX_NOTE_FLUSHED_CMDS(cx); return Success; }
int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc) { GLenum pname; GLint compsize; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLfloat answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; pname = *(GLenum *)(pc + 8); compsize = __glGetTexLevelParameterfv_size(pname); if (compsize < 0) compsize = 0; __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4); __glXClearErrorOccured(); glGetTexLevelParameterfv( *(GLenum *)(pc + 0), *(GLint *)(pc + 4), *(GLenum *)(pc + 8), (GLfloat *) answer ); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(0); __GLX_SEND_HEADER(); } else if (compsize == 1) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(1); __GLX_PUT_FLOAT(); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(compsize*4); __GLX_PUT_SIZE(compsize); __GLX_SEND_HEADER(); __GLX_SEND_FLOAT_ARRAY(compsize); } return Success; }
int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc) { GLsizei n; __GLXcontext *cx; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; n = *(GLsizei *)(pc + 0); glDeleteTextures( *(GLsizei *)(pc + 0), (GLuint *)(pc + 4) ); return Success; }
int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc) { GLenum map; GLint compsize; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLushort answerBuffer[200]; char *answer; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; map = *(GLenum *)(pc + 0); compsize = __glGetPixelMapusv_size(map); if (compsize < 0) compsize = 0; __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*2,2); __glXClearErrorOccured(); glGetPixelMapusv( *(GLenum *)(pc + 0), (GLushort *) answer ); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(0); __GLX_SEND_HEADER(); } else if (compsize == 1) { __GLX_BEGIN_REPLY(0); __GLX_PUT_SIZE(1); __GLX_PUT_SHORT(); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(compsize*2); __GLX_PUT_SIZE(compsize); __GLX_SEND_HEADER(); __GLX_SEND_SHORT_ARRAY(compsize); } return Success; }
int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc) { GLenum retval; __GLXcontext *cx; ClientPtr client = cl->client; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } retval = glGetError( ); __GLX_PUT_RETVAL(retval); __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); return Success; }
int __glXDispSwap_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc) { GLboolean lsbFirst; __GLXcontext *cx; ClientPtr client = cl->client; int error; GLubyte answerBuffer[200]; char *answer; xGLXSingleReply reply = { 0, }; __GLX_DECLARE_SWAP_VARIABLES; REQUEST_FIXED_SIZE(xGLXSingleReq, 4); __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; lsbFirst = *(GLboolean *) (pc + 0); glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst); __GLX_GET_ANSWER_BUFFER(answer, cl, 128, 1); __glXClearErrorOccured(); glGetPolygonStipple((GLubyte *) answer); if (__glXErrorOccured()) { __GLX_BEGIN_REPLY(0); __GLX_SWAP_REPLY_HEADER(); __GLX_SEND_HEADER(); } else { __GLX_BEGIN_REPLY(128); __GLX_SWAP_REPLY_HEADER(); __GLX_SEND_HEADER(); __GLX_SEND_BYTE_ARRAY(128); } return Success; }
int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; ClientPtr client; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } /* Do a local glFinish */ CALL_Finish( GET_DISPATCH(), () ); cx->hasUnflushedCommands = GL_FALSE; /* Send empty reply packet to indicate finish is finished */ client = cl->client; __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); return Success; }
int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc) { __GLXcontext *cx; ClientPtr client; int error; cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } /* Do a local glFinish */ glFinish(); __GLX_NOTE_FLUSHED_CMDS(cx); /* Send empty reply packet to indicate finish is finished */ client = cl->client; __GLX_BEGIN_REPLY(0); __GLX_SEND_HEADER(); return Success; }