frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix formatting of address operators 

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
parent b51a1bd276
commit ea1d76d1b6
68 changed files with 335 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Xext/saver.c
View File

@ -837,7 +837,7 @@ ScreenSaverSetAttributes(ClientPtr client)
if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) { if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) {
fOK = FALSE; fOK = FALSE;
for (idepth = 0; idepth < pScreen->numDepths; idepth++) { for (idepth = 0; idepth < pScreen->numDepths; idepth++) {
pDepth = (DepthPtr) & pScreen->allowedDepths[idepth]; pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
if ((depth == pDepth->depth) || (depth == 0)) { if ((depth == pDepth->depth) || (depth == 0)) {
for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) { for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) {
if (visual == pDepth->vids[ivisual]) { if (visual == pDepth->vids[ivisual]) {

6
Xi/extinit.c
View File

@ -646,7 +646,7 @@ SDeviceChangedEvent(xXIDeviceChangedEvent * from, xXIDeviceChangedEvent * to)
*to = *from; *to = *from;
memcpy(&to[1], &from[1], from->length * 4); memcpy(&to[1], &from[1], from->length * 4);
any = (xXIAnyInfo *) & to[1]; any = (xXIAnyInfo *) &to[1];
for (i = 0; i < to->num_classes; i++) { for (i = 0; i < to->num_classes; i++) {
int length = any->length; int length = any->length;
@ -654,7 +654,7 @@ SDeviceChangedEvent(xXIDeviceChangedEvent * from, xXIDeviceChangedEvent * to)
case KeyClass: case KeyClass:
{ {
xXIKeyInfo *ki = (xXIKeyInfo *) any; xXIKeyInfo *ki = (xXIKeyInfo *) any;
uint32_t *key = (uint32_t *) & ki[1]; uint32_t *key = (uint32_t *) &ki[1];
for (j = 0; j < ki->num_keycodes; j++, key++) for (j = 0; j < ki->num_keycodes; j++, key++)
swapl(key); swapl(key);
@ -765,7 +765,7 @@ SDeviceHierarchyEvent(xXIHierarchyEvent * from, xXIHierarchyEvent * to)
swapl(&to->flags); swapl(&to->flags);
swaps(&to->num_info); swaps(&to->num_info);
info = (xXIHierarchyInfo *) & to[1]; info = (xXIHierarchyInfo *) &to[1];
for (i = 0; i < from->num_info; i++) { for (i = 0; i < from->num_info; i++) {
swaps(&info->deviceid); swaps(&info->deviceid);
swaps(&info->attachment); swaps(&info->attachment);

2
Xi/gtmotion.c
View File

@ -131,7 +131,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
num_events = v->numMotionEvents; num_events = v->numMotionEvents;
if (num_events) { if (num_events) {
size = sizeof(Time) + (axes * sizeof(INT32)); size = sizeof(Time) + (axes * sizeof(INT32));
rep.nEvents = GetMotionHistory(dev, (xTimecoord **) & coords, /* XXX */ rep.nEvents = GetMotionHistory(dev, (xTimecoord **) &coords, /* XXX */
start.milliseconds, stop.milliseconds, start.milliseconds, stop.milliseconds,
(ScreenPtr) NULL, FALSE); (ScreenPtr) NULL, FALSE);
} }

2
Xi/xichangehierarchy.c
View File

@ -79,7 +79,7 @@ XISendDeviceHierarchyEvent(int flags[MAXDEVICES])
ev->flags = 0; ev->flags = 0;
ev->num_info = inputInfo.numDevices; ev->num_info = inputInfo.numDevices;
info = (xXIHierarchyInfo *) & ev[1]; info = (xXIHierarchyInfo *) &ev[1];
for (dev = inputInfo.devices; dev; dev = dev->next) { for (dev = inputInfo.devices; dev; dev = dev->next) {
info->deviceid = dev->id; info->deviceid = dev->id;
info->enabled = dev->enabled; info->enabled = dev->enabled;

4
Xi/xiquerydevice.c
View File

@ -304,7 +304,7 @@ ListKeyInfo(DeviceIntPtr dev, xXIKeyInfo * info)
info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes; info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes;
info->sourceid = dev->key->sourceid; info->sourceid = dev->key->sourceid;
kc = (uint32_t *) & info[1]; kc = (uint32_t *) &info[1];
for (i = xkb->min_key_code; i <= xkb->max_key_code; i++, kc++) for (i = xkb->min_key_code; i <= xkb->max_key_code; i++, kc++)
*kc = i; *kc = i;
@ -321,7 +321,7 @@ SwapKeyInfo(DeviceIntPtr dev, xXIKeyInfo * info)
swaps(&info->length); swaps(&info->length);
swaps(&info->sourceid); swaps(&info->sourceid);
for (i = 0, key = (uint32_t *) & info[1]; i < info->num_keycodes; for (i = 0, key = (uint32_t *) &info[1]; i < info->num_keycodes;
i++, key++) i++, key++)
swapl(key); swapl(key);

8
dix/colormap.c
View File

@ -658,15 +658,15 @@ FreeCell(ColormapPtr pmap, Pixel i, int channel)
default: /* so compiler can see that everything gets initialized */ default: /* so compiler can see that everything gets initialized */
case PSEUDOMAP: case PSEUDOMAP:
case REDMAP: case REDMAP:
pent = (EntryPtr) & pmap->red[i]; pent = (EntryPtr) &pmap->red[i];
pCount = &pmap->freeRed; pCount = &pmap->freeRed;
break; break;
case GREENMAP: case GREENMAP:
pent = (EntryPtr) & pmap->green[i]; pent = (EntryPtr) &pmap->green[i];
pCount = &pmap->freeGreen; pCount = &pmap->freeGreen;
break; break;
case BLUEMAP: case BLUEMAP:
pent = (EntryPtr) & pmap->blue[i]; pent = (EntryPtr) &pmap->blue[i];
pCount = &pmap->freeBlue; pCount = &pmap->freeBlue;
break; break;
} }
@ -1400,7 +1400,7 @@ QueryColors(ColormapPtr pmap, int count, Pixel * ppixIn, xrgb * prgbList,
errVal = BadValue; errVal = BadValue;
} }
else { else {
pent = (EntryPtr) & pmap->red[pixel]; pent = (EntryPtr) &pmap->red[pixel];
if (pent->fShared) { if (pent->fShared) {
prgb->red = pent->co.shco.red->color; prgb->red = pent->co.shco.red->color;
prgb->green = pent->co.shco.green->color; prgb->green = pent->co.shco.green->color;

4
dix/devices.c
View File

@ -283,7 +283,7 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart)
dev->coreEvents = TRUE; dev->coreEvents = TRUE;
/* sprite defaults */ /* sprite defaults */
dev->spriteInfo = (SpriteInfoPtr) & dev[1]; dev->spriteInfo = (SpriteInfoPtr) &dev[1];
/* security creation/labeling check /* security creation/labeling check
*/ */
@ -944,7 +944,7 @@ CloseDevice(DeviceIntPtr dev)
free(dev->name); free(dev->name);
classes = (ClassesPtr) & dev->key; classes = (ClassesPtr) &dev->key;
FreeAllDeviceClasses(classes); FreeAllDeviceClasses(classes);
if (IsMaster(dev)) { if (IsMaster(dev)) {

2
dix/dispatch.c
View File

@ -2454,7 +2454,7 @@ ProcListInstalledColormaps(ClientPtr client)
preply->type = X_Reply; preply->type = X_Reply;
preply->sequenceNumber = client->sequence; preply->sequenceNumber = client->sequence;
nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps) nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps)
(pWin->drawable.pScreen, (Colormap *) & preply[1]); (pWin->drawable.pScreen, (Colormap *) &preply[1]);
preply->nColormaps = nummaps; preply->nColormaps = nummaps;
preply->length = nummaps; preply->length = nummaps;
WriteReplyToClient(client, sizeof(xListInstalledColormapsReply), preply); WriteReplyToClient(client, sizeof(xListInstalledColormapsReply), preply);

2
dix/eventconvert.c
View File

@ -451,7 +451,7 @@ appendKeyInfo(DeviceChangedEvent *dce, xXIKeyInfo * info)
info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes; info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes;
info->sourceid = dce->sourceid; info->sourceid = dce->sourceid;
kc = (uint32_t *) & info[1]; kc = (uint32_t *) &info[1];
for (i = 0; i < info->num_keycodes; i++) for (i = 0; i < info->num_keycodes; i++)
*kc++ = i + dce->keys.min_keycode; *kc++ = i + dce->keys.min_keycode;

2
dix/window.c
View File

@ -680,7 +680,7 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w,
if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) { if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) {
fOK = FALSE; fOK = FALSE;
for (idepth = 0; idepth < pScreen->numDepths; idepth++) { for (idepth = 0; idepth < pScreen->numDepths; idepth++) {
pDepth = (DepthPtr) & pScreen->allowedDepths[idepth]; pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
if ((depth == pDepth->depth) || (depth == 0)) { if ((depth == pDepth->depth) || (depth == 0)) {
for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) { for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) {
if (visual == pDepth->vids[ivisual]) { if (visual == pDepth->vids[ivisual]) {

4
exa/exa.c
View File

@ -620,8 +620,8 @@ exaCreateGC(GCPtr pGC)
swap(pExaScr, pScreen, CreateGC); swap(pExaScr, pScreen, CreateGC);
if ((ret = (*pScreen->CreateGC) (pGC))) { if ((ret = (*pScreen->CreateGC) (pGC))) {
wrap(pExaGC, pGC, funcs, (GCFuncs *) & exaGCFuncs); wrap(pExaGC, pGC, funcs, (GCFuncs *) &exaGCFuncs);
wrap(pExaGC, pGC, ops, (GCOps *) & exaOps); wrap(pExaGC, pGC, ops, (GCOps *) &exaOps);
} }
swap(pExaScr, pScreen, CreateGC); swap(pExaScr, pScreen, CreateGC);

4
fb/fbgc.c
View File

@ -64,8 +64,8 @@ const GCOps fbGCOps = {
Bool Bool
fbCreateGC(GCPtr pGC) fbCreateGC(GCPtr pGC)
{ {
pGC->ops = (GCOps *) & fbGCOps; pGC->ops = (GCOps *) &fbGCOps;
pGC->funcs = (GCFuncs *) & fbGCFuncs; pGC->funcs = (GCFuncs *) &fbGCFuncs;
/* fb wants to translate before scan conversion */ /* fb wants to translate before scan conversion */
pGC->miTranslate = 1; pGC->miTranslate = 1;

2
glx/glapi.c
View File

@ -490,7 +490,7 @@ init_glapi_relocs(void)
char run_time_patch[] = { char run_time_patch[] = {
0x65, 0xa1, 0, 0, 0, 0 /* movl %gs:0,%eax */ 0x65, 0xa1, 0, 0, 0, 0 /* movl %gs:0,%eax */
}; };
GLuint *offset = (GLuint *) & run_time_patch[2]; /* 32-bits for x86/32 */ GLuint *offset = (GLuint *) &run_time_patch[2]; /* 32-bits for x86/32 */
const GLubyte *const get_disp = (const GLubyte *) run_time_patch; const GLubyte *const get_disp = (const GLubyte *) run_time_patch;
GLubyte *curr_func = (GLubyte *) gl_dispatch_functions_start; GLubyte *curr_func = (GLubyte *) gl_dispatch_functions_start;

2
glx/glxdri.c
View File

@ -1069,7 +1069,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
/* Map the framebuffer region. */ /* Map the framebuffer region. */
status = drmMap(fd, hFB, framebuffer.size, status = drmMap(fd, hFB, framebuffer.size,
(drmAddressPtr) & framebuffer.base); (drmAddressPtr) &framebuffer.base);
if (status != 0) { if (status != 0) {
LogMessage(X_ERROR, "AIGLX error: drmMap of framebuffer failed (%s)\n", LogMessage(X_ERROR, "AIGLX error: drmMap of framebuffer failed (%s)\n",
strerror(-status)); strerror(-status));

2
glx/indirect_program.c
View File

@ -109,7 +109,7 @@ DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *) & __glXReply)->width = compsize; ((xGLXGetTexImageReply *) &__glXReply)->width = compsize;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }

4
glx/indirect_texture_compression.c
View File

@ -72,7 +72,7 @@ __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *cl, GLbyte * pc)
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *) & __glXReply)->width = compsize; ((xGLXGetTexImageReply *) &__glXReply)->width = compsize;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -118,7 +118,7 @@ __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *cl,
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *) & __glXReply)->width = compsize; ((xGLXGetTexImageReply *) &__glXReply)->width = compsize;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }

20
glx/renderpixswap.c
View File

@ -51,17 +51,17 @@ __glXDispSwap_SeparableFilter2D(GLbyte * pc)
hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE); hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** Just invert swapBytes flag; the GL will figure out if it needs to swap

18
glx/singlepix.c
View File

@ -150,9 +150,9 @@ __glXDisp_GetTexImage(__GLXclientState * cl, GLbyte * pc)
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *) & __glXReply)->width = width; ((xGLXGetTexImageReply *) &__glXReply)->width = width;
((xGLXGetTexImageReply *) & __glXReply)->height = height; ((xGLXGetTexImageReply *) &__glXReply)->height = height;
((xGLXGetTexImageReply *) & __glXReply)->depth = depth; ((xGLXGetTexImageReply *) &__glXReply)->depth = depth;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -252,8 +252,8 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
} }
else { else {
__GLX_BEGIN_REPLY(compsize + compsize2); __GLX_BEGIN_REPLY(compsize + compsize2);
((xGLXGetSeparableFilterReply *) & __glXReply)->width = width; ((xGLXGetSeparableFilterReply *) &__glXReply)->width = width;
((xGLXGetSeparableFilterReply *) & __glXReply)->height = height; ((xGLXGetSeparableFilterReply *) &__glXReply)->height = height;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize + compsize2); __GLX_SEND_VOID_ARRAY(compsize + compsize2);
} }
@ -330,8 +330,8 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetConvolutionFilterReply *) & __glXReply)->width = width; ((xGLXGetConvolutionFilterReply *) &__glXReply)->width = width;
((xGLXGetConvolutionFilterReply *) & __glXReply)->height = height; ((xGLXGetConvolutionFilterReply *) &__glXReply)->height = height;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -399,7 +399,7 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetHistogramReply *) & __glXReply)->width = width; ((xGLXGetHistogramReply *) &__glXReply)->width = width;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -528,7 +528,7 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
} }
else { else {
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
((xGLXGetColorTableReply *) & __glXReply)->width = width; ((xGLXGetColorTableReply *) &__glXReply)->width = width;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }

18
glx/singlepixswap.c
View File

@ -176,9 +176,9 @@ __glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&width); __GLX_SWAP_INT(&width);
__GLX_SWAP_INT(&height); __GLX_SWAP_INT(&height);
__GLX_SWAP_INT(&depth); __GLX_SWAP_INT(&depth);
((xGLXGetTexImageReply *) & __glXReply)->width = width; ((xGLXGetTexImageReply *) &__glXReply)->width = width;
((xGLXGetTexImageReply *) & __glXReply)->height = height; ((xGLXGetTexImageReply *) &__glXReply)->height = height;
((xGLXGetTexImageReply *) & __glXReply)->depth = depth; ((xGLXGetTexImageReply *) &__glXReply)->depth = depth;
__GLX_SEND_HEADER(); __GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -290,8 +290,8 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
__GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width); __GLX_SWAP_INT(&width);
__GLX_SWAP_INT(&height); __GLX_SWAP_INT(&height);
((xGLXGetSeparableFilterReply *) & __glXReply)->width = width; ((xGLXGetSeparableFilterReply *) &__glXReply)->width = width;
((xGLXGetSeparableFilterReply *) & __glXReply)->height = height; ((xGLXGetSeparableFilterReply *) &__glXReply)->height = height;
__GLX_SEND_VOID_ARRAY(compsize + compsize2); __GLX_SEND_VOID_ARRAY(compsize + compsize2);
} }
@ -376,8 +376,8 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
__GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width); __GLX_SWAP_INT(&width);
__GLX_SWAP_INT(&height); __GLX_SWAP_INT(&height);
((xGLXGetConvolutionFilterReply *) & __glXReply)->width = width; ((xGLXGetConvolutionFilterReply *) &__glXReply)->width = width;
((xGLXGetConvolutionFilterReply *) & __glXReply)->height = height; ((xGLXGetConvolutionFilterReply *) &__glXReply)->height = height;
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -452,7 +452,7 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
__GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width); __GLX_SWAP_INT(&width);
((xGLXGetHistogramReply *) & __glXReply)->width = width; ((xGLXGetHistogramReply *) &__glXReply)->width = width;
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }
@ -594,7 +594,7 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
__GLX_BEGIN_REPLY(compsize); __GLX_BEGIN_REPLY(compsize);
__GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width); __GLX_SWAP_INT(&width);
((xGLXGetColorTableReply *) & __glXReply)->width = width; ((xGLXGetColorTableReply *) &__glXReply)->width = width;
__GLX_SEND_VOID_ARRAY(compsize); __GLX_SEND_VOID_ARRAY(compsize);
} }

