hashirama/xserver
Watch
0
0
Fork
You've already forked xserver
 0
mirror of https://github.com/X11Libre/xserver.git synced 2026-09-29 21:46:40 +00:00
Code Issues Projects Releases Wiki Activity

Fix formatting of address operators

Browse source 
The formatter confused address operators preceded by casts with
bitwise-and expressions, placing spaces on either side of both.
That syntax isn't used by ordinary address operators, however,
so fix them for consistency.

Signed-off-by: Yaakov Selkowitz <yselkowitz@users.sourceforge.net>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Yaakov Selkowitz 2012-11-05 23:50:58 -06:00
commit ea1d76d1b6
68 changed files with 338 additions and 338 deletions
Download patch file Download diff file Expand all files Collapse all files

4
hw/dmx/config/Canvas.c
View file

@ -76,7 +76,7 @@ CanvasExpose(Widget w, XEvent * event, Region region)
if (!XtIsRealized(w))
return;
XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) & data);
XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) &data);
}
static void
@ -162,4 +162,4 @@ CanvasClassRec canvasClassRec = {
}
};
WidgetClass canvasWidgetClass = (WidgetClass) & canvasClassRec;
WidgetClass canvasWidgetClass = (WidgetClass) &canvasClassRec;

4
hw/dmx/dmx_glxvisuals.c
View file

@ -61,7 +61,7 @@ GetGLXVisualConfigs(Display * dpy, int screen, int *nconfigs)
req->reqType = majorOpcode;
req->glxCode = X_GLXGetVisualConfigs;
req->screen = screen;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
/* Something is busted. Punt. */
UnlockDisplay(dpy);
SyncHandle();
@ -252,7 +252,7 @@ GetGLXFBConfigs(Display * dpy, int glxMajorOpcode, int *nconfigs)
*nconfigs = 0;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
/* Something is busted. Punt. */
UnlockDisplay(dpy);
SyncHandle();

2
hw/dmx/dmxwindow.c
View file

