diff --git a/glx/glxcmds.c b/glx/glxcmds.c index 6f973f5215..75e17ee6c2 100644 --- a/glx/glxcmds.c +++ b/glx/glxcmds.c @@ -744,9 +744,8 @@ __glXDisp_QueryVersion(__GLXclientState * cl, GLbyte * pc) }; if (client->swapped) { - __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT(&reply.majorVersion); - __GLX_SWAP_INT(&reply.minorVersion); + swapl(&reply.majorVersion); + swapl(&reply.minorVersion); } X_SEND_REPLY_SIMPLE(client, reply); @@ -898,8 +897,6 @@ __glXDisp_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc) CARD32 buf[GLX_VIS_CONFIG_TOTAL]; int p, i, err; - __GLX_DECLARE_SWAP_VARIABLES; - if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err)) return err; @@ -914,9 +911,9 @@ __glXDisp_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc) if (client->swapped) { swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.numVisuals); - __GLX_SWAP_INT(&reply.numProps); + swapl(&reply.length); + swapl(&reply.numVisuals); + swapl(&reply.numProps); } WriteToClient(client, sizeof(xGLXGetVisualConfigsReply), &reply); @@ -1011,8 +1008,6 @@ DoGetFBConfigs(__GLXclientState * cl, unsigned screen) int p, err; __GLXconfig *modes; - __GLX_DECLARE_SWAP_VARIABLES; - if (!validGlxScreen(cl->client, screen, &pGlxScreen, &err)) return err; @@ -1026,9 +1021,9 @@ DoGetFBConfigs(__GLXclientState * cl, unsigned screen) if (client->swapped) { swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.numFBConfigs); - __GLX_SWAP_INT(&reply.numAttribs); + swapl(&reply.length); + swapl(&reply.numFBConfigs); + swapl(&reply.numAttribs); } WriteToClient(client, sizeof(xGLXGetFBConfigsReply), &reply); @@ -1912,10 +1907,9 @@ DoGetDrawableAttributes(__GLXclientState * cl, XID drawId) if (client->swapped) { int length = reply.length; - __GLX_DECLARE_SWAP_VARIABLES; swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.numAttribs); + swapl(&reply.length); + swapl(&reply.numAttribs); WriteToClient(client, sizeof(xGLXGetDrawableAttributesReply), &reply); SwapLongs(attributes, length); WriteToClient(client, length << 2, attributes); @@ -1985,14 +1979,12 @@ __glXDisp_Render(__GLXclientState * cl, GLbyte * pc) __GLXrenderHeader *hdr; __GLXcontext *glxc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXRenderReq); req = (xGLXRenderReq *) pc; if (client->swapped) { swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); + swapl(&req->contextTag); } glxc = __glXForceCurrent(cl, req->contextTag, &error); @@ -2087,15 +2079,13 @@ __glXDisp_RenderLarge(__GLXclientState * cl, GLbyte * pc) int error; CARD16 opcode; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXRenderLargeReq); req = (xGLXRenderLargeReq *) pc; if (client->swapped) { swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(&req->dataBytes); + swapl(&req->contextTag); + swapl(&req->dataBytes); swaps(&req->requestNumber); swaps(&req->requestTotal); } @@ -2140,8 +2130,8 @@ __glXDisp_RenderLarge(__GLXclientState * cl, GLbyte * pc) hdr = (__GLXrenderLargeHeader *) pc; if (client->swapped) { - __GLX_SWAP_INT(&hdr->length); - __GLX_SWAP_INT(&hdr->opcode); + swapl(&hdr->length); + swapl(&hdr->opcode); } opcode = hdr->opcode; if ((cmdlen = safe_pad(hdr->length)) < 0) @@ -2372,10 +2362,9 @@ __glXDisp_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc) memcpy(buf, pGlxScreen->GLXextensions, n); if (client->swapped) { - __GLX_DECLARE_SWAP_VARIABLES; swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.n); + swapl(&reply.length); + swapl(&reply.n); WriteToClient(client, sizeof(xGLXQueryExtensionsStringReply), &reply); SwapLongs((CARD32*)buf, length); WriteToClient(client, length << 2, buf); @@ -2444,10 +2433,9 @@ __glXDisp_QueryServerString(__GLXclientState * cl, GLbyte * pc) memcpy(buf, ptr, n); if (client->swapped) { - __GLX_DECLARE_SWAP_VARIABLES; swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.n); + swapl(&reply.length); + swapl(&reply.n); WriteToClient(client, sizeof(xGLXQueryServerStringReply), &reply); /** no swap is needed for an array of chars **/ WriteToClient(client, length << 2, buf); diff --git a/glx/glxcmdsswap.c b/glx/glxcmdsswap.c index 9adff11939..285de19c85 100644 --- a/glx/glxcmdsswap.c +++ b/glx/glxcmdsswap.c @@ -56,13 +56,11 @@ __glXDispSwap_CreateContext(__GLXclientState * cl, GLbyte * pc) { xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->context); - __GLX_SWAP_INT(&req->visual); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->shareList); + swapl(&req->context); + swapl(&req->visual); + swapl(&req->screen); + swapl(&req->shareList); return __glXDisp_CreateContext(cl, pc); } @@ -72,14 +70,12 @@ __glXDispSwap_CreateNewContext(__GLXclientState * cl, GLbyte * pc) { xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->context); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->renderType); - __GLX_SWAP_INT(&req->shareList); + swapl(&req->context); + swapl(&req->fbconfig); + swapl(&req->screen); + swapl(&req->renderType); + swapl(&req->shareList); return __glXDisp_CreateNewContext(cl, pc); } @@ -90,16 +86,15 @@ __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq); swaps(&req->length); - __GLX_SWAP_INT(&req->context); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->renderType); - __GLX_SWAP_INT(&req->shareList); + swapl(&req->context); + swapl(&req->fbconfig); + swapl(&req->screen); + swapl(&req->renderType); + swapl(&req->shareList); return __glXDisp_CreateContextWithConfigSGIX(cl, pc); } @@ -109,10 +104,8 @@ __glXDispSwap_DestroyContext(__GLXclientState * cl, GLbyte * pc) { xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->context); + swapl(&req->context); return __glXDisp_DestroyContext(cl, pc); } @@ -140,10 +133,8 @@ __glXDispSwap_IsDirect(__GLXclientState * cl, GLbyte * pc) { xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->context); + swapl(&req->context); return __glXDisp_IsDirect(cl, pc); } @@ -153,11 +144,9 @@ __glXDispSwap_QueryVersion(__GLXclientState * cl, GLbyte * pc) { xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->majorVersion); - __GLX_SWAP_INT(&req->minorVersion); + swapl(&req->majorVersion); + swapl(&req->minorVersion); return __glXDisp_QueryVersion(cl, pc); } @@ -167,10 +156,8 @@ __glXDispSwap_WaitGL(__GLXclientState * cl, GLbyte * pc) { xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); + swapl(&req->contextTag); return __glXDisp_WaitGL(cl, pc); } @@ -180,10 +167,8 @@ __glXDispSwap_WaitX(__GLXclientState * cl, GLbyte * pc) { xGLXWaitXReq *req = (xGLXWaitXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); + swapl(&req->contextTag); return __glXDisp_WaitX(cl, pc); } @@ -193,12 +178,10 @@ __glXDispSwap_CopyContext(__GLXclientState * cl, GLbyte * pc) { xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->source); - __GLX_SWAP_INT(&req->dest); - __GLX_SWAP_INT(&req->mask); + swapl(&req->source); + swapl(&req->dest); + swapl(&req->mask); return __glXDisp_CopyContext(cl, pc); } @@ -208,9 +191,7 @@ __glXDispSwap_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc) { xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - - __GLX_SWAP_INT(&req->screen); + swapl(&req->screen); return __glXDisp_GetVisualConfigs(cl, pc); } @@ -219,9 +200,7 @@ __glXDispSwap_GetFBConfigs(__GLXclientState * cl, GLbyte * pc) { xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - - __GLX_SWAP_INT(&req->screen); + swapl(&req->screen); return __glXDisp_GetFBConfigs(cl, pc); } @@ -231,11 +210,9 @@ __glXDispSwap_GetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq); - __GLX_SWAP_INT(&req->screen); + swapl(&req->screen); return __glXDisp_GetFBConfigsSGIX(cl, pc); } @@ -244,13 +221,11 @@ __glXDispSwap_CreateGLXPixmap(__GLXclientState * cl, GLbyte * pc) { xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->visual); - __GLX_SWAP_INT(&req->pixmap); - __GLX_SWAP_INT(&req->glxpixmap); + swapl(&req->screen); + swapl(&req->visual); + swapl(&req->pixmap); + swapl(&req->glxpixmap); return __glXDisp_CreateGLXPixmap(cl, pc); } @@ -262,16 +237,14 @@ __glXDispSwap_CreatePixmap(__GLXclientState * cl, GLbyte * pc) xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc; CARD32 *attribs; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq); swaps(&req->length); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->pixmap); - __GLX_SWAP_INT(&req->glxpixmap); - __GLX_SWAP_INT(&req->numAttribs); + swapl(&req->screen); + swapl(&req->fbconfig); + swapl(&req->pixmap); + swapl(&req->glxpixmap); + swapl(&req->numAttribs); if (req->numAttribs > (UINT32_MAX >> 3)) { client->errorValue = req->numAttribs; @@ -290,15 +263,14 @@ __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXCreateGLXPixmapWithConfigSGIXReq *req = (xGLXCreateGLXPixmapWithConfigSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq); swaps(&req->length); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->pixmap); - __GLX_SWAP_INT(&req->glxpixmap); + swapl(&req->screen); + swapl(&req->fbconfig); + swapl(&req->pixmap); + swapl(&req->glxpixmap); return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc); } @@ -308,10 +280,8 @@ __glXDispSwap_DestroyGLXPixmap(__GLXclientState * cl, GLbyte * pc) { xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->glxpixmap); + swapl(&req->glxpixmap); return __glXDisp_DestroyGLXPixmap(cl, pc); } @@ -322,12 +292,10 @@ __glXDispSwap_DestroyPixmap(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXDestroyGLXPixmapReq); swaps(&req->length); - __GLX_SWAP_INT(&req->glxpixmap); + swapl(&req->glxpixmap); return __glXDisp_DestroyGLXPixmap(cl, pc); } @@ -337,9 +305,7 @@ __glXDispSwap_QueryContext(__GLXclientState * cl, GLbyte * pc) { xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - - __GLX_SWAP_INT(&req->context); + swapl(&req->context); return __glXDisp_QueryContext(cl, pc); } @@ -350,15 +316,14 @@ __glXDispSwap_CreatePbuffer(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; CARD32 *attribs; REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->pbuffer); - __GLX_SWAP_INT(&req->numAttribs); + swapl(&req->screen); + swapl(&req->fbconfig); + swapl(&req->pbuffer); + swapl(&req->numAttribs); if (req->numAttribs > (UINT32_MAX >> 3)) { client->errorValue = req->numAttribs; @@ -377,15 +342,13 @@ __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->pbuffer); - __GLX_SWAP_INT(&req->width); - __GLX_SWAP_INT(&req->height); + swapl(&req->screen); + swapl(&req->fbconfig); + swapl(&req->pbuffer); + swapl(&req->width); + swapl(&req->height); return __glXDisp_CreateGLXPbufferSGIX(cl, pc); } @@ -395,9 +358,7 @@ __glXDispSwap_DestroyPbuffer(__GLXclientState * cl, GLbyte * pc) { xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - - __GLX_SWAP_INT(&req->pbuffer); + swapl(&req->pbuffer); return __glXDisp_DestroyPbuffer(cl, pc); } @@ -408,11 +369,9 @@ __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq); - __GLX_SWAP_INT(&req->pbuffer); + swapl(&req->pbuffer); return __glXDisp_DestroyGLXPbufferSGIX(cl, pc); } @@ -423,13 +382,12 @@ __glXDispSwap_ChangeDrawableAttributes(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; CARD32 *attribs; REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq); - __GLX_SWAP_INT(&req->drawable); - __GLX_SWAP_INT(&req->numAttribs); + swapl(&req->drawable); + swapl(&req->numAttribs); if (req->numAttribs > (UINT32_MAX >> 3)) { client->errorValue = req->numAttribs; @@ -451,13 +409,12 @@ __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXChangeDrawableAttributesSGIXReq *req = (xGLXChangeDrawableAttributesSGIXReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; CARD32 *attribs; REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq); - __GLX_SWAP_INT(&req->drawable); - __GLX_SWAP_INT(&req->numAttribs); + swapl(&req->drawable); + swapl(&req->numAttribs); if (req->numAttribs > (UINT32_MAX >> 3)) { client->errorValue = req->numAttribs; @@ -477,16 +434,15 @@ __glXDispSwap_CreateWindow(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; CARD32 *attribs; REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->fbconfig); - __GLX_SWAP_INT(&req->window); - __GLX_SWAP_INT(&req->glxwindow); - __GLX_SWAP_INT(&req->numAttribs); + swapl(&req->screen); + swapl(&req->fbconfig); + swapl(&req->window); + swapl(&req->glxwindow); + swapl(&req->numAttribs); if (req->numAttribs > (UINT32_MAX >> 3)) { client->errorValue = req->numAttribs; @@ -505,11 +461,9 @@ __glXDispSwap_DestroyWindow(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq); - __GLX_SWAP_INT(&req->glxwindow); + swapl(&req->glxwindow); return __glXDisp_DestroyWindow(cl, pc); } @@ -519,11 +473,9 @@ __glXDispSwap_SwapBuffers(__GLXclientState * cl, GLbyte * pc) { xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(&req->drawable); + swapl(&req->contextTag); + swapl(&req->drawable); return __glXDisp_SwapBuffers(cl, pc); } @@ -533,14 +485,12 @@ __glXDispSwap_UseXFont(__GLXclientState * cl, GLbyte * pc) { xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(&req->font); - __GLX_SWAP_INT(&req->first); - __GLX_SWAP_INT(&req->count); - __GLX_SWAP_INT(&req->listBase); + swapl(&req->contextTag); + swapl(&req->font); + swapl(&req->first); + swapl(&req->count); + swapl(&req->listBase); return __glXDisp_UseXFont(cl, pc); } @@ -550,10 +500,8 @@ __glXDispSwap_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc) { xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->screen); + swapl(&req->screen); return __glXDisp_QueryExtensionsString(cl, pc); } @@ -563,11 +511,9 @@ __glXDispSwap_QueryServerString(__GLXclientState * cl, GLbyte * pc) { xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - swaps(&req->length); - __GLX_SWAP_INT(&req->screen); - __GLX_SWAP_INT(&req->name); + swapl(&req->screen); + swapl(&req->name); return __glXDisp_QueryServerString(cl, pc); } @@ -578,14 +524,12 @@ __glXDispSwap_ClientInfo(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq); swaps(&req->length); - __GLX_SWAP_INT(&req->major); - __GLX_SWAP_INT(&req->minor); - __GLX_SWAP_INT(&req->numbytes); + swapl(&req->major); + swapl(&req->minor); + swapl(&req->numbytes); return __glXDisp_ClientInfo(cl, pc); } @@ -596,12 +540,10 @@ __glXDispSwap_QueryContextInfoEXT(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq); swaps(&req->length); - __GLX_SWAP_INT(&req->context); + swapl(&req->context); return __glXDisp_QueryContextInfoEXT(cl, pc); } @@ -615,8 +557,6 @@ __glXDispSwap_BindTexImageEXT(__GLXclientState * cl, GLbyte * pc) int *buffer; CARD32 *num_attribs; - __GLX_DECLARE_SWAP_VARIABLES; - if ((sizeof(xGLXVendorPrivateReq) + 12) >> 2 > client->req_len) return BadLength; @@ -627,10 +567,10 @@ __glXDispSwap_BindTexImageEXT(__GLXclientState * cl, GLbyte * pc) num_attribs = ((CARD32 *) (pc + 8)); swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(drawId); - __GLX_SWAP_INT(buffer); - __GLX_SWAP_INT(num_attribs); + swapl(&req->contextTag); + swapl(drawId); + swapl(buffer); + swapl(num_attribs); return __glXDisp_BindTexImageEXT(cl, (GLbyte *) pc); } @@ -643,8 +583,6 @@ __glXDispSwap_ReleaseTexImageEXT(__GLXclientState * cl, GLbyte * pc) GLXDrawable *drawId; int *buffer; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8); pc += __GLX_VENDPRIV_HDR_SIZE; @@ -653,9 +591,9 @@ __glXDispSwap_ReleaseTexImageEXT(__GLXclientState * cl, GLbyte * pc) buffer = ((int *) (pc + 4)); swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(drawId); - __GLX_SWAP_INT(buffer); + swapl(&req->contextTag); + swapl(drawId); + swapl(buffer); return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *) pc); } @@ -668,8 +606,6 @@ __glXDispSwap_CopySubBufferMESA(__GLXclientState * cl, GLbyte * pc) GLXDrawable *drawId; int *buffer; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20); (void) drawId; @@ -678,12 +614,12 @@ __glXDispSwap_CopySubBufferMESA(__GLXclientState * cl, GLbyte * pc) pc += __GLX_VENDPRIV_HDR_SIZE; swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(pc); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); - __GLX_SWAP_INT(pc + 12); - __GLX_SWAP_INT(pc + 16); + swapl(&req->contextTag); + swapl((CARD32*)(pc)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); + swapl((CARD32*)(pc + 12)); + swapl((CARD32*)(pc + 16)); return __glXDisp_CopySubBufferMESA(cl, pc); @@ -696,14 +632,12 @@ __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc) xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *) pc; CARD32 *data; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq); data = (CARD32 *) (req + 1); swaps(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(data); + swapl(&req->contextTag); + swapl(data); return __glXDisp_GetDrawableAttributesSGIX(cl, pc); } @@ -714,12 +648,10 @@ __glXDispSwap_GetDrawableAttributes(__GLXclientState * cl, GLbyte * pc) ClientPtr client = cl->client; xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *) pc; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq); swaps(&req->length); - __GLX_SWAP_INT(&req->drawable); + swapl(&req->drawable); return __glXDisp_GetDrawableAttributes(cl, pc); } @@ -761,12 +693,11 @@ __glXDispSwap_VendorPrivate(__GLXclientState * cl, GLbyte * pc) GLint vendorcode; __GLXdispatchVendorPrivProcPtr proc; - __GLX_DECLARE_SWAP_VARIABLES; REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateReq); req = (xGLXVendorPrivateReq *) pc; swaps(&req->length); - __GLX_SWAP_INT(&req->vendorCode); + swapl(&req->vendorCode); vendorcode = req->vendorCode; @@ -789,12 +720,11 @@ __glXDispSwap_VendorPrivateWithReply(__GLXclientState * cl, GLbyte * pc) GLint vendorcode; __GLXdispatchVendorPrivProcPtr proc; - __GLX_DECLARE_SWAP_VARIABLES; REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateWithReplyReq); req = (xGLXVendorPrivateWithReplyReq *) pc; swaps(&req->length); - __GLX_SWAP_INT(&req->vendorCode); + swapl(&req->vendorCode); vendorcode = req->vendorCode; diff --git a/glx/render2swap.c b/glx/render2swap.c index 58d43cabcf..2c206bcd5b 100644 --- a/glx/render2swap.c +++ b/glx/render2swap.c @@ -46,8 +46,8 @@ __glXDispSwap_Map1f(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 12); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 12)); __GLX_SWAP_FLOAT(pc + 4); __GLX_SWAP_FLOAT(pc + 8); @@ -81,9 +81,9 @@ __glXDispSwap_Map2f(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 12); - __GLX_SWAP_INT(pc + 24); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 12)); + swapl((CARD32*)(pc + 24)); __GLX_SWAP_FLOAT(pc + 4); __GLX_SWAP_FLOAT(pc + 8); __GLX_SWAP_FLOAT(pc + 16); @@ -126,8 +126,8 @@ __glXDispSwap_Map1d(GLbyte * pc) __GLX_SWAP_DOUBLE(pc + 0); __GLX_SWAP_DOUBLE(pc + 8); - __GLX_SWAP_INT(pc + 16); - __GLX_SWAP_INT(pc + 20); + swapl((CARD32*)(pc + 16)); + swapl((CARD32*)(pc + 20)); target = *(GLenum *) (pc + 16); order = *(GLint *) (pc + 20); @@ -176,9 +176,9 @@ __glXDispSwap_Map2d(GLbyte * pc) __GLX_SWAP_DOUBLE(pc + 8); __GLX_SWAP_DOUBLE(pc + 16); __GLX_SWAP_DOUBLE(pc + 24); - __GLX_SWAP_INT(pc + 32); - __GLX_SWAP_INT(pc + 36); - __GLX_SWAP_INT(pc + 40); + swapl((CARD32*)(pc + 32)); + swapl((CARD32*)(pc + 36)); + swapl((CARD32*)(pc + 40)); target = *(GLenum *) (pc + 32); uorder = *(GLint *) (pc + 36); @@ -248,7 +248,7 @@ swapArray(GLint numVals, GLenum datatype, GLint *pVal = (GLint *) pc; for (j = 0; j < numVals; j++) { - __GLX_SWAP_INT(&pVal[j]); + swapl(&pVal[j]); } pc += stride; } @@ -289,11 +289,9 @@ __glXDispSwap_DrawArrays(GLbyte * pc) GLint stride = 0; int i; - __GLX_DECLARE_SWAP_VARIABLES; - - __GLX_SWAP_INT(&numVertexes); - __GLX_SWAP_INT(&numComponents); - __GLX_SWAP_INT(&primType); + swapl(&numVertexes); + swapl(&numComponents); + swapl(&primType); pc += sizeof(__GLXdispatchDrawArraysHeader); compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; @@ -304,9 +302,9 @@ __glXDispSwap_DrawArrays(GLbyte * pc) GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; - __GLX_SWAP_INT(&datatype); - __GLX_SWAP_INT(&numVals); - __GLX_SWAP_INT(&component); + swapl(&datatype); + swapl(&numVals); + swapl(&component); stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); } @@ -319,9 +317,9 @@ __glXDispSwap_DrawArrays(GLbyte * pc) GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; - __GLX_SWAP_INT(&datatype); - __GLX_SWAP_INT(&numVals); - __GLX_SWAP_INT(&component); + swapl(&datatype); + swapl(&numVals); + swapl(&component); swapArray(numVals, datatype, stride, numVertexes, pc); diff --git a/glx/renderpixswap.c b/glx/renderpixswap.c index 322dc7e860..d356f7e06d 100644 --- a/glx/renderpixswap.c +++ b/glx/renderpixswap.c @@ -41,21 +41,19 @@ __glXDispSwap_SeparableFilter2D(GLbyte * pc) (__GLXdispatchConvolutionFilterHeader *) pc; GLint hdrlen, image1len; - __GLX_DECLARE_SWAP_VARIABLES; - hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE); - __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) &hdr->alignment); + swapl(&hdr->rowLength); + swapl(&hdr->skipRows); + swapl(&hdr->skipPixels); + swapl(&hdr->alignment); - __GLX_SWAP_INT((GLbyte *) &hdr->target); - __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) &hdr->width); - __GLX_SWAP_INT((GLbyte *) &hdr->height); - __GLX_SWAP_INT((GLbyte *) &hdr->format); - __GLX_SWAP_INT((GLbyte *) &hdr->type); + swapl(&hdr->target); + swapl(&hdr->internalformat); + swapl(&hdr->width); + swapl(&hdr->height); + swapl(&hdr->format); + swapl(&hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap diff --git a/glx/single2.c b/glx/single2.c index 2848f73c5f..2268cf7a60 100644 --- a/glx/single2.c +++ b/glx/single2.c @@ -328,7 +328,6 @@ DoGetString(__GLXclientState * cl, GLbyte * pc, GLboolean need_swap) GLenum name; const char *string; - __GLX_DECLARE_SWAP_VARIABLES; int error; char *buf = NULL, *buf1 = NULL; GLint length = 0; @@ -339,8 +338,8 @@ DoGetString(__GLXclientState * cl, GLbyte * pc, GLboolean need_swap) * the name. */ if (need_swap) { - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + __GLX_SINGLE_HDR_SIZE); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + __GLX_SINGLE_HDR_SIZE)); } cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); diff --git a/glx/single2swap.c b/glx/single2swap.c index 0a4ef7ecaf..545faeec28 100644 --- a/glx/single2swap.c +++ b/glx/single2swap.c @@ -42,22 +42,20 @@ __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); + swapl(&((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); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); size = *(GLsizei *) (pc + 0); type = *(GLenum *) (pc + 4); if (cx->feedbackBufSize < size) { @@ -79,20 +77,18 @@ __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); + swapl(&((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); + swapl((CARD32*)(pc + 0)); size = *(GLsizei *) (pc + 0); if (cx->selectBufSize < size) { cx->selectBuf = reallocarray(cx->selectBuf, @@ -122,14 +118,14 @@ __glXDispSwap_RenderMode(__GLXclientState * cl, GLbyte * pc) REQUEST_FIXED_SIZE(xGLXSingleReq, 4); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((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); + swapl((CARD32*)pc); newMode = *(GLenum *) pc; retval = glRenderMode(newMode); @@ -211,10 +207,10 @@ __glXDispSwap_RenderMode(__GLXclientState * cl, GLbyte * pc) .newMode = newMode }; swaps(&reply.sequenceNumber); - __GLX_SWAP_INT(&reply.length); - __GLX_SWAP_INT(&reply.retval); - __GLX_SWAP_INT(&reply.size); - __GLX_SWAP_INT(&reply.newMode); + swapl(&reply.length); + swapl(&reply.retval); + swapl(&reply.size); + swapl(&reply.newMode); WriteToClient(client, sizeof(xGLXRenderModeReply), &reply); if (retBytes) { WriteToClient(client, retBytes, retBuffer); @@ -229,11 +225,9 @@ __glXDispSwap_Flush(__GLXclientState * cl, GLbyte * pc) __GLXcontext *cx; int error; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_SIZE_MATCH(xGLXSingleReq); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; @@ -250,11 +244,9 @@ __glXDispSwap_Finish(__GLXclientState * cl, GLbyte * pc) __GLXcontext *cx; int error; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_SIZE_MATCH(xGLXSingleReq); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; diff --git a/glx/singlepixswap.c b/glx/singlepixswap.c index 0e27791452..b4f82cf8ae 100644 --- a/glx/singlepixswap.c +++ b/glx/singlepixswap.c @@ -45,7 +45,6 @@ __glXDispSwap_ReadPixels(__GLXclientState * cl, GLbyte * pc) GLboolean swapBytes, lsbFirst; GLint compsize; - __GLX_DECLARE_SWAP_VARIABLES; __GLXcontext *cx; ClientPtr client = cl->client; int error; @@ -54,19 +53,19 @@ __glXDispSwap_ReadPixels(__GLXclientState * cl, GLbyte * pc) REQUEST_FIXED_SIZE(xGLXSingleReq, 28); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((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); - __GLX_SWAP_INT(pc + 8); - __GLX_SWAP_INT(pc + 12); - __GLX_SWAP_INT(pc + 16); - __GLX_SWAP_INT(pc + 20); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); + swapl((CARD32*)(pc + 12)); + swapl((CARD32*)(pc + 16)); + swapl((CARD32*)(pc + 20)); width = *(GLsizei *) (pc + 8); height = *(GLsizei *) (pc + 12); @@ -107,7 +106,6 @@ __glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc) GLenum format, type, target; GLboolean swapBytes; - __GLX_DECLARE_SWAP_VARIABLES; __GLXcontext *cx; ClientPtr client = cl->client; int error; @@ -117,17 +115,17 @@ __glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc) REQUEST_FIXED_SIZE(xGLXSingleReq, 20); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((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); - __GLX_SWAP_INT(pc + 8); - __GLX_SWAP_INT(pc + 12); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); + swapl((CARD32*)(pc + 12)); level = *(GLint *) (pc + 4); format = *(GLenum *) (pc + 8); @@ -163,9 +161,9 @@ __glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc) else { __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); - __GLX_SWAP_INT(&width); - __GLX_SWAP_INT(&height); - __GLX_SWAP_INT(&depth); + swapl(&width); + swapl(&height); + swapl(&depth); ((xGLXGetTexImageReply *) &reply)->width = width; ((xGLXGetTexImageReply *) &reply)->height = height; ((xGLXGetTexImageReply *) &reply)->depth = depth; @@ -186,11 +184,9 @@ __glXDispSwap_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc) char *answer; xGLXSingleReply reply = { 0, }; - __GLX_DECLARE_SWAP_VARIABLES; - REQUEST_FIXED_SIZE(xGLXSingleReq, 4); - __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); + swapl(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; @@ -227,7 +223,6 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) ClientPtr client = cl->client; int error; - __GLX_DECLARE_SWAP_VARIABLES; char *answer, answerBuffer[200]; GLint width = 0, height = 0; xGLXSingleReply reply = { 0, }; @@ -237,9 +232,9 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) return error; } - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); format = *(GLenum *) (pc + 4); type = *(GLenum *) (pc + 8); @@ -276,8 +271,8 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) else { __GLX_BEGIN_REPLY(compsize + compsize2); __GLX_SWAP_REPLY_HEADER(); - __GLX_SWAP_INT(&width); - __GLX_SWAP_INT(&height); + swapl(&width); + swapl(&height); ((xGLXGetSeparableFilterReply *) &reply)->width = width; ((xGLXGetSeparableFilterReply *) &reply)->height = height; __GLX_SEND_VOID_ARRAY(compsize + compsize2); @@ -316,7 +311,6 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) ClientPtr client = cl->client; int error; - __GLX_DECLARE_SWAP_VARIABLES; char *answer, answerBuffer[200]; GLint width = 0, height = 0; xGLXSingleReply reply = { 0, }; @@ -326,9 +320,9 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) return error; } - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); format = *(GLenum *) (pc + 4); type = *(GLenum *) (pc + 8); @@ -363,8 +357,8 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) else { __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); - __GLX_SWAP_INT(&width); - __GLX_SWAP_INT(&height); + swapl(&width); + swapl(&height); ((xGLXGetConvolutionFilterReply *) &reply)->width = width; ((xGLXGetConvolutionFilterReply *) &reply)->height = height; __GLX_SEND_VOID_ARRAY(compsize); @@ -403,7 +397,6 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) ClientPtr client = cl->client; int error; - __GLX_DECLARE_SWAP_VARIABLES; char *answer, answerBuffer[200]; GLint width = 0; xGLXSingleReply reply = { 0, }; @@ -413,9 +406,9 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) return error; } - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); format = *(GLenum *) (pc + 4); type = *(GLenum *) (pc + 8); @@ -444,7 +437,7 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) else { __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); - __GLX_SWAP_INT(&width); + swapl(&width); ((xGLXGetHistogramReply *) &reply)->width = width; __GLX_SEND_VOID_ARRAY(compsize); } @@ -482,7 +475,6 @@ GetMinmax(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) ClientPtr client = cl->client; int error; - __GLX_DECLARE_SWAP_VARIABLES; char *answer, answerBuffer[200]; xGLXSingleReply reply = { 0, }; @@ -491,9 +483,9 @@ GetMinmax(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) return error; } - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); format = *(GLenum *) (pc + 4); type = *(GLenum *) (pc + 8); @@ -553,7 +545,6 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) ClientPtr client = cl->client; int error; - __GLX_DECLARE_SWAP_VARIABLES; char *answer, answerBuffer[200]; GLint width = 0; xGLXSingleReply reply = { 0, }; @@ -563,9 +554,9 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) return error; } - __GLX_SWAP_INT(pc + 0); - __GLX_SWAP_INT(pc + 4); - __GLX_SWAP_INT(pc + 8); + swapl((CARD32*)(pc + 0)); + swapl((CARD32*)(pc + 4)); + swapl((CARD32*)(pc + 8)); format = *(GLenum *) (pc + 4); type = *(GLenum *) (pc + 8); @@ -594,7 +585,7 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) else { __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); - __GLX_SWAP_INT(&width); + swapl(&width); ((xGLXGetColorTableReply *) &reply)->width = width; __GLX_SEND_VOID_ARRAY(compsize); } diff --git a/glx/unpack.h b/glx/unpack.h index cf559d7cc8..ac19b88285 100644 --- a/glx/unpack.h +++ b/glx/unpack.h @@ -122,14 +122,6 @@ GLbyte *swapPC; \ GLbyte *swapEnd -#define __GLX_SWAP_INT(pc) \ - sw = ((GLbyte *)(pc))[0]; \ - ((GLbyte *)(pc))[0] = ((GLbyte *)(pc))[3]; \ - ((GLbyte *)(pc))[3] = sw; \ - sw = ((GLbyte *)(pc))[1]; \ - ((GLbyte *)(pc))[1] = ((GLbyte *)(pc))[2]; \ - ((GLbyte *)(pc))[2] = sw; - #define __GLX_SWAP_DOUBLE(pc) \ sw = ((GLbyte *)(pc))[0]; \ ((GLbyte *)(pc))[0] = ((GLbyte *)(pc))[7]; \ @@ -170,12 +162,12 @@ #define __GLX_SWAP_REPLY_HEADER() \ swaps(&reply.sequenceNumber); \ - __GLX_SWAP_INT(&reply.length); + swapl(&reply.length); #define __GLX_SWAP_REPLY_RETVAL() \ - __GLX_SWAP_INT(&reply.retval) + swpal(&reply.retval) #define __GLX_SWAP_REPLY_SIZE() \ - __GLX_SWAP_INT(&reply.size) + swapl(&reply.size) #endif /* !__GLX_unpack_h__ */