2
glx/xfont.c
View File

@ -168,7 +168,7 @@ __glXDisp_UseXFont(__GLXclientState * cl, GLbyte * pc)
} }
CALL_GetIntegerv(GET_DISPATCH(), CALL_GetIntegerv(GET_DISPATCH(),
(GL_LIST_INDEX, (GLint *) & currentListIndex)); (GL_LIST_INDEX, (GLint *) &currentListIndex));
if (currentListIndex != 0) { if (currentListIndex != 0) {
/* /*
** A display list is currently being made. It is an error ** A display list is currently being made. It is an error

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

@ -76,7 +76,7 @@ CanvasExpose(Widget w, XEvent * event, Region region)
if (!XtIsRealized(w)) if (!XtIsRealized(w))
return; return;
XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) & data); XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) &data);
} }
static void 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->reqType = majorOpcode;
req->glxCode = X_GLXGetVisualConfigs; req->glxCode = X_GLXGetVisualConfigs;
req->screen = screen; req->screen = screen;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
/* Something is busted. Punt. */ /* Something is busted. Punt. */
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
@ -252,7 +252,7 @@ GetGLXFBConfigs(Display * dpy, int glxMajorOpcode, int *nconfigs)
*nconfigs = 0; *nconfigs = 0;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
/* Something is busted. Punt. */ /* Something is busted. Punt. */
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();

2
hw/dmx/dmxwindow.c
View File

@ -786,7 +786,7 @@ dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
if (pWinPriv->window) { if (pWinPriv->window) {
while (XCheckIfEvent(dmxScreen->beDisplay, &ev, while (XCheckIfEvent(dmxScreen->beDisplay, &ev,
dmxWindowExposurePredicate, dmxWindowExposurePredicate,
(XPointer) & pWinPriv->window)) { (XPointer) &pWinPriv->window)) {
/* Handle expose events -- this should not be necessary /* Handle expose events -- this should not be necessary
since the base window in which the root window was since the base window in which the root window was
created is guaranteed to be on top (override_redirect), 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); XNextEvent(display, &event);
for (i = 0; i < cnt; i++) { for (i = 0; i < cnt; i++) {
XDeviceMotionEvent *e = (XDeviceMotionEvent *) & event; XDeviceMotionEvent *e = (XDeviceMotionEvent *) &event;
XDeviceButtonEvent *b = (XDeviceButtonEvent *) & event; XDeviceButtonEvent *b = (XDeviceButtonEvent *) &event;
if (event.type == event_type[i]) { if (event.type == event_type[i]) {
printf("%s id=%lu (%d @ %d,%d; s=0x%04x, d=%d, t=%lu)" 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 = be_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); 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 */ /* The make current failed */
UnlockDisplay(dpy); UnlockDisplay(dpy);
@ -1331,7 +1331,7 @@ MakeCurrent(__GLXclientState * cl,
be_new_req->context = be_new_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); 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 */ /* The make current failed */
UnlockDisplay(dpy); UnlockDisplay(dpy);
@ -1362,7 +1362,7 @@ MakeCurrent(__GLXclientState * cl,
ext_req->context = ext_req->context =
(unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0);
ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); 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 */ /* The make current failed */
UnlockDisplay(dpy); UnlockDisplay(dpy);
@ -2177,7 +2177,7 @@ __glXDoSwapBuffers(__GLXclientState * cl, XID drawId, GLXContextTag tag)
finishReq->glxCode = X_GLsop_Finish; finishReq->glxCode = X_GLsop_Finish;
finishReq->contextTag = finishReq->contextTag =
(tag ? GetCurrentBackEndTag(cl, tag, s) : 0); (tag ? GetCurrentBackEndTag(cl, tag, s) : 0);
(void) _XReply(dpy, (xReply *) & reply, 0, False); (void) _XReply(dpy, (xReply *) &reply, 0, False);
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
} }
@ -2605,7 +2605,7 @@ __glXQueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
be_req->reqType = dmxScreen->glxMajorOpcode; be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXQueryServerString; be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy); be_req->screen = DefaultScreen(dpy);
_XReply(dpy, (xReply *) & be_reply, 0, False); _XReply(dpy, (xReply *) &be_reply, 0, False);
len = (int) be_reply.length; len = (int) be_reply.length;
numbytes = (int) be_reply.n; numbytes = (int) be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3; slop = numbytes * __GLX_SIZE_INT8 & 3;
@ -2690,7 +2690,7 @@ __glXQueryServerString(__GLXclientState * cl, GLbyte * pc)
be_req->glxCode = X_GLXQueryServerString; be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy); be_req->screen = DefaultScreen(dpy);
be_req->name = name; be_req->name = name;
_XReply(dpy, (xReply *) & be_reply, 0, False); _XReply(dpy, (xReply *) &be_reply, 0, False);
len = (int) be_reply.length; len = (int) be_reply.length;
numbytes = (int) be_reply.n; numbytes = (int) be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3; slop = numbytes * __GLX_SIZE_INT8 & 3;
@ -3045,7 +3045,7 @@ __glXGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
new_req.length = req->length; new_req.length = req->length;
new_req.screen = req->screen; new_req.screen = req->screen;
return (__glXGetFBConfigs(cl, (GLbyte *) & new_req)); return (__glXGetFBConfigs(cl, (GLbyte *) &new_req));
} }
int int
@ -3591,7 +3591,7 @@ __glXGetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
be_req->glxCode = X_GLXGetDrawableAttributes; be_req->glxCode = X_GLXGetDrawableAttributes;
be_req->drawable = be_drawable; be_req->drawable = be_drawable;
be_req->length = req->length; be_req->length = req->length;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
return (BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code)); 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.length = req->length;
new_req.screen = req->screen; new_req.screen = req->screen;
return (__glXSwapGetFBConfigs(cl, (GLbyte *) & new_req)); return (__glXSwapGetFBConfigs(cl, (GLbyte *) &new_req));
} }
int int

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

@ -88,7 +88,7 @@ CalcServerVersionAndExtensions(void)
req->glxCode = X_GLXQueryVersion; req->glxCode = X_GLXQueryVersion;
req->majorVersion = GLX_SERVER_MAJOR_VERSION; req->majorVersion = GLX_SERVER_MAJOR_VERSION;
req->minorVersion = GLX_SERVER_MINOR_VERSION; req->minorVersion = GLX_SERVER_MINOR_VERSION;
_XReply(dpy, (xReply *) & reply, 0, False); _XReply(dpy, (xReply *) &reply, 0, False);
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
@ -147,7 +147,7 @@ CalcServerVersionAndExtensions(void)
req->glxCode = X_GLXQueryServerString; req->glxCode = X_GLXQueryServerString;
req->screen = DefaultScreen(dpy); req->screen = DefaultScreen(dpy);
req->name = GLX_EXTENSIONS; req->name = GLX_EXTENSIONS;
_XReply(dpy, (xReply *) & reply, 0, False); _XReply(dpy, (xReply *) &reply, 0, False);
length = (int) reply.length; length = (int) reply.length;
numbytes = (int) reply.n; 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 * 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; be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) { if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size); be_buf = (char *) malloc(be_buf_size);
@ -348,7 +348,7 @@ __glXForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
/* /*
* get the reply from the back-end server * 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; be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) { if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size); 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 + 24) = swapBytes;
*(GLboolean *) (be_pc + 25) = lsbFirst; *(GLboolean *) (be_pc + 25) = lsbFirst;
_XReply(dpy, (xReply *) & be_reply, 0, False); _XReply(dpy, (xReply *) &be_reply, 0, False);
if (be_reply.length > 0) { if (be_reply.length > 0) {
char *be_buf; 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 * 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; be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) { if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size); be_buf = (char *) malloc(be_buf_size);
@ -331,7 +331,7 @@ __glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
/* /*
* get the reply from the back-end server * 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; be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) { if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size); 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
hdr->swapBytes = !hdr->swapBytes; hdr->swapBytes = !hdr->swapBytes;
} }
@ -54,17 +54,17 @@ __glXDispSwap_Bitmap(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->xorig); __GLX_SWAP_FLOAT((GLbyte *) &hdr->xorig);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->yorig); __GLX_SWAP_FLOAT((GLbyte *) &hdr->yorig);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->xmove); __GLX_SWAP_FLOAT((GLbyte *) &hdr->xmove);
__GLX_SWAP_FLOAT((GLbyte *) & hdr->ymove); __GLX_SWAP_FLOAT((GLbyte *) &hdr->ymove);
hdr->swapBytes = !hdr->swapBytes; hdr->swapBytes = !hdr->swapBytes;
@ -77,19 +77,19 @@ __glXDispSwap_TexImage1D(GLbyte * pc)
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->components); __GLX_SWAP_INT((GLbyte *) &hdr->components);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->border); __GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->components); __GLX_SWAP_INT((GLbyte *) &hdr->components);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->border); __GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->imageHeight); __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) & hdr->imageDepth); __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipImages); __GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes); __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->depth); __GLX_SWAP_INT((GLbyte *) &hdr->depth);
__GLX_SWAP_INT((GLbyte *) & hdr->size4d); __GLX_SWAP_INT((GLbyte *) &hdr->size4d);
__GLX_SWAP_INT((GLbyte *) & hdr->border); __GLX_SWAP_INT((GLbyte *) &hdr->border);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset); __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset); __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->yoffset); __GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->imageHeight); __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *) & hdr->imageDepth); __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipImages); __GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
__GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes); __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->level); __GLX_SWAP_INT((GLbyte *) &hdr->level);
__GLX_SWAP_INT((GLbyte *) & hdr->xoffset); __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->yoffset); __GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->zoffset); __GLX_SWAP_INT((GLbyte *) &hdr->zoffset);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->depth); __GLX_SWAP_INT((GLbyte *) &hdr->depth);
__GLX_SWAP_INT((GLbyte *) & hdr->size4d); __GLX_SWAP_INT((GLbyte *) &hdr->size4d);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -306,16 +306,16 @@ __glXDispSwap_ColorSubTable(GLbyte * pc)
(__GLXdispatchColorSubTableHeader *) pc; (__GLXdispatchColorSubTableHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->start); __GLX_SWAP_INT((GLbyte *) &hdr->start);
__GLX_SWAP_INT((GLbyte *) & hdr->count); __GLX_SWAP_INT((GLbyte *) &hdr->count);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -331,16 +331,16 @@ __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
(__GLXdispatchConvolutionFilterHeader *) pc; (__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** Just invert swapBytes flag; the GL will figure out if it needs to swap
@ -356,17 +356,17 @@ __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
(__GLXdispatchConvolutionFilterHeader *) pc; (__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** 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); hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
__GLX_SWAP_INT((GLbyte *) & hdr->rowLength); __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
__GLX_SWAP_INT((GLbyte *) & hdr->skipRows); __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
__GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *) & hdr->alignment); __GLX_SWAP_INT((GLbyte *) &hdr->alignment);
__GLX_SWAP_INT((GLbyte *) & hdr->target); __GLX_SWAP_INT((GLbyte *) &hdr->target);
__GLX_SWAP_INT((GLbyte *) & hdr->internalformat); __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
__GLX_SWAP_INT((GLbyte *) & hdr->width); __GLX_SWAP_INT((GLbyte *) &hdr->width);
__GLX_SWAP_INT((GLbyte *) & hdr->height); __GLX_SWAP_INT((GLbyte *) &hdr->height);
__GLX_SWAP_INT((GLbyte *) & hdr->format); __GLX_SWAP_INT((GLbyte *) &hdr->format);
__GLX_SWAP_INT((GLbyte *) & hdr->type); __GLX_SWAP_INT((GLbyte *) &hdr->type);
/* /*
** Just invert swapBytes flag; the GL will figure out if it needs to swap ** Just invert swapBytes flag; the GL will figure out if it needs to swap

18
hw/kdrive/ephyr/XF86dri.c
View File

@ -151,7 +151,7 @@ XF86DRIQueryVersion(Display * dpy, int *majorVersion, int *minorVersion,
GetReq(XF86DRIQueryVersion, req); GetReq(XF86DRIQueryVersion, req);
req->reqType = info->codes->major_opcode; req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIQueryVersion; req->driReqType = X_XF86DRIQueryVersion;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("QueryVersion... return False"); TRACE("QueryVersion... return False");
@ -181,7 +181,7 @@ XF86DRIQueryDirectRenderingCapable(Display * dpy, int screen, Bool *isCapable)
req->reqType = info->codes->major_opcode; req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIQueryDirectRenderingCapable; req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
req->screen = screen; req->screen = screen;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("QueryDirectRenderingCapable... return False"); TRACE("QueryDirectRenderingCapable... return False");
@ -210,7 +210,7 @@ XF86DRIOpenConnection(Display * dpy, int screen,
req->reqType = info->codes->major_opcode; req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIOpenConnection; req->driReqType = X_XF86DRIOpenConnection;
req->screen = screen; req->screen = screen;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("OpenConnection... return False"); TRACE("OpenConnection... return False");
@ -260,7 +260,7 @@ XF86DRIAuthConnection(Display * dpy, int screen, drm_magic_t magic)
req->screen = screen; req->screen = screen;
req->magic = magic; req->magic = magic;
rep.authenticated = 0; rep.authenticated = 0;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse) || !rep.authenticated) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse) || !rep.authenticated) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("AuthConnection... return False"); TRACE("AuthConnection... return False");
@ -311,7 +311,7 @@ XF86DRIGetClientDriverName(Display * dpy, int screen,
req->reqType = info->codes->major_opcode; req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIGetClientDriverName; req->driReqType = X_XF86DRIGetClientDriverName;
req->screen = screen; req->screen = screen;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("GetClientDriverName... return False"); TRACE("GetClientDriverName... return False");
@ -362,7 +362,7 @@ XF86DRICreateContextWithConfig(Display * dpy, int screen, int configID,
req->screen = screen; req->screen = screen;
*context = XAllocID(dpy); *context = XAllocID(dpy);
req->context = *context; req->context = *context;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("CreateContext... return False"); TRACE("CreateContext... return False");
@ -421,7 +421,7 @@ XF86DRICreateDrawable(Display * dpy, int screen,
req->driReqType = X_XF86DRICreateDrawable; req->driReqType = X_XF86DRICreateDrawable;
req->screen = screen; req->screen = screen;
req->drawable = drawable; req->drawable = drawable;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("CreateDrawable... return False"); TRACE("CreateDrawable... return False");
@ -503,7 +503,7 @@ XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable,
req->screen = screen; req->screen = screen;
req->drawable = drawable; req->drawable = drawable;
if (!_XReply(dpy, (xReply *) & rep, 1, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 1, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("GetDrawableInfo... return False"); TRACE("GetDrawableInfo... return False");
@ -585,7 +585,7 @@ XF86DRIGetDeviceInfo(Display * dpy, int screen, drm_handle_t * hFrameBuffer,
req->reqType = info->codes->major_opcode; req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIGetDeviceInfo; req->driReqType = X_XF86DRIGetDeviceInfo;
req->screen = screen; req->screen = screen;
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
TRACE("GetDeviceInfo... return False"); TRACE("GetDeviceInfo... return False");

4
hw/kdrive/ephyr/ephyrdriext.c
View File

@ -754,7 +754,7 @@ ProcXF86DRICreateContext(register ClientPtr client)
if (!ephyrDRICreateContext(stuff->screen, if (!ephyrDRICreateContext(stuff->screen,
stuff->visual, stuff->visual,
&context_id, &context_id,
(drm_context_t *) & rep.hHWContext)) { (drm_context_t *) &rep.hHWContext)) {
return BadValue; return BadValue;
} }
@ -964,7 +964,7 @@ ProcXF86DRICreateDrawable(ClientPtr client)
if (!ephyrDRICreateDrawable(stuff->screen, if (!ephyrDRICreateDrawable(stuff->screen,
remote_win, remote_win,
(drm_drawable_t *) & rep.hHWDrawable)) { (drm_drawable_t *) &rep.hHWDrawable)) {
EPHYR_LOG_ERROR("failed to create dri drawable\n"); EPHYR_LOG_ERROR("failed to create dri drawable\n");
return BadValue; return BadValue;
} }

10
hw/kdrive/ephyr/ephyrhostglx.c
View File

@ -121,7 +121,7 @@ ephyrHostGLXQueryVersion(int *a_major, int *a_minor)
req->glxCode = X_GLXQueryVersion; req->glxCode = X_GLXQueryVersion;
req->majorVersion = 2; req->majorVersion = 2;
req->minorVersion = 1; req->minorVersion = 1;
_XReply(dpy, (xReply *) & reply, 0, False); _XReply(dpy, (xReply *) &reply, 0, False);
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
@ -207,7 +207,7 @@ ephyrHostGLXGetStringFromServer(int a_screen_number,
req->for_whom = default_screen; req->for_whom = default_screen;
req->name = a_string_name; req->name = a_string_name;
_XReply(dpy, (xReply *) & reply, 0, False); _XReply(dpy, (xReply *) &reply, 0, False);
length = reply.length * 4; length = reply.length * 4;
if (!length) { if (!length) {
@ -303,7 +303,7 @@ ephyrHostGLXGetVisualConfigsInternal(enum VisualConfRequestType a_type,
break; break;
} }
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
EPHYR_LOG_ERROR("unknown error\n"); EPHYR_LOG_ERROR("unknown error\n");
UnlockDisplay(dpy); UnlockDisplay(dpy);
goto out; goto out;
@ -615,7 +615,7 @@ ephyrHostGLXMakeCurrent(int a_drawable, int a_readable,
} }
memset(&reply, 0, sizeof(reply)); memset(&reply, 0, sizeof(reply));
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
EPHYR_LOG_ERROR("failed to get reply from host\n"); EPHYR_LOG_ERROR("failed to get reply from host\n");
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();
@ -735,7 +735,7 @@ ephyrHostIsContextDirect(int a_ctxt_id, int *a_is_direct)
req->reqType = major_opcode; req->reqType = major_opcode;
req->glxCode = X_GLXIsDirect; req->glxCode = X_GLXIsDirect;
req->context = remote_glx_ctxt_id; req->context = remote_glx_ctxt_id;
if (!_XReply(dpy, (xReply *) & reply, 0, False)) { if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
EPHYR_LOG_ERROR("fail in reading reply from host\n"); EPHYR_LOG_ERROR("fail in reading reply from host\n");
UnlockDisplay(dpy); UnlockDisplay(dpy);
SyncHandle(); SyncHandle();

2
hw/kdrive/ephyr/ephyrhostproxy.c
View File

@ -73,7 +73,7 @@ ephyrHostProxyDoForward(pointer a_request_buffer,
GetXReq(forward_req); GetXReq(forward_req);
memmove(forward_req, in_req, 4); memmove(forward_req, in_req, 4);
if (!_XReply(dpy, (xReply *) & reply, 0, FALSE)) { if (!_XReply(dpy, (xReply *) &reply, 0, FALSE)) {
EPHYR_LOG_ERROR("failed to get reply\n"); EPHYR_LOG_ERROR("failed to get reply\n");
goto out; goto out;
} }

4
hw/kdrive/ephyr/ephyrhostvideo.c
View File

@ -304,7 +304,7 @@ ephyrHostXVAdaptorArrayAt(const EphyrHostXVAdaptorArray * a_this, int a_index)
if (a_index >= a_this->nb_adaptors) if (a_index >= a_this->nb_adaptors)
return NULL; return NULL;
return (EphyrHostXVAdaptor *) & a_this->adaptors[a_index]; return (EphyrHostXVAdaptor *) &a_this->adaptors[a_index];
} }
char char
@ -668,7 +668,7 @@ ephyrHostXVQueryImageAttributes(int a_port_id,
/* /*
* read the reply * read the reply
*/ */
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
EPHYR_LOG_ERROR("QeryImageAttribute req failed\n"); EPHYR_LOG_ERROR("QeryImageAttribute req failed\n");
goto out; goto out;
} }

2
hw/kdrive/ephyr/ephyrvideo.c
View File

@ -495,7 +495,7 @@ ephyrXVPrivQueryHostAdaptors(EphyrXVPriv * a_this)
port_priv_offset = a_this->adaptors[i].nPorts; port_priv_offset = a_this->adaptors[i].nPorts;
for (j = 0; j < a_this->adaptors[i].nPorts; j++) { for (j = 0; j < a_this->adaptors[i].nPorts; j++) {
EphyrPortPriv *port_privs_base = EphyrPortPriv *port_privs_base =
(EphyrPortPriv *) & a_this->adaptors[i]. (EphyrPortPriv *) &a_this->adaptors[i].
pPortPrivates[port_priv_offset]; pPortPrivates[port_priv_offset];
EphyrPortPriv *port_priv = &port_privs_base[j]; EphyrPortPriv *port_priv = &port_privs_base[j];

2
hw/xfree86/common/xf86cmap.c
View File

@ -608,7 +608,7 @@ CMapRefreshColors(ColormapPtr pmap, int defs, int *indices)
case GrayScale: case GrayScale:
for (i = 0; i < defs; i++) { for (i = 0; i < defs; i++) {
index = indices[i]; index = indices[i];
entry = (EntryPtr) & pmap->red[index]; entry = (EntryPtr) &pmap->red[index];
if (entry->fShared) { if (entry->fShared) {
colors[index].red = colors[index].red =

4
hw/xfree86/dri/xf86dri.c
View File

@ -280,7 +280,7 @@ ProcXF86DRICreateContext(register ClientPtr client)
if (!DRICreateContext(pScreen, if (!DRICreateContext(pScreen,
NULL, NULL,
stuff->context, (drm_context_t *) & rep.hHWContext)) { stuff->context, (drm_context_t *) &rep.hHWContext)) {
return BadValue; return BadValue;
} }
@ -329,7 +329,7 @@ ProcXF86DRICreateDrawable(ClientPtr client)
return rc; return rc;
if (!DRICreateDrawable(screenInfo.screens[stuff->screen], client, if (!DRICreateDrawable(screenInfo.screens[stuff->screen], client,
pDrawable, (drm_drawable_t *) & rep.hHWDrawable)) { pDrawable, (drm_drawable_t *) &rep.hHWDrawable)) {
return BadValue; return BadValue;
} }

10
hw/xfree86/i2c/fi1236.c
View File

@ -91,7 +91,7 @@ MT2032_getid(FI1236Ptr f)
CARD8 in; CARD8 in;
in = 0x11; in = 0x11;
I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 4); I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 4);
xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO,
"MT2032: Company code 0x%02x%02x, part code 0x%02x, revision code 0x%02x\n", "MT2032: Company code 0x%02x%02x, part code 0x%02x, revision code 0x%02x\n",
out[0], out[1], out[2], out[3]); out[0], out[1], out[2], out[3]);
@ -432,7 +432,7 @@ MT2032_get_afc_hint(FI1236Ptr f)
CARD8 AFC; CARD8 AFC;
in = 0x0e; in = 0x0e;
I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 2); I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 2);
AFC = (out[0] >> 4) & 0x7; AFC = (out[0] >> 4) & 0x7;
#if 0 #if 0
xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "AFC=%d TAD1=%d TAD2=%d\n", xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "AFC=%d TAD1=%d TAD2=%d\n",
@ -467,7 +467,7 @@ MT2032_dump_status(FI1236Ptr f)
CARD8 TAD2, TAD1; CARD8 TAD2, TAD1;
in = 0x0e; in = 0x0e;
I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 2); I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 2);
XOK = out[0] & 1; XOK = out[0] & 1;
LO1LK = (out[0] >> 2) & 1; LO1LK = (out[0] >> 2) & 1;
LO2LK = (out[0] >> 1) & 1; LO2LK = (out[0] >> 1) & 1;
@ -589,12 +589,12 @@ FI1236_tune(FI1236Ptr f, CARD32 frequency)
if ((f->type == TUNER_TYPE_FM1216ME) || (f->type == TUNER_TYPE_FI1236W)) { if ((f->type == TUNER_TYPE_FM1216ME) || (f->type == TUNER_TYPE_FI1236W)) {
f->tuner_data.aux = 0x20; f->tuner_data.aux = 0x20;
I2C_WriteRead(&(f->d), (I2CByte *) & (f->tuner_data), 5, NULL, 0); I2C_WriteRead(&(f->d), (I2CByte *) &(f->tuner_data), 5, NULL, 0);
I2C_WriteRead(&(f->d), NULL, 0, &data, 1); I2C_WriteRead(&(f->d), NULL, 0, &data, 1);
xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "Tuner status %x\n", data); xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "Tuner status %x\n", data);
} }
else else
I2C_WriteRead(&(f->d), (I2CByte *) & (f->tuner_data), 4, NULL, 0); I2C_WriteRead(&(f->d), (I2CByte *) &(f->tuner_data), 4, NULL, 0);
} }
void void

2
hw/xfree86/i2c/tda9850.c
View File

@ -131,6 +131,6 @@ tda9850_getstatus(TDA9850Ptr t)
{ {
CARD16 status; CARD16 status;
I2C_WriteRead(&(t->d), NULL, 0, (I2CByte *) & status, 2); I2C_WriteRead(&(t->d), NULL, 0, (I2CByte *) &status, 2);
return status; return status;
} }

2
hw/xwin/InitOutput.c
View File

@ -1042,7 +1042,7 @@ winCheckDisplayNumber(void)
NULL, NULL,
GetLastError(), GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & lpMsgBuf, 0, NULL); (LPTSTR) &lpMsgBuf, 0, NULL);
ErrorF("winCheckDisplayNumber - CreateMutex failed: %s\n", ErrorF("winCheckDisplayNumber - CreateMutex failed: %s\n",
(LPSTR) lpMsgBuf); (LPSTR) lpMsgBuf);
LocalFree(lpMsgBuf); LocalFree(lpMsgBuf);

4
hw/xwin/glx/indirect.c
View File

@ -224,7 +224,7 @@ glxWinErrorMessage(void)
if (!FormatMessage if (!FormatMessage
(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, last_error, 0, FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, last_error, 0,
(LPTSTR) & errorbuffer, sizeof(errorbuffer), NULL)) { (LPTSTR) &errorbuffer, sizeof(errorbuffer), NULL)) {
snprintf(errorbuffer, sizeof(errorbuffer), "Unknown error"); snprintf(errorbuffer, sizeof(errorbuffer), "Unknown error");
} }
@ -1370,7 +1370,7 @@ glxWinDeferredCreateContext(__GLXWinContext * gc, __GLXWinDrawable * draw)
} }
draw->hDIB = draw->hDIB =
CreateDIBSection(draw->dibDC, (BITMAPINFO *) & bmpHeader, CreateDIBSection(draw->dibDC, (BITMAPINFO *) &bmpHeader,
DIB_RGB_COLORS, &pBits, 0, 0); DIB_RGB_COLORS, &pBits, 0, 0);
if (draw->dibDC == NULL) { if (draw->dibDC == NULL) {
ErrorF("CreateDIBSection error: %s\n", glxWinErrorMessage()); ErrorF("CreateDIBSection error: %s\n", glxWinErrorMessage());

6
hw/xwin/winclipboardxevents.c
View File

@ -157,7 +157,7 @@ winClipboardFlushXEvents(HWND hwnd,
*/ */
iReturn = XSendEvent(pDisplay, iReturn = XSendEvent(pDisplay,
eventSelection.requestor, eventSelection.requestor,
False, 0L, (XEvent *) & eventSelection); False, 0L, (XEvent *) &eventSelection);
if (iReturn == BadValue || iReturn == BadWindow) { if (iReturn == BadValue || iReturn == BadWindow) {
ErrorF("winClipboardFlushXEvents - SelectionRequest - " ErrorF("winClipboardFlushXEvents - SelectionRequest - "
"XSendEvent () failed\n"); "XSendEvent () failed\n");
@ -341,7 +341,7 @@ winClipboardFlushXEvents(HWND hwnd,
/* Notify the requesting window that the operation has completed */ /* Notify the requesting window that the operation has completed */
iReturn = XSendEvent(pDisplay, iReturn = XSendEvent(pDisplay,
eventSelection.requestor, eventSelection.requestor,
False, 0L, (XEvent *) & eventSelection); False, 0L, (XEvent *) &eventSelection);
if (iReturn == BadValue || iReturn == BadWindow) { if (iReturn == BadValue || iReturn == BadWindow) {
ErrorF("winClipboardFlushXEvents - SelectionRequest - " ErrorF("winClipboardFlushXEvents - SelectionRequest - "
"XSendEvent () failed\n"); "XSendEvent () failed\n");
@ -380,7 +380,7 @@ winClipboardFlushXEvents(HWND hwnd,
/* Notify the requesting window that the operation is complete */ /* Notify the requesting window that the operation is complete */
iReturn = XSendEvent(pDisplay, iReturn = XSendEvent(pDisplay,
eventSelection.requestor, eventSelection.requestor,
False, 0L, (XEvent *) & eventSelection); False, 0L, (XEvent *) &eventSelection);
if (iReturn == BadValue || iReturn == BadWindow) { if (iReturn == BadValue || iReturn == BadWindow) {
/* /*
* Should not be a problem if XSendEvent fails because * Should not be a problem if XSendEvent fails because

6
hw/xwin/wincursor.c
View File

@ -104,7 +104,7 @@ winPointerWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
/* Translate the client area coords to screen coords */ /* Translate the client area coords to screen coords */
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & rcClient, 2); HWND_DESKTOP, (LPPOINT) &rcClient, 2);
/* /*
* Update the Windows cursor position so that we don't * Update the Windows cursor position so that we don't
@ -275,7 +275,7 @@ winLoadCursor(ScreenPtr pScreen, CursorPtr pCursor, int screen)
if (!lpBits) { if (!lpBits) {
/* Bicolor, use a palettized DIB */ /* Bicolor, use a palettized DIB */
WIN_DEBUG_MSG("winLoadCursor: Trying two color cursor\n"); WIN_DEBUG_MSG("winLoadCursor: Trying two color cursor\n");
pbmi = (BITMAPINFO *) & bi; pbmi = (BITMAPINFO *) &bi;
memset(pbmi, 0, sizeof(BITMAPINFOHEADER)); memset(pbmi, 0, sizeof(BITMAPINFOHEADER));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = pScreenPriv->cursor.sm_cx; pbmi->bmiHeader.biWidth = pScreenPriv->cursor.sm_cx;
@ -358,7 +358,7 @@ winLoadCursor(ScreenPtr pScreen, CursorPtr pCursor, int screen)
CreateCompatibleBitmap(hDC, pScreenPriv->cursor.sm_cx, CreateCompatibleBitmap(hDC, pScreenPriv->cursor.sm_cx,
pScreenPriv->cursor.sm_cy); pScreenPriv->cursor.sm_cy);
SetDIBits(hDC, hXor, 0, pScreenPriv->cursor.sm_cy, lpBits, SetDIBits(hDC, hXor, 0, pScreenPriv->cursor.sm_cy, lpBits,
(BITMAPINFO *) & bi, DIB_RGB_COLORS); (BITMAPINFO *) &bi, DIB_RGB_COLORS);
ReleaseDC(NULL, hDC); ReleaseDC(NULL, hDC);
} }
free(lpBits); free(lpBits);

2
hw/xwin/winengine.c
View File

@ -108,7 +108,7 @@ winDetectSupportedEngines(void)
/* Try to query for DirectDraw4 interface */ /* Try to query for DirectDraw4 interface */
ddrval = IDirectDraw_QueryInterface(lpdd, ddrval = IDirectDraw_QueryInterface(lpdd,
&IID_IDirectDraw4, &IID_IDirectDraw4,
(LPVOID *) & lpdd4); (LPVOID *) &lpdd4);
if (SUCCEEDED(ddrval)) { if (SUCCEEDED(ddrval)) {
/* We have DirectDraw4 */ /* We have DirectDraw4 */
winErrorFVerb(2, winErrorFVerb(2,

4
hw/xwin/wingc.c
View File

@ -130,8 +130,8 @@ winCreateGCNativeGDI(GCPtr pGC)
ErrorF("winCreateGCNativeGDI - depth: %d\n", pGC->depth); ErrorF("winCreateGCNativeGDI - depth: %d\n", pGC->depth);
#endif #endif
pGC->ops = (GCOps *) & winGCOps; pGC->ops = (GCOps *) &winGCOps;
pGC->funcs = (GCFuncs *) & winGCFuncs; pGC->funcs = (GCFuncs *) &winGCFuncs;
/* We want all coordinates passed to spans functions to be screen relative */ /* We want all coordinates passed to spans functions to be screen relative */
pGC->miTranslate = TRUE; pGC->miTranslate = TRUE;

2
hw/xwin/winmsg.c
View File

@ -137,7 +137,7 @@ winW32ErrorEx(int verb, const char *msg, DWORD errorcode)
NULL, NULL,
errorcode, errorcode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & buffer, 0, NULL)) { (LPTSTR) &buffer, 0, NULL)) {
winErrorFVerb(verb, "Unknown error in FormatMessage!\n"); winErrorFVerb(verb, "Unknown error in FormatMessage!\n");
} }
else { else {

2
hw/xwin/winmultiwindowicons.c
View File

@ -253,7 +253,7 @@ NetWMToWinIconAlpha(uint32_t * icon)
ii.fIcon = TRUE; ii.fIcon = TRUE;
ii.xHotspot = 0; /* ignored */ ii.xHotspot = 0; /* ignored */
ii.yHotspot = 0; /* ignored */ ii.yHotspot = 0; /* ignored */
ii.hbmColor = CreateDIBSection(hdc, (BITMAPINFO *) & bmh, ii.hbmColor = CreateDIBSection(hdc, (BITMAPINFO *) &bmh,
DIB_RGB_COLORS, (void **) &DIB_pixels, NULL, DIB_RGB_COLORS, (void **) &DIB_pixels, NULL,
0); 0);
ReleaseDC(NULL, hdc); ReleaseDC(NULL, hdc);

2
hw/xwin/winmultiwindowshape.c
View File

@ -137,7 +137,7 @@ winReshapeMultiWindow(WindowPtr pWin)
/* Translate client rectangle coords to screen coords */ /* Translate client rectangle coords to screen coords */
/* NOTE: Only transforms top and left members */ /* NOTE: Only transforms top and left members */
ClientToScreen(pWinPriv->hWnd, (LPPOINT) & rcClient); ClientToScreen(pWinPriv->hWnd, (LPPOINT) &rcClient);
/* Get window rectangle */ /* Get window rectangle */
if (!GetWindowRect(pWinPriv->hWnd, &rcWindow)) { if (!GetWindowRect(pWinPriv->hWnd, &rcWindow)) {

2
hw/xwin/winmultiwindowwndproc.c
View File

@ -498,7 +498,7 @@ winTopLevelWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
NULL, NULL,
GetLastError(), GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & lpMsgBuf, 0, NULL); (LPTSTR) &lpMsgBuf, 0, NULL);
ErrorF("winTopLevelWindowProc - BitBlt failed: %s\n", ErrorF("winTopLevelWindowProc - BitBlt failed: %s\n",
(LPSTR) lpMsgBuf); (LPSTR) lpMsgBuf);

8
hw/xwin/winpfbdd.c
View File

@ -78,7 +78,7 @@ winAllocateFBPrimaryDD(ScreenPtr pScreen)
/* Get client area location in screen coords */ /* Get client area location in screen coords */
GetClientRect(pScreenPriv->hwndScreen, &rcClient); GetClientRect(pScreenPriv->hwndScreen, &rcClient);
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & rcClient, 2); HWND_DESKTOP, (LPPOINT) &rcClient, 2);
/* Create a DirectDraw object, store the address at lpdd */ /* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL); ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL);
@ -88,7 +88,7 @@ winAllocateFBPrimaryDD(ScreenPtr pScreen)
/* Get a DirectDraw2 interface pointer */ /* Get a DirectDraw2 interface pointer */
ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd,
&IID_IDirectDraw2, &IID_IDirectDraw2,
(LPVOID *) & pScreenPriv->pdd2); (LPVOID *) &pScreenPriv->pdd2);
if (FAILED(ddrval)) { if (FAILED(ddrval)) {
ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n", ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n",
(unsigned int) ddrval); (unsigned int) ddrval);
@ -465,7 +465,7 @@ winActivateAppPrimaryDD(ScreenPtr pScreen)
/* Get client area in screen coords */ /* Get client area in screen coords */
GetClientRect(pScreenPriv->hwndScreen, &rcClient); GetClientRect(pScreenPriv->hwndScreen, &rcClient);
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & rcClient, 2); HWND_DESKTOP, (LPPOINT) &rcClient, 2);
/* Setup a source rectangle */ /* Setup a source rectangle */
rcSrc.left = 0; rcSrc.left = 0;
@ -530,7 +530,7 @@ winHotKeyAltTabPrimaryDD(ScreenPtr pScreen)
/* Get client area in screen coords */ /* Get client area in screen coords */
GetClientRect(pScreenPriv->hwndScreen, &rcClient); GetClientRect(pScreenPriv->hwndScreen, &rcClient);
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & rcClient, 2); HWND_DESKTOP, (LPPOINT) &rcClient, 2);
/* Did we loose the primary surface? */ /* Did we loose the primary surface? */
ddrval = IDirectDrawSurface2_IsLost(pScreenPriv->pddsPrimary); ddrval = IDirectDrawSurface2_IsLost(pScreenPriv->pddsPrimary);

2
hw/xwin/winpixmap.c
View File

@ -109,7 +109,7 @@ winCreatePixmapNativeGDI(ScreenPtr pScreen,
/* Create a DIB for the pixmap */ /* Create a DIB for the pixmap */
pPixmapPriv->hBitmap = winCreateDIBNativeGDI(iWidth, iHeight, iDepth, pPixmapPriv->hBitmap = winCreateDIBNativeGDI(iWidth, iHeight, iDepth,
&pPixmapPriv->pbBits, &pPixmapPriv->pbBits,
(BITMAPINFO **) & pPixmapPriv-> (BITMAPINFO **) &pPixmapPriv->
pbmih); pbmih);
#if CYGDEBUG #if CYGDEBUG

2
hw/xwin/winscrinit.c
View File

@ -550,7 +550,7 @@ winFinishScreenInitFB(int i, ScreenPtr pScreen, int argc, char **argv)
&pScreenPriv->ptWMProc, &pScreenPriv->ptWMProc,
&pScreenPriv->ptXMsgProc, &pScreenPriv->ptXMsgProc,
&pScreenPriv->pmServerStarted, &pScreenPriv->pmServerStarted,
pScreenInfo->dwScreen, (HWND) & pScreenPriv->hwndScreen, pScreenInfo->dwScreen, (HWND) &pScreenPriv->hwndScreen,
#ifdef XWIN_MULTIWINDOWEXTWM #ifdef XWIN_MULTIWINDOWEXTWM
pScreenInfo->fInternalWM || pScreenInfo->fInternalWM ||
#endif #endif

4
hw/xwin/winsetsp.c
View File

@ -107,7 +107,7 @@ winSetSpansNativeGDI(DrawablePtr pDrawable,
0, 0, 0, 0,
*piWidths, 1, *piWidths, 1,
pSrcs, pSrcs,
(BITMAPINFO *) & bmi, (BITMAPINFO *) &bmi,
DIB_RGB_COLORS, g_copyROP[pGC->alu]); DIB_RGB_COLORS, g_copyROP[pGC->alu]);
pSrcs += PixmapBytePad(*piWidths, pDrawable->depth); pSrcs += PixmapBytePad(*piWidths, pDrawable->depth);
@ -150,7 +150,7 @@ winSetSpansNativeGDI(DrawablePtr pDrawable,
0, 0, 0, 0,
*piWidths, 1, *piWidths, 1,
pSrcs, pSrcs,
(BITMAPINFO *) & bmi, (BITMAPINFO *) &bmi,
DIB_RGB_COLORS, g_copyROP[pGC->alu]); DIB_RGB_COLORS, g_copyROP[pGC->alu]);
pSrcs += PixmapBytePad(*piWidths, pDrawable->depth); pSrcs += PixmapBytePad(*piWidths, pDrawable->depth);

8
hw/xwin/winshaddd.c
View File

@ -232,7 +232,7 @@ winAllocateFBShadowDD(ScreenPtr pScreen)
/* Get a DirectDraw2 interface pointer */ /* Get a DirectDraw2 interface pointer */
ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd,
&IID_IDirectDraw2, &IID_IDirectDraw2,
(LPVOID *) & pScreenPriv->pdd2); (LPVOID *) &pScreenPriv->pdd2);
if (FAILED(ddrval)) { if (FAILED(ddrval)) {
ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n", ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n",
(unsigned int) ddrval); (unsigned int) ddrval);
@ -507,7 +507,7 @@ winShadowUpdateDD(ScreenPtr pScreen, shadowBufPtr pBuf)
ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.x = pScreenInfo->dwXOffset;
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
/* Unlock the shadow surface, so we can blit */ /* Unlock the shadow surface, so we can blit */
ddrval = IDirectDrawSurface2_Unlock(pScreenPriv->pddsShadow, NULL); ddrval = IDirectDrawSurface2_Unlock(pScreenPriv->pddsShadow, NULL);
@ -853,7 +853,7 @@ winBltExposedRegionsShadowDD(ScreenPtr pScreen)
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
rcDest.left = ptOrigin.x; rcDest.left = ptOrigin.x;
rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
rcDest.top = ptOrigin.y; rcDest.top = ptOrigin.y;
@ -996,7 +996,7 @@ winRedrawScreenShadowDD(ScreenPtr pScreen)
ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.x = pScreenInfo->dwXOffset;
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
rcDest.left = ptOrigin.x; rcDest.left = ptOrigin.x;
rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
rcDest.top = ptOrigin.y; rcDest.top = ptOrigin.y;

10
hw/xwin/winshadddnl.c
View File

@ -249,7 +249,7 @@ winAllocateFBShadowDDNL(ScreenPtr pScreen)
/* Create a DirectDraw object, store the address at lpdd */ /* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, ddrval = (*g_fpDirectDrawCreate) (NULL,
(LPDIRECTDRAW *) & pScreenPriv->pdd, (LPDIRECTDRAW *) &pScreenPriv->pdd,
NULL); NULL);
if (FAILED(ddrval)) { if (FAILED(ddrval)) {
ErrorF("winAllocateFBShadowDDNL - Could not start " ErrorF("winAllocateFBShadowDDNL - Could not start "
@ -264,7 +264,7 @@ winAllocateFBShadowDDNL(ScreenPtr pScreen)
/* Get a DirectDraw4 interface pointer */ /* Get a DirectDraw4 interface pointer */
ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd,
&IID_IDirectDraw4, &IID_IDirectDraw4,
(LPVOID *) & pScreenPriv->pdd4); (LPVOID *) &pScreenPriv->pdd4);
if (FAILED(ddrval)) { if (FAILED(ddrval)) {
ErrorF("winAllocateFBShadowDDNL - Failed DD4 query: %08x\n", ErrorF("winAllocateFBShadowDDNL - Failed DD4 query: %08x\n",
(unsigned int) ddrval); (unsigned int) ddrval);
@ -541,7 +541,7 @@ winShadowUpdateDDNL(ScreenPtr pScreen, shadowBufPtr pBuf)
ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.x = pScreenInfo->dwXOffset;
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
/* /*
* Handle small regions with multiple blits, * Handle small regions with multiple blits,
@ -880,7 +880,7 @@ winBltExposedRegionsShadowDDNL(ScreenPtr pScreen)
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
rcDest.left = ptOrigin.x; rcDest.left = ptOrigin.x;
rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
rcDest.top = ptOrigin.y; rcDest.top = ptOrigin.y;
@ -990,7 +990,7 @@ winRedrawScreenShadowDDNL(ScreenPtr pScreen)
ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.x = pScreenInfo->dwXOffset;
ptOrigin.y = pScreenInfo->dwYOffset; ptOrigin.y = pScreenInfo->dwYOffset;
MapWindowPoints(pScreenPriv->hwndScreen, MapWindowPoints(pScreenPriv->hwndScreen,
HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); HWND_DESKTOP, (LPPOINT) &ptOrigin, 1);
rcDest.left = ptOrigin.x; rcDest.left = ptOrigin.x;
rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth;
rcDest.top = ptOrigin.y; rcDest.top = ptOrigin.y;

2
hw/xwin/winshadgdi.c
View File

@ -337,7 +337,7 @@ winAllocateFBShadowGDI(ScreenPtr pScreen)
pScreenPriv->hbmpShadow = CreateDIBSection(pScreenPriv->hdcScreen, pScreenPriv->hbmpShadow = CreateDIBSection(pScreenPriv->hdcScreen,
(BITMAPINFO *) pScreenPriv-> (BITMAPINFO *) pScreenPriv->
pbmih, DIB_RGB_COLORS, pbmih, DIB_RGB_COLORS,
(VOID **) & pScreenInfo->pfb, (VOID **) &pScreenInfo->pfb,
NULL, 0); NULL, 0);
if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL) { if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL) {
winW32Error(2, "winAllocateFBShadowGDI - CreateDIBSection failed:"); winW32Error(2, "winAllocateFBShadowGDI - CreateDIBSection failed:");

6
hw/xwin/winwin32rootless.c
View File

@ -634,7 +634,7 @@ winMWExtWMReshapeFrame(RootlessFrameID wid, RegionPtr pShape)
/* Create region for non-client area */ /* Create region for non-client area */
GetWindowRect(pRLWinPriv->hWnd, &rcWindow); GetWindowRect(pRLWinPriv->hWnd, &rcWindow);
GetClientRect(pRLWinPriv->hWnd, &rcClient); GetClientRect(pRLWinPriv->hWnd, &rcClient);
MapWindowPoints(pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); MapWindowPoints(pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2);
OffsetRgn(hRgn, rcClient.left - rcWindow.left, rcClient.top - rcWindow.top); OffsetRgn(hRgn, rcClient.left - rcWindow.left, rcClient.top - rcWindow.top);
OffsetRect(&rcClient, -rcWindow.left, -rcWindow.top); OffsetRect(&rcClient, -rcWindow.left, -rcWindow.top);
OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top); OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top);
@ -725,7 +725,7 @@ winMWExtWMStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)
hbmpNew = CreateDIBSection(pRLWinPriv->hdcScreen, hbmpNew = CreateDIBSection(pRLWinPriv->hdcScreen,
(BITMAPINFO *) pRLWinPriv->pbmihShadow, (BITMAPINFO *) pRLWinPriv->pbmihShadow,
DIB_RGB_COLORS, DIB_RGB_COLORS,
(VOID **) & pRLWinPriv->pfb, NULL, 0); (VOID **) &pRLWinPriv->pfb, NULL, 0);
if (hbmpNew == NULL || pRLWinPriv->pfb == NULL) { if (hbmpNew == NULL || pRLWinPriv->pfb == NULL) {
ErrorF("winMWExtWMStartDrawing - CreateDIBSection failed\n"); ErrorF("winMWExtWMStartDrawing - CreateDIBSection failed\n");
//return FALSE; //return FALSE;
@ -883,7 +883,7 @@ winMWExtWMUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)
NULL, NULL,
GetLastError(), GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & lpMsgBuf, 0, NULL); (LPTSTR) &lpMsgBuf, 0, NULL);
ErrorF("winMWExtWMUpdateRegion - UpdateLayeredWindow failed: %s\n", ErrorF("winMWExtWMUpdateRegion - UpdateLayeredWindow failed: %s\n",
(LPSTR) lpMsgBuf); (LPSTR) lpMsgBuf);