@ -786,7 +786,7 @@ dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
if (pWinPriv->window) {
while (XCheckIfEvent(dmxScreen->beDisplay, &ev,
dmxWindowExposurePredicate,
(XPointer) & pWinPriv->window)) {
(XPointer) &pWinPriv->window)) {
/* Handle expose events -- this should not be necessary
since the base window in which the root window was
created is guaranteed to be on top (override_redirect),

4
hw/dmx/examples/xinput.c
View file

@ -303,8 +303,8 @@ main(int argc, char **argv)
XNextEvent(display, &event);
for (i = 0; i < cnt; i++) {
XDeviceMotionEvent *e = (XDeviceMotionEvent *) & event;
XDeviceButtonEvent *b = (XDeviceButtonEvent *) & event;
XDeviceMotionEvent *e = (XDeviceMotionEvent *) &event;
XDeviceButtonEvent *b = (XDeviceButtonEvent *) &event;
if (event.type == event_type[i]) {
printf("%s id=%lu (%d @ %d,%d; s=0x%04x, d=%d, t=%lu)"

16
hw/dmx/glxProxy/glxcmds.c
View file

@ -1276,7 +1276,7 @@ MakeCurrent(__GLXclientState * cl,
be_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) & be_reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
@ -1331,7 +1331,7 @@ MakeCurrent(__GLXclientState * cl,
be_new_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) & be_new_reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
@ -1362,7 +1362,7 @@ MakeCurrent(__GLXclientState * cl,
ext_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) & ext_reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
@ -2177,7 +2177,7 @@ __glXDoSwapBuffers(__GLXclientState * cl, XID drawId, GLXContextTag tag)
finishReq->glxCode = X_GLsop_Finish;
finishReq->contextTag =
(tag ? GetCurrentBackEndTag(cl, tag, s) : 0);
(void) _XReply(dpy, (xReply *) & reply, 0, False);
(void) _XReply(dpy, (xReply *) &reply, 0, False);
UnlockDisplay(dpy);
SyncHandle();
}
@ -2605,7 +2605,7 @@ __glXQueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy);
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
len = (int) be_reply.length;
numbytes = (int) be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3;
@ -2690,7 +2690,7 @@ __glXQueryServerString(__GLXclientState * cl, GLbyte * pc)
be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy);
be_req->name = name;
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
len = (int) be_reply.length;
numbytes = (int) be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3;
@ -3045,7 +3045,7 @@ __glXGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
new_req.length = req->length;
new_req.screen = req->screen;
return (__glXGetFBConfigs(cl, (GLbyte *) & new_req));
return (__glXGetFBConfigs(cl, (GLbyte *) &new_req));
}
int
@ -3591,7 +3591,7 @@ __glXGetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
be_req->glxCode = X_GLXGetDrawableAttributes;
be_req->drawable = be_drawable;
be_req->length = req->length;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
UnlockDisplay(dpy);
SyncHandle();
return (BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code));

2
hw/dmx/glxProxy/glxcmdsswap.c
View file

@ -1051,7 +1051,7 @@ __glXSwapGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
new_req.length = req->length;
new_req.screen = req->screen;
return (__glXSwapGetFBConfigs(cl, (GLbyte *) & new_req));
return (__glXSwapGetFBConfigs(cl, (GLbyte *) &new_req));
}
int

4
hw/dmx/glxProxy/glxscreens.c
View file

@ -88,7 +88,7 @@ CalcServerVersionAndExtensions(void)
req->glxCode = X_GLXQueryVersion;
req->majorVersion = GLX_SERVER_MAJOR_VERSION;
req->minorVersion = GLX_SERVER_MINOR_VERSION;
_XReply(dpy, (xReply *) & reply, 0, False);
_XReply(dpy, (xReply *) &reply, 0, False);
UnlockDisplay(dpy);
SyncHandle();
@ -147,7 +147,7 @@ CalcServerVersionAndExtensions(void)
req->glxCode = X_GLXQueryServerString;
req->screen = DefaultScreen(dpy);
req->name = GLX_EXTENSIONS;
_XReply(dpy, (xReply *) & reply, 0, False);
_XReply(dpy, (xReply *) &reply, 0, False);
length = (int) reply.length;
numbytes = (int) reply.n;

6
hw/dmx/glxProxy/glxsingle.c
View file

@ -249,7 +249,7 @@ __glXForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size);
@ -348,7 +348,7 @@ __glXForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size);
@ -919,7 +919,7 @@ __glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc)
*(GLboolean *) (be_pc + 24) = swapBytes;
*(GLboolean *) (be_pc + 25) = lsbFirst;
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
if (be_reply.length > 0) {
char *be_buf;

4
hw/dmx/glxProxy/glxvendor.c
View file

@ -237,7 +237,7 @@ __glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size);
@ -331,7 +331,7 @@ __glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) & be_reply, 0, False);
_XReply(dpy, (xReply *) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size);

304
hw/dmx/glxProxy/renderpixswap.c
View file

@ -39,10 +39,10 @@ __glXDispSwap_PolygonStipple(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
hdr->swapBytes = !hdr->swapBytes;
}
@ -54,17 +54,17 @@ __glXDispSwap_Bitmap(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->xorig);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->yorig);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->xmove);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->ymove);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_FLOAT((GLbyte *) &hdr->xorig);
__GLX_SWAP_FLOAT((GLbyte *) &hdr->yorig);
__GLX_SWAP_FLOAT((GLbyte *) &hdr->xmove);
__GLX_SWAP_FLOAT((GLbyte *) &hdr->ymove);
hdr->swapBytes = !hdr->swapBytes;
@ -77,19 +77,19 @@ __glXDispSwap_TexImage1D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->components);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->components);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -105,19 +105,19 @@ __glXDispSwap_TexImage2D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->components);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->components);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -133,25 +133,25 @@ __glXDispSwap_TexImage3D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) & hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->depth);
__GLX_SWAP_INT((GLbyte *) & hdr->size4d);
__GLX_SWAP_INT((GLbyte *) & hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->depth);
__GLX_SWAP_INT((GLbyte *) &hdr->size4d);
__GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -167,15 +167,15 @@ __glXDispSwap_DrawPixels(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -191,17 +191,17 @@ __glXDispSwap_TexSubImage1D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -217,19 +217,19 @@ __glXDispSwap_TexSubImage2D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -246,26 +246,26 @@ __glXDispSwap_TexSubImage3D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) & hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->zoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->depth);
__GLX_SWAP_INT((GLbyte *) & hdr->size4d);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->zoffset);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) &hdr->depth);
__GLX_SWAP_INT((GLbyte *) &hdr->size4d);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -281,16 +281,16 @@ __glXDispSwap_ColorTable(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &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->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -306,16 +306,16 @@ __glXDispSwap_ColorSubTable(GLbyte * pc)
(__GLXdispatchColorSubTableHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->start);
__GLX_SWAP_INT((GLbyte *) & hdr->count);
__GLX_SWAP_INT((GLbyte *) & hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->start);
__GLX_SWAP_INT((GLbyte *) &hdr->count);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -331,16 +331,16 @@ __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
(__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &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->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type);
__GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) &hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -356,17 +356,17 @@ __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
(__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &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);
__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);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -386,17 +386,17 @@ __glXDispSwap_SeparableFilter2D(GLbyte * pc)
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);
__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) &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);
__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);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap