XLibre/xserver
1
1
Fork 0
mirror of https://github.com/X11Libre/xserver.git synced 2026-03-24 03:44:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

glx: replace __GLX_SWAP_INT() by swapl()

Browse Source 
We have an optimized function for this, so use it.
This commit is contained in:
Enrico Weigelt, metux IT consult
2025-09-02 16:08:11 +02:00
committed by Enrico Weigelt
parent d438dfc677
commit c339338277
8 changed files with 199 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
glx/glxcmds.c
View File

@@ -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);

260
glx/glxcmdsswap.c
View File

@@ -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;

42
glx/render2swap.c
View File

@@ -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);

22
glx/renderpixswap.c
View File

@@ -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

5
glx/single2.c
View File

@@ -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);

34
glx/single2swap.c
View File

@@ -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;

83
glx/singlepixswap.c
View File

@@ -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);
}

14
glx/unpack.h
View File

@@ -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__ */