6
hw/xwin/winwin32rootlesswndproc.c
View File

@ -780,7 +780,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
NULL, NULL,
GetLastError(), GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & lpMsgBuf, 0, NULL); (LPTSTR) &lpMsgBuf, 0, NULL);
ErrorF("winMWExtWMWindowProc - BitBlt failed: %s\n", ErrorF("winMWExtWMWindowProc - BitBlt failed: %s\n",
(LPSTR) lpMsgBuf); (LPSTR) lpMsgBuf);
@ -1058,7 +1058,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
if (!pRLWinPriv->fMovingOrSizing if (!pRLWinPriv->fMovingOrSizing
/*&& (pWinPos->flags & SWP_SHOWWINDOW) */ ) { /*&& (pWinPos->flags & SWP_SHOWWINDOW) */ ) {
GetClientRect(hwnd, &rcClient); GetClientRect(hwnd, &rcClient);
MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2);
if (!(pWinPos->flags & SWP_NOMOVE) if (!(pWinPos->flags & SWP_NOMOVE)
&& !(pWinPos->flags & SWP_NOSIZE)) { && !(pWinPos->flags & SWP_NOSIZE)) {
@ -1263,7 +1263,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
GetClientRect(hwnd, &rcClient); GetClientRect(hwnd, &rcClient);
MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2);
if (winIsInternalWMRunning(pScreenInfo)) if (winIsInternalWMRunning(pScreenInfo))
winAdjustXWindow(pWin, hwnd); winAdjustXWindow(pWin, hwnd);

2
os/access.c
View File

@ -471,7 +471,7 @@ in6_fillscopeid(struct sockaddr_in6 *sin6)
#if defined(__KAME__) #if defined(__KAME__)
if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
sin6->sin6_scope_id = sin6->sin6_scope_id =
ntohs(*(u_int16_t *) & sin6->sin6_addr.s6_addr[2]); ntohs(*(u_int16_t *) &sin6->sin6_addr.s6_addr[2]);
sin6->sin6_addr.s6_addr[2] = sin6->sin6_addr.s6_addr[3] = 0; sin6->sin6_addr.s6_addr[2] = sin6->sin6_addr.s6_addr[3] = 0;
} }
#endif #endif

2
os/utils.c
View File

@ -1639,7 +1639,7 @@ System(const char *cmdline)
NULL, NULL,
GetLastError(), GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) & buffer, 0, NULL)) { (LPTSTR) &buffer, 0, NULL)) {
ErrorF("[xkb] Starting '%s' failed!\n", cmdline); ErrorF("[xkb] Starting '%s' failed!\n", cmdline);
} }
else { else {

12
os/xdmcp.c
View File

@ -751,7 +751,7 @@ receive_packet(int socketfd)
XdmcpHeader header; XdmcpHeader header;
/* read message off socket */ /* read message off socket */
if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) & from, &fromlen)) if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) &from, &fromlen))
return; return;
/* reset retransmission backoff */ /* reset retransmission backoff */
@ -1059,7 +1059,7 @@ send_query_msg(void)
for (i = 0; i < NumBroadcastAddresses; i++) for (i = 0; i < NumBroadcastAddresses; i++)
XdmcpFlush(xdmcpSocket, &buffer, XdmcpFlush(xdmcpSocket, &buffer,
(XdmcpNetaddr) & BroadcastAddresses[i], (XdmcpNetaddr) &BroadcastAddresses[i],
sizeof(struct sockaddr_in)); sizeof(struct sockaddr_in));
} }
#if defined(IPv6) && defined(AF_INET6) #if defined(IPv6) && defined(AF_INET6)
@ -1098,7 +1098,7 @@ send_query_msg(void)
if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6) if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6)
socketfd = xdmcpSocket6; socketfd = xdmcpSocket6;
#endif #endif
XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & ManagerAddress, XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &ManagerAddress,
ManagerAddressLen); ManagerAddressLen);
} }
} }
@ -1223,7 +1223,7 @@ send_request_msg(void)
socketfd = xdmcpSocket6; socketfd = xdmcpSocket6;
#endif #endif
if (XdmcpFlush(socketfd, &buffer, if (XdmcpFlush(socketfd, &buffer,
(XdmcpNetaddr) & req_sockaddr, req_socklen)) (XdmcpNetaddr) &req_sockaddr, req_socklen))
state = XDM_AWAIT_REQUEST_RESPONSE; state = XDM_AWAIT_REQUEST_RESPONSE;
} }
@ -1316,7 +1316,7 @@ send_manage_msg(void)
if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6) if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
socketfd = xdmcpSocket6; socketfd = xdmcpSocket6;
#endif #endif
XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen); XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
} }
static void static void
@ -1373,7 +1373,7 @@ send_keepalive_msg(void)
if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6) if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
socketfd = xdmcpSocket6; socketfd = xdmcpSocket6;
#endif #endif
XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen); XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
} }
static void static void

2
test/input.c
View File

@ -406,7 +406,7 @@ _dix_test_xi_convert(DeviceEvent *ev, int expected_rc, int expected_count)
assert(kbp->same_screen == FALSE); assert(kbp->same_screen == FALSE);
while (--count > 0) { while (--count > 0) {
deviceValuator *v = (deviceValuator *) & xi[count]; deviceValuator *v = (deviceValuator *) &xi[count];
assert(v->type == DeviceValuator); assert(v->type == DeviceValuator);
assert(v->num_valuators <= 6); assert(v->num_valuators <= 6);

2
test/xi2/protocol-eventconvert.c
View File

@ -694,7 +694,7 @@ test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
assert(k->num_keycodes == in->keys.max_keycode - assert(k->num_keycodes == in->keys.max_keycode -
in->keys.min_keycode + 1); in->keys.min_keycode + 1);
kc = (uint32_t *) & k[1]; kc = (uint32_t *) &k[1];
for (j = 0; j < k->num_keycodes; j++) { for (j = 0; j < k->num_keycodes; j++) {
if (swap) { if (swap) {
swapl(&kc[j]); swapl(&kc[j]);

2
test/xi2/protocol-xiquerydevice.c
View File

@ -171,7 +171,7 @@ reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void *closure)
(xkb->max_key_code - xkb->min_key_code + 1)); (xkb->max_key_code - xkb->min_key_code + 1));
assert(any->length == (2 + ki->num_keycodes)); assert(any->length == (2 + ki->num_keycodes));
kc = (uint32_t *) & ki[1]; kc = (uint32_t *) &ki[1];
for (k = 0; k < ki->num_keycodes; k++, kc++) { for (k = 0; k < ki->num_keycodes; k++, kc++) {
if (client->swapped) if (client->swapped)
swapl(kc); swapl(kc);

12
test/xi2/protocol-xiselectevents.c
View File

@ -98,7 +98,7 @@ request_XISelectEvent(xXISelectEventsReq * req, int error)
xXIEventMask *mask, *next; xXIEventMask *mask, *next;
req->length = (sz_xXISelectEventsReq / 4); req->length = (sz_xXISelectEventsReq / 4);
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
for (i = 0; i < req->num_masks; i++) { for (i = 0; i < req->num_masks; i++) {
req->length += sizeof(xXIEventMask) / 4 + mask->mask_len; req->length += sizeof(xXIEventMask) / 4 + mask->mask_len;
mask = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4); mask = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4);
@ -111,7 +111,7 @@ request_XISelectEvent(xXISelectEventsReq * req, int error)
client.swapped = TRUE; client.swapped = TRUE;
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
for (i = 0; i < req->num_masks; i++) { for (i = 0; i < req->num_masks; i++) {
next = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4); next = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4);
swaps(&mask->deviceid); swaps(&mask->deviceid);
@ -156,7 +156,7 @@ request_XISelectEvents_masks(xXISelectEventsReq * req)
int nmasks = (XI2LASTEVENT + 7) / 8; int nmasks = (XI2LASTEVENT + 7) / 8;
unsigned char *bits; unsigned char *bits;
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
req->win = ROOT_WINDOW_ID; req->win = ROOT_WINDOW_ID;
/* if a clients submits more than 100 masks, consider it insane and untested */ /* if a clients submits more than 100 masks, consider it insane and untested */
@ -312,7 +312,7 @@ test_XISelectEvents(void)
req->num_masks = 1; req->num_masks = 1;
printf("Triggering bogus mask length error\n"); printf("Triggering bogus mask length error\n");
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
mask->deviceid = 0; mask->deviceid = 0;
mask->mask_len = 0xFFFF; mask->mask_len = 0xFFFF;
request_XISelectEvent(req, BadLength); request_XISelectEvent(req, BadLength);
@ -320,7 +320,7 @@ test_XISelectEvents(void)
/* testing various device ids */ /* testing various device ids */
printf("Testing existing device ids.\n"); printf("Testing existing device ids.\n");
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
mask->deviceid = i; mask->deviceid = i;
mask->mask_len = 1; mask->mask_len = 1;
req->win = ROOT_WINDOW_ID; req->win = ROOT_WINDOW_ID;
@ -332,7 +332,7 @@ test_XISelectEvents(void)
for (i = 6; i <= 0xFFFF; i++) { for (i = 6; i <= 0xFFFF; i++) {
req->win = ROOT_WINDOW_ID; req->win = ROOT_WINDOW_ID;
req->num_masks = 1; req->num_masks = 1;
mask = (xXIEventMask *) & req[1]; mask = (xXIEventMask *) &req[1];
mask->deviceid = i; mask->deviceid = i;
mask->mask_len = 1; mask->mask_len = 1;
request_XISelectEvent(req, BadDevice); request_XISelectEvent(req, BadDevice);

36
xkb/xkb.c
View File

@ -1650,8 +1650,8 @@ CheckKeyTypes(ClientPtr client,
xkbKTSetMapEntryWireDesc *mapWire; xkbKTSetMapEntryWireDesc *mapWire;
xkbModsWireDesc *preWire; xkbModsWireDesc *preWire;
mapWire = (xkbKTSetMapEntryWireDesc *) & wire[1]; mapWire = (xkbKTSetMapEntryWireDesc *) &wire[1];
preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries]; preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
for (n = 0; n < wire->nMapEntries; n++) { for (n = 0; n < wire->nMapEntries; n++) {
if (client->swapped) { if (client->swapped) {
swaps(&mapWire[n].virtualMods); swaps(&mapWire[n].virtualMods);
@ -1761,8 +1761,8 @@ CheckKeySyms(ClientPtr client,
*errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms); *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms);
return 0; return 0;
} }
pSyms = (KeySym *) & wire[1]; pSyms = (KeySym *) &wire[1];
wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms]; wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
} }
map = &xkb->map->key_sym_map[i]; map = &xkb->map->key_sym_map[i];
@ -2039,7 +2039,7 @@ SetKeyTypes(XkbDescPtr xkb,
unsigned tmp; unsigned tmp;
mapWire = (xkbKTSetMapEntryWireDesc *) map; mapWire = (xkbKTSetMapEntryWireDesc *) map;
preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries]; preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
for (n = 0; n < wire->nMapEntries; n++) { for (n = 0; n < wire->nMapEntries; n++) {
pOld->map[n].active = 1; pOld->map[n].active = 1;
pOld->map[n].mods.mask = mapWire[n].realMods; pOld->map[n].mods.mask = mapWire[n].realMods;
@ -2098,7 +2098,7 @@ SetKeySyms(ClientPtr client,
oldMap = &xkb->map->key_sym_map[req->firstKeySym]; oldMap = &xkb->map->key_sym_map[req->firstKeySym];
for (i = 0; i < req->nKeySyms; i++, oldMap++) { for (i = 0; i < req->nKeySyms; i++, oldMap++) {
pSyms = (KeySym *) & wire[1]; pSyms = (KeySym *) &wire[1];
if (wire->nSyms > 0) { if (wire->nSyms > 0) {
newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms); newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
for (s = 0; s < wire->nSyms; s++) { for (s = 0; s < wire->nSyms; s++) {
@ -2116,7 +2116,7 @@ SetKeySyms(ClientPtr client,
oldMap->kt_index[3] = wire->ktIndex[3]; oldMap->kt_index[3] = wire->ktIndex[3];
oldMap->group_info = wire->groupInfo; oldMap->group_info = wire->groupInfo;
oldMap->width = wire->width; oldMap->width = wire->width;
wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms]; wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
} }
first = req->firstKeySym; first = req->firstKeySym;
last = first + req->nKeySyms - 1; last = first + req->nKeySyms - 1;
@ -2408,7 +2408,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
} }
if ((req->present & XkbKeyTypesMask) && if ((req->present & XkbKeyTypesMask) &&
(!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) & values, (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) &values,
&nTypes, mapWidths))) { &nTypes, mapWidths))) {
client->errorValue = nTypes; client->errorValue = nTypes;
return BadValue; return BadValue;
@ -2433,7 +2433,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
if ((req->present & XkbKeySymsMask) && if ((req->present & XkbKeySymsMask) &&
(!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey, (!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey,
(xkbSymMapWireDesc **) & values, &error))) { (xkbSymMapWireDesc **) &values, &error))) {
client->errorValue = error; client->errorValue = error;
return BadValue; return BadValue;
} }
@ -2447,7 +2447,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
if ((req->present & XkbKeyBehaviorsMask) && if ((req->present & XkbKeyBehaviorsMask) &&
(!CheckKeyBehaviors (!CheckKeyBehaviors
(xkb, req, (xkbBehaviorWireDesc **) & values, &error))) { (xkb, req, (xkbBehaviorWireDesc **) &values, &error))) {
client->errorValue = error; client->errorValue = error;
return BadValue; return BadValue;
} }
@ -2469,7 +2469,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
} }
if ((req->present & XkbVirtualModMapMask) && if ((req->present & XkbVirtualModMapMask) &&
(!CheckVirtualModMap (!CheckVirtualModMap
(xkb, req, (xkbVModMapWireDesc **) & values, &error))) { (xkb, req, (xkbVModMapWireDesc **) &values, &error))) {
client->errorValue = error; client->errorValue = error;
return BadValue; return BadValue;
} }
@ -5097,7 +5097,7 @@ _CheckSetOverlay(char **wire_inout,
} }
CHK_ATOM_ONLY(olWire->name); CHK_ATOM_ONLY(olWire->name);
ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows); ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows);
rWire = (xkbOverlayRowWireDesc *) & olWire[1]; rWire = (xkbOverlayRowWireDesc *) &olWire[1];
for (r = 0; r < olWire->nRows; r++) { for (r = 0; r < olWire->nRows; r++) {
register int k; register int k;
xkbOverlayKeyWireDesc *kWire; xkbOverlayKeyWireDesc *kWire;
@ -5109,7 +5109,7 @@ _CheckSetOverlay(char **wire_inout,
return BadMatch; return BadMatch;
} }
row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys); row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
kWire = (xkbOverlayKeyWireDesc *) & rWire[1]; kWire = (xkbOverlayKeyWireDesc *) &rWire[1];
for (k = 0; k < rWire->nKeys; k++, kWire++) { for (k = 0; k < rWire->nKeys; k++, kWire++) {
if (XkbAddGeomOverlayKey(ol, row, if (XkbAddGeomOverlayKey(ol, row,
(char *) kWire->over, (char *) kWire->over,
@ -5163,7 +5163,7 @@ _CheckSetSections(XkbGeometryPtr geom,
section->width = sWire->width; section->width = sWire->width;
section->height = sWire->height; section->height = sWire->height;
section->angle = sWire->angle; section->angle = sWire->angle;
rWire = (xkbRowWireDesc *) & sWire[1]; rWire = (xkbRowWireDesc *) &sWire[1];
for (r = 0; r < sWire->nRows; r++) { for (r = 0; r < sWire->nRows; r++) {
register int k; register int k;
XkbRowPtr row; XkbRowPtr row;
@ -5179,7 +5179,7 @@ _CheckSetSections(XkbGeometryPtr geom,
row->top = rWire->top; row->top = rWire->top;
row->left = rWire->left; row->left = rWire->left;
row->vertical = rWire->vertical; row->vertical = rWire->vertical;
kWire = (xkbKeyWireDesc *) & rWire[1]; kWire = (xkbKeyWireDesc *) &rWire[1];
for (k = 0; k < rWire->nKeys; k++) { for (k = 0; k < rWire->nKeys; k++) {
XkbKeyPtr key; XkbKeyPtr key;
@ -5201,7 +5201,7 @@ _CheckSetSections(XkbGeometryPtr geom,
return BadMatch; return BadMatch;
} }
} }
rWire = (xkbRowWireDesc *) & kWire[rWire->nKeys]; rWire = (xkbRowWireDesc *) &kWire[rWire->nKeys];
} }
wire = (char *) rWire; wire = (char *) rWire;
if (sWire->nDoodads > 0) { if (sWire->nDoodads > 0) {
@ -5265,7 +5265,7 @@ _CheckSetShapes(XkbGeometryPtr geom,
if (!ol) if (!ol)
return BadAlloc; return BadAlloc;
ol->corner_radius = olWire->cornerRadius; ol->corner_radius = olWire->cornerRadius;
ptWire = (xkbPointWireDesc *) & olWire[1]; ptWire = (xkbPointWireDesc *) &olWire[1];
for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) { for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) {
pt->x = ptWire[p].x; pt->x = ptWire[p].x;
pt->y = ptWire[p].y; pt->y = ptWire[p].y;
@ -6348,7 +6348,7 @@ ProcXkbGetDeviceInfo(ClientPtr client)
xkbActionWireDesc *awire; xkbActionWireDesc *awire;
sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc); sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc);
awire = (xkbActionWireDesc *) & dev->button->xkb_acts[rep.firstBtnRtrn]; awire = (xkbActionWireDesc *) &dev->button->xkb_acts[rep.firstBtnRtrn];
WriteToClient(client, sz, awire); WriteToClient(client, sz, awire);
length -= sz; length -= sz;
} }

2
xkb/xkbout.c
View File

@ -522,7 +522,7 @@ XkbWriteXKBSymbols(FILE * file,
for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) { for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) {
if (s != 0) if (s != 0)
fprintf(file, ", "); fprintf(file, ", ");
WriteXKBAction(file, xkb, (XkbAnyAction *) & acts[s]); WriteXKBAction(file, xkb, (XkbAnyAction *) &acts[s]);
} }
fprintf(file, " ]"); fprintf(file, " ]");
acts += XkbKeyGroupsWidth(xkb, i); acts += XkbKeyGroupsWidth(xkb, i);