andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove unneccesary casts from WriteToClient calls

Browse Source 
Casting return to (void) was used to tell lint that you intended
to ignore the return value, so it didn't warn you about it.

Casting the third argument to (char *) was used as the most generic
pointer type in the days before compilers supported C89 (void *)
(except for a couple places it's used for byte-sized pointer math).

Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>
Reviewed-by: Keith Packard <keithp@keithp.com>
Tested-by: Daniel Stone <daniel@fooishbar.org>
This commit is contained in:
Alan Coopersmith 2012-05-13 00:03:35 -07:00
parent 329db32922
commit 789d64e19a
90 changed files with 464 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Xext/bigreq.c
View File

@ -64,7 +64,7 @@ ProcBigReqDispatch(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.max_request_size);
}
WriteToClient(client, sizeof(xBigReqEnableReply), (char *) &rep);
WriteToClient(client, sizeof(xBigReqEnableReply), &rep);
return Success;
}

8
Xext/dpms.c
View File

@ -59,7 +59,7 @@ ProcDPMSGetVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xDPMSGetVersionReply), &rep);
return Success;
}
@ -79,7 +79,7 @@ ProcDPMSCapable(ClientPtr client)
if (client->swapped) {
swaps(&rep.sequenceNumber);
}
WriteToClient(client, sizeof(xDPMSCapableReply), (char *) &rep);
WriteToClient(client, sizeof(xDPMSCapableReply), &rep);
return Success;
}
@ -104,7 +104,7 @@ ProcDPMSGetTimeouts(ClientPtr client)
swaps(&rep.suspend);
swaps(&rep.off);
}
WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *) &rep);
WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), &rep);
return Success;
}
@ -202,7 +202,7 @@ ProcDPMSInfo(ClientPtr client)
swaps(&rep.sequenceNumber);
swaps(&rep.power_level);
}
WriteToClient(client, sizeof(xDPMSInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xDPMSInfoReply), &rep);
return Success;
}

2
Xext/geext.c
View File

@ -85,7 +85,7 @@ ProcGEQueryVersion(ClientPtr client)
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xGEQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xGEQueryVersionReply), &rep);
return Success;
}

14
Xext/panoramiX.c
View File

@ -918,7 +918,7 @@ ProcPanoramiXQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), &rep);
return Success;
}
@ -945,7 +945,7 @@ ProcPanoramiXGetState(ClientPtr client)
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetStateReply), &rep);
return Success;
}
@ -973,7 +973,7 @@ ProcPanoramiXGetScreenCount(ClientPtr client)
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), &rep);
return Success;
}
@ -1009,7 +1009,7 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
swapl(&rep.window);
swapl(&rep.screen);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), &rep);
return Success;
}
@ -1038,7 +1038,7 @@ ProcXineramaIsActive(ClientPtr client)
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
WriteToClient(client, sizeof(xXineramaIsActiveReply), &rep);
return Success;
}
@ -1059,7 +1059,7 @@ ProcXineramaQueryScreens(ClientPtr client)
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *) &rep);
WriteToClient(client, sizeof(xXineramaQueryScreensReply), &rep);
if (!noPanoramiXExtension) {
xXineramaScreenInfo scratch;
@ -1077,7 +1077,7 @@ ProcXineramaQueryScreens(ClientPtr client)
swaps(&scratch.width);
swaps(&scratch.height);
}
WriteToClient(client, sz_XineramaScreenInfo, (char *) &scratch);
WriteToClient(client, sz_XineramaScreenInfo, &scratch);
}
}

5
Xext/panoramiXprocs.c
View File

@ -2003,7 +2003,7 @@ PanoramiXGetImage(ClientPtr client)
format, planemask, pBuf, widthBytesLine,
isRoot);
(void) WriteToClient(client, (int) (nlines * widthBytesLine), pBuf);
WriteToClient(client, (int) (nlines * widthBytesLine), pBuf);
linesDone += nlines;
}
}
@ -2020,8 +2020,7 @@ PanoramiXGetImage(ClientPtr client)
nlines, format, plane, pBuf,
widthBytesLine, isRoot);
(void) WriteToClient(client,
(int) (nlines * widthBytesLine), pBuf);
WriteToClient(client, (int)(nlines * widthBytesLine), pBuf);
linesDone += nlines;
}

4
Xext/saver.c
View File

@ -646,7 +646,7 @@ ProcScreenSaverQueryVersion(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xScreenSaverQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xScreenSaverQueryVersionReply), &rep);
return Success;
}
@ -717,7 +717,7 @@ ProcScreenSaverQueryInfo(ClientPtr client)
swapl(&rep.idle);
swapl(&rep.eventMask);
}
WriteToClient(client, sizeof(xScreenSaverQueryInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xScreenSaverQueryInfoReply), &rep);
return Success;
}

6
Xext/security.c
View File

@ -351,8 +351,7 @@ ProcSecurityQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
(void) WriteToClient(client, SIZEOF(xSecurityQueryVersionReply),
(char *) &rep);
WriteToClient(client, SIZEOF(xSecurityQueryVersionReply), &rep);
return Success;
} /* ProcSecurityQueryVersion */
@ -541,8 +540,7 @@ ProcSecurityGenerateAuthorization(ClientPtr client)
swaps(&rep.dataLength);
}
WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply),
(char *) &rep);
WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply), &rep);
WriteToClient(client, authdata_len, pAuthdata);
SecurityAudit

10
Xext/shape.c
View File

@ -219,7 +219,7 @@ ProcShapeQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xShapeQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xShapeQueryVersionReply), &rep);
return Success;
}
@ -679,7 +679,7 @@ ProcShapeQueryExtents(ClientPtr client)
swaps(&rep.widthClipShape);
swaps(&rep.heightClipShape);
}
WriteToClient(client, sizeof(xShapeQueryExtentsReply), (char *) &rep);
WriteToClient(client, sizeof(xShapeQueryExtentsReply), &rep);
return Success;
}
@ -928,7 +928,7 @@ ProcShapeInputSelected(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xShapeInputSelectedReply), (char *) &rep);
WriteToClient(client, sizeof(xShapeInputSelectedReply), &rep);
return Success;
}
@ -1012,8 +1012,8 @@ ProcShapeGetRectangles(ClientPtr client)
swapl(&rep.nrects);
SwapShorts((short *) rects, (unsigned long) nrects * 4);
}
WriteToClient(client, sizeof(rep), (char *) &rep);
WriteToClient(client, nrects * sizeof(xRectangle), (char *) rects);
WriteToClient(client, sizeof(rep), &rep);
WriteToClient(client, nrects * sizeof(xRectangle), rects);
free(rects);
return Success;
}

6
Xext/shm.c
View File

@ -306,7 +306,7 @@ ProcShmQueryVersion(ClientPtr client)
swaps(&rep.uid);
swaps(&rep.gid);
}
WriteToClient(client, sizeof(xShmQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xShmQueryVersionReply), &rep);
return Success;
}
@ -702,7 +702,7 @@ ProcShmGetImage(ClientPtr client)
swapl(&xgi.visual);
swapl(&xgi.size);
}
WriteToClient(client, sizeof(xShmGetImageReply), (char *) &xgi);
WriteToClient(client, sizeof(xShmGetImageReply), &xgi);
return Success;
}
@ -877,7 +877,7 @@ ProcPanoramiXShmGetImage(ClientPtr client)
swapl(&xgi.visual);
swapl(&xgi.size);
}
WriteToClient(client, sizeof(xShmGetImageReply), (char *) &xgi);
WriteToClient(client, sizeof(xShmGetImageReply), &xgi);
return Success;
}

14
Xext/sync.c
View File

@ -1198,7 +1198,7 @@ ProcSyncInitialize(ClientPtr client)
if (client->swapped) {
swaps(&rep.sequenceNumber);
}
WriteToClient(client, sizeof(rep), (char *) &rep);
WriteToClient(client, sizeof(rep), &rep);
return Success;
}
@ -1263,9 +1263,9 @@ ProcSyncListSystemCounters(ClientPtr client)
namelen));
}
WriteToClient(client, sizeof(rep), (char *) &rep);
WriteToClient(client, sizeof(rep), &rep);
if (len) {
WriteToClient(client, len, (char *) list);
WriteToClient(client, len, list);
free(list);
}
@ -1338,7 +1338,7 @@ ProcSyncGetPriority(ClientPtr client)
swapl(&rep.priority);
}
WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
WriteToClient(client, sizeof(xSyncGetPriorityReply), &rep);
return Success;
}
@ -1624,7 +1624,7 @@ ProcSyncQueryCounter(ClientPtr client)
swapl(&rep.value_hi);
swapl(&rep.value_lo);
}
WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
WriteToClient(client, sizeof(xSyncQueryCounterReply), &rep);
return Success;
}
@ -1809,7 +1809,7 @@ ProcSyncQueryAlarm(ClientPtr client)
swapl(&rep.delta_lo);
}
WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
WriteToClient(client, sizeof(xSyncQueryAlarmReply), &rep);
return Success;
}
@ -1966,7 +1966,7 @@ ProcSyncQueryFence(ClientPtr client)
swapl(&rep.length);
}
WriteToClient(client, sizeof(xSyncQueryFenceReply), (char *) &rep);
WriteToClient(client, sizeof(xSyncQueryFenceReply), &rep);
return client->noClientException;
}

6
Xext/xcmisc.c
View File

@ -58,7 +58,7 @@ ProcXCMiscGetVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXCMiscGetVersionReply), &rep);
return Success;
}
@ -80,7 +80,7 @@ ProcXCMiscGetXIDRange(ClientPtr client)
swapl(&rep.start_id);
swapl(&rep.count);
}
WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *) &rep);
WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), &rep);
return Success;
}
@ -111,7 +111,7 @@ ProcXCMiscGetXIDList(ClientPtr client)
swapl(&rep.length);
swapl(&rep.count);
}
WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *) &rep);
WriteToClient(client, sizeof(xXCMiscGetXIDListReply), &rep);
if (count) {
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, count * sizeof(XID), pids);

5
Xext/xf86bigfont.c
View File

@ -307,8 +307,7 @@ ProcXF86BigfontQueryVersion(ClientPtr client)
swapl(&reply.gid);
swapl(&reply.signature);
}
WriteToClient(client,
sizeof(xXF86BigfontQueryVersionReply), (char *) &reply);
WriteToClient(client, sizeof(xXF86BigfontQueryVersionReply), &reply);
return Success;
}
@ -644,7 +643,7 @@ ProcXF86BigfontQueryFont(ClientPtr client)
}
}
}
WriteToClient(client, rlength, (char *) reply);
WriteToClient(client, rlength, reply);
free(reply);
if (nCharInfos > 0) {
if (shmid == -1)

18
Xext/xres.c
View File

@ -209,7 +209,7 @@ ProcXResQueryVersion(ClientPtr client)
swaps(&rep.server_major);
swaps(&rep.server_minor);
}
WriteToClient(client, sizeof(xXResQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXResQueryVersionReply), &rep);
return Success;
}
@ -242,7 +242,7 @@ ProcXResQueryClients(ClientPtr client)
swapl(&rep.length);
swapl(&rep.num_clients);
}
WriteToClient(client, sizeof(xXResQueryClientsReply), (char *) &rep);
WriteToClient(client, sizeof(xXResQueryClientsReply), &rep);
if (num_clients) {
xXResClient scratch;
@ -255,7 +255,7 @@ ProcXResQueryClients(ClientPtr client)
swapl(&scratch.resource_base);
swapl(&scratch.resource_mask);
}
WriteToClient(client, sz_xXResClient, (char *) &scratch);
WriteToClient(client, sz_xXResClient, &scratch);
}
}
@ -310,8 +310,7 @@ ProcXResQueryClientResources(ClientPtr client)
swapl(&rep.num_types);
}
WriteToClient(client, sizeof(xXResQueryClientResourcesReply),
(char *) &rep);
WriteToClient(client, sizeof(xXResQueryClientResourcesReply), &rep);
if (num_types) {
xXResType scratch;
@ -337,7 +336,7 @@ ProcXResQueryClientResources(ClientPtr client)
swapl(&scratch.resource_type);
swapl(&scratch.count);
}
WriteToClient(client, sz_xXResType, (char *) &scratch);
WriteToClient(client, sz_xXResType, &scratch);
}
}
@ -486,8 +485,7 @@ ProcXResQueryClientPixmapBytes(ClientPtr client)
swapl(&rep.bytes);
swapl(&rep.bytes_overflow);
}
WriteToClient(client, sizeof(xXResQueryClientPixmapBytesReply),
(char *) &rep);
WriteToClient(client, sizeof(xXResQueryClientPixmapBytesReply), &rep);
return Success;
}
@ -679,7 +677,7 @@ ProcXResQueryClientIds (ClientPtr client)
swapl (&rep.numIds);
}
WriteToClient(client,sizeof(rep),(char*)&rep);
WriteToClient(client, sizeof(rep), &rep);
WriteFragmentsToClient(client, &ctx.response);
}
@ -1061,7 +1059,7 @@ ProcXResQueryResourceBytes (ClientPtr client)
SwapXResQueryResourceBytes(&ctx.response);
}
WriteToClient(client,sizeof(rep),(char*)&rep);
WriteToClient(client, sizeof(rep), &rep);
WriteFragmentsToClient(client, &ctx.response);
}

8
Xext/xselinux_ext.c
View File

@ -76,7 +76,7 @@ ProcSELinuxQueryVersion(ClientPtr client)
swaps(&rep.server_major);
swaps(&rep.server_minor);
}
WriteToClient(client, sizeof(rep), (char *) &rep);
WriteToClient(client, sizeof(rep), &rep);
return Success;
}
@ -104,7 +104,7 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
swapl(&rep.context_len);
}
WriteToClient(client, sizeof(SELinuxGetContextReply), (char *) &rep);
WriteToClient(client, sizeof(SELinuxGetContextReply), &rep);
WriteToClient(client, len, ctx);
freecon(ctx);
return Success;
@ -383,8 +383,8 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec * items,
swapl(&rep.count);
}
WriteToClient(client, sizeof(SELinuxListItemsReply), (char *) &rep);
WriteToClient(client, size * 4, (char *) buf);
WriteToClient(client, sizeof(SELinuxListItemsReply), &rep);
WriteToClient(client, size * 4, buf);
/* Free stuff and return */
rc = Success;

4
Xext/xtest.c
View File

@ -100,7 +100,7 @@ ProcXTestGetVersion(ClientPtr client)
swaps(&rep.sequenceNumber);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXTestGetVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXTestGetVersionReply), &rep);
return Success;
}
@ -141,7 +141,7 @@ ProcXTestCompareCursor(ClientPtr client)
if (client->swapped) {
swaps(&rep.sequenceNumber);
}
WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *) &rep);
WriteToClient(client, sizeof(xXTestCompareCursorReply), &rep);
return Success;
}

58
Xext/xvdisp.c
View File

@ -62,7 +62,7 @@ SWriteQueryExtensionReply(ClientPtr client, xvQueryExtensionReply * rep)
swaps(&rep->version);
swaps(&rep->revision);
(void) WriteToClient(client, sz_xvQueryExtensionReply, (char *) rep);
WriteToClient(client, sz_xvQueryExtensionReply, rep);
return Success;
}
@ -74,7 +74,7 @@ SWriteQueryAdaptorsReply(ClientPtr client, xvQueryAdaptorsReply * rep)
swapl(&rep->length);
swaps(&rep->num_adaptors);
(void) WriteToClient(client, sz_xvQueryAdaptorsReply, (char *) rep);
WriteToClient(client, sz_xvQueryAdaptorsReply, rep);
return Success;
}
@ -86,7 +86,7 @@ SWriteQueryEncodingsReply(ClientPtr client, xvQueryEncodingsReply * rep)
swapl(&rep->length);
swaps(&rep->num_encodings);
(void) WriteToClient(client, sz_xvQueryEncodingsReply, (char *) rep);
WriteToClient(client, sz_xvQueryEncodingsReply, rep);
return Success;
}
@ -99,7 +99,7 @@ SWriteAdaptorInfo(ClientPtr client, xvAdaptorInfo * pAdaptor)
swaps(&pAdaptor->num_ports);
swaps(&pAdaptor->num_formats);
(void) WriteToClient(client, sz_xvAdaptorInfo, (char *) pAdaptor);
WriteToClient(client, sz_xvAdaptorInfo, pAdaptor);
return Success;
}
@ -114,7 +114,7 @@ SWriteEncodingInfo(ClientPtr client, xvEncodingInfo * pEncoding)
swaps(&pEncoding->height);
swapl(&pEncoding->rate.numerator);
swapl(&pEncoding->rate.denominator);
(void) WriteToClient(client, sz_xvEncodingInfo, (char *) pEncoding);
WriteToClient(client, sz_xvEncodingInfo, pEncoding);
return Success;
}
@ -123,7 +123,7 @@ static int
SWriteFormat(ClientPtr client, xvFormat * pFormat)
{
swapl(&pFormat->visual);
(void) WriteToClient(client, sz_xvFormat, (char *) pFormat);
WriteToClient(client, sz_xvFormat, pFormat);
return Success;
}
@ -135,7 +135,7 @@ SWriteAttributeInfo(ClientPtr client, xvAttributeInfo * pAtt)
swapl(&pAtt->size);
swapl(&pAtt->min);
swapl(&pAtt->max);
(void) WriteToClient(client, sz_xvAttributeInfo, (char *) pAtt);
WriteToClient(client, sz_xvAttributeInfo, pAtt);
return Success;
}
@ -157,7 +157,7 @@ SWriteImageFormatInfo(ClientPtr client, xvImageFormatInfo * pImage)
swapl(&pImage->vert_u_period);
swapl(&pImage->vert_v_period);
(void) WriteToClient(client, sz_xvImageFormatInfo, (char *) pImage);
WriteToClient(client, sz_xvImageFormatInfo, pImage);
return Success;
}
@ -168,7 +168,7 @@ SWriteGrabPortReply(ClientPtr client, xvGrabPortReply * rep)
swaps(&rep->sequenceNumber);
swapl(&rep->length);
(void) WriteToClient(client, sz_xvGrabPortReply, (char *) rep);
WriteToClient(client, sz_xvGrabPortReply, rep);
return Success;
}
@ -180,7 +180,7 @@ SWriteGetPortAttributeReply(ClientPtr client, xvGetPortAttributeReply * rep)
swapl(&rep->length);
swapl(&rep->value);
(void) WriteToClient(client, sz_xvGetPortAttributeReply, (char *) rep);
WriteToClient(client, sz_xvGetPortAttributeReply, rep);
return Success;
}
@ -193,7 +193,7 @@ SWriteQueryBestSizeReply(ClientPtr client, xvQueryBestSizeReply * rep)
swaps(&rep->actual_width);
swaps(&rep->actual_height);
(void) WriteToClient(client, sz_xvQueryBestSizeReply, (char *) rep);
WriteToClient(client, sz_xvQueryBestSizeReply, rep);
return Success;
}
@ -207,7 +207,7 @@ SWriteQueryPortAttributesReply(ClientPtr client,
swapl(&rep->num_attributes);
swapl(&rep->text_size);
(void) WriteToClient(client, sz_xvQueryPortAttributesReply, (char *) rep);
WriteToClient(client, sz_xvQueryPortAttributesReply, rep);
return Success;
}
@ -223,7 +223,7 @@ SWriteQueryImageAttributesReply(ClientPtr client,
swaps(&rep->width);
swaps(&rep->height);
(void) WriteToClient(client, sz_xvQueryImageAttributesReply, (char *) rep);
WriteToClient(client, sz_xvQueryImageAttributesReply, rep);
return Success;
}
@ -235,66 +235,66 @@ SWriteListImageFormatsReply(ClientPtr client, xvListImageFormatsReply * rep)
swapl(&rep->length);
swapl(&rep->num_formats);
(void) WriteToClient(client, sz_xvListImageFormatsReply, (char *) rep);
WriteToClient(client, sz_xvListImageFormatsReply, rep);
return Success;
}
#define _WriteQueryAdaptorsReply(_c,_d) \
if ((_c)->swapped) SWriteQueryAdaptorsReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryAdaptorsReply, (char*)_d)
else WriteToClient(_c, sz_xvQueryAdaptorsReply, _d)
#define _WriteQueryExtensionReply(_c,_d) \
if ((_c)->swapped) SWriteQueryExtensionReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryExtensionReply, (char*)_d)
else WriteToClient(_c, sz_xvQueryExtensionReply, _d)
#define _WriteQueryEncodingsReply(_c,_d) \
if ((_c)->swapped) SWriteQueryEncodingsReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryEncodingsReply, (char*)_d)
else WriteToClient(_c, sz_xvQueryEncodingsReply, _d)
#define _WriteAdaptorInfo(_c,_d) \
if ((_c)->swapped) SWriteAdaptorInfo(_c, _d); \
else WriteToClient(_c, sz_xvAdaptorInfo, (char*)_d)
else WriteToClient(_c, sz_xvAdaptorInfo, _d)
#define _WriteAttributeInfo(_c,_d) \
if ((_c)->swapped) SWriteAttributeInfo(_c, _d); \
else WriteToClient(_c, sz_xvAttributeInfo, (char*)_d)
else WriteToClient(_c, sz_xvAttributeInfo, _d)
#define _WriteEncodingInfo(_c,_d) \
if ((_c)->swapped) SWriteEncodingInfo(_c, _d); \
else WriteToClient(_c, sz_xvEncodingInfo, (char*)_d)
else WriteToClient(_c, sz_xvEncodingInfo, _d)
#define _WriteFormat(_c,_d) \
if ((_c)->swapped) SWriteFormat(_c, _d); \
else WriteToClient(_c, sz_xvFormat, (char*)_d)
else WriteToClient(_c, sz_xvFormat, _d)
#define _WriteGrabPortReply(_c,_d) \
if ((_c)->swapped) SWriteGrabPortReply(_c, _d); \
else WriteToClient(_c, sz_xvGrabPortReply, (char*)_d)
else WriteToClient(_c, sz_xvGrabPortReply, _d)
#define _WriteGetPortAttributeReply(_c,_d) \
if ((_c)->swapped) SWriteGetPortAttributeReply(_c, _d); \
else WriteToClient(_c, sz_xvGetPortAttributeReply, (char*)_d)
else WriteToClient(_c, sz_xvGetPortAttributeReply, _d)
#define _WriteQueryBestSizeReply(_c,_d) \
if ((_c)->swapped) SWriteQueryBestSizeReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryBestSizeReply,(char*) _d)
else WriteToClient(_c, sz_xvQueryBestSizeReply, _d)
#define _WriteQueryPortAttributesReply(_c,_d) \
if ((_c)->swapped) SWriteQueryPortAttributesReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryPortAttributesReply,(char*) _d)
else WriteToClient(_c, sz_xvQueryPortAttributesReply, _d)
#define _WriteQueryImageAttributesReply(_c,_d) \
if ((_c)->swapped) SWriteQueryImageAttributesReply(_c, _d); \
else WriteToClient(_c, sz_xvQueryImageAttributesReply,(char*) _d)
else WriteToClient(_c, sz_xvQueryImageAttributesReply, _d)
#define _WriteListImageFormatsReply(_c,_d) \
if ((_c)->swapped) SWriteListImageFormatsReply(_c, _d); \
else WriteToClient(_c, sz_xvListImageFormatsReply,(char*) _d)
else WriteToClient(_c, sz_xvListImageFormatsReply, _d)
#define _WriteImageFormatInfo(_c,_d) \
if ((_c)->swapped) SWriteImageFormatInfo(_c, _d); \
else WriteToClient(_c, sz_xvImageFormatInfo, (char*)_d)
else WriteToClient(_c, sz_xvImageFormatInfo, _d)
#define _AllocatePort(_i,_p) \
((_p)->id != _i) ? (* (_p)->pAdaptor->ddAllocatePort)(_i,_p,&_p) : Success
@ -1100,7 +1100,7 @@ ProcXvQueryImageAttributes(ClientPtr client)
_WriteQueryImageAttributesReply(client, &rep);
if (client->swapped)
SwapLongs((CARD32 *) offsets, planeLength);
WriteToClient(client, planeLength << 2, (char *) offsets);
WriteToClient(client, planeLength << 2, offsets);
free(offsets);

24
Xext/xvmc.c
View File

@ -118,7 +118,7 @@ ProcXvMCQueryVersion(ClientPtr client)
rep.length = 0;
rep.major = SERVER_XVMC_MAJOR_VERSION;
rep.minor = SERVER_XVMC_MINOR_VERSION;
WriteToClient(client, sizeof(xvmcQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcQueryVersionReply), &rep);
return Success;
}
@ -156,7 +156,7 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
rep.num = (adaptor) ? adaptor->num_surfaces : 0;
rep.length = bytes_to_int32(rep.num * sizeof(xvmcSurfaceInfo));
WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), &rep);
for (i = 0; i < rep.num; i++) {
surface = adaptor->surfaces[i];
@ -168,7 +168,7 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
info.subpicture_max_height = surface->subpicture_max_height;
info.mc_type = surface->mc_type;
info.flags = surface->flags;
WriteToClient(client, sizeof(xvmcSurfaceInfo), (char *) &info);
WriteToClient(client, sizeof(xvmcSurfaceInfo), &info);
}
return Success;
@ -254,9 +254,9 @@ ProcXvMCCreateContext(ClientPtr client)
rep.flags_return = pContext->flags;
rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateContextReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcCreateContextReply), &rep);
if (dwords)
WriteToClient(client, dwords << 2, (char *) data);
WriteToClient(client, dwords << 2, data);
AddResource(pContext->context_id, XvMCRTContext, pContext);
free(data);
@ -325,9 +325,9 @@ ProcXvMCCreateSurface(ClientPtr client)
rep.sequenceNumber = client->sequence;
rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcCreateSurfaceReply), &rep);
if (dwords)
WriteToClient(client, dwords << 2, (char *) data);
WriteToClient(client, dwords << 2, data);
AddResource(pSurface->surface_id, XvMCRTSurface, pSurface);
free(data);
@ -448,9 +448,9 @@ ProcXvMCCreateSubpicture(ClientPtr client)
rep.component_order[3] = pSubpicture->component_order[3];
rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcCreateSubpictureReply), &rep);
if (dwords)
WriteToClient(client, dwords << 2, (char *) data);
WriteToClient(client, dwords << 2, data);
AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture);
free(data);
@ -533,7 +533,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
rep.length = bytes_to_int32(rep.num * sizeof(xvImageFormatInfo));
WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), &rep);
for (i = 0; i < rep.num; i++) {
pImage = NULL;
@ -569,7 +569,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
info.vert_v_period = pImage->vert_v_period;
memcpy(&info.comp_order, pImage->component_order, 32);
info.scanline_order = pImage->scanline_order;
WriteToClient(client, sizeof(xvImageFormatInfo), (char *) &info);
WriteToClient(client, sizeof(xvImageFormatInfo), &info);
}
return Success;
@ -634,7 +634,7 @@ ProcXvMCGetDRInfo(ClientPtr client)
}
#endif /* HAS_XVMCSHM */
WriteToClient(client, sizeof(xvmcGetDRInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xvmcGetDRInfoReply), &rep);
if (rep.length) {
WriteToClient(client, rep.nameLen, pScreenPriv->clientDriverName);
WriteToClient(client, rep.busIDLen, pScreenPriv->busID);

2
Xi/chgdctl.c
View File

@ -236,5 +236,5 @@ SRepXChangeDeviceControl(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

4
Xi/getbmap.c
View File

@ -109,7 +109,7 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
rep.nElts = b->numButtons;
rep.length = bytes_to_int32(rep.nElts);
WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
(void) WriteToClient(client, rep.nElts, (char *) &b->map[1]);
WriteToClient(client, rep.nElts, &b->map[1]);
return Success;
}
@ -126,5 +126,5 @@ SRepXGetDeviceButtonMapping(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/getdctl.c
View File

@ -158,7 +158,7 @@ SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
/***********************************************************************

2
Xi/getfctl.c
View File

@ -265,7 +265,7 @@ SRepXGetFeedbackControl(ClientPtr client, int size,
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->num_feedbacks);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
/***********************************************************************

2
Xi/getfocus.c
View File

@ -135,5 +135,5 @@ SRepXGetDeviceFocus(ClientPtr client, int size, xGetDeviceFocusReply * rep)
swapl(&rep->length);
swapl(&rep->focus);
swapl(&rep->time);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/getkmap.c
View File

@ -150,5 +150,5 @@ SRepXGetDeviceKeyMapping(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

4
Xi/getmmap.c
View File

@ -109,7 +109,7 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
rep.length = max_keys_per_mod << 1;
WriteReplyToClient(client, sizeof(xGetDeviceModifierMappingReply), &rep);
WriteToClient(client, max_keys_per_mod * 8, (char *) modkeymap);
WriteToClient(client, max_keys_per_mod * 8, modkeymap);
free(modkeymap);
@ -129,5 +129,5 @@ SRepXGetDeviceModifierMapping(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/getprop.c
View File

@ -178,5 +178,5 @@ SRepXGetDeviceDontPropagateList(ClientPtr client, int size,
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->count);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/getselev.c
View File

@ -170,5 +170,5 @@ SRepXGetSelectedExtensionEvents(ClientPtr client, int size,
swapl(&rep->length);
swaps(&rep->this_client_count);
swaps(&rep->all_clients_count);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/getvers.c
View File

@ -127,5 +127,5 @@ SRepXGetExtensionVersion(ClientPtr client, int size,
swapl(&rep->length);
swaps(&rep->major_version);
swaps(&rep->minor_version);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/grabdev.c
View File

@ -211,5 +211,5 @@ SRepXGrabDevice(ClientPtr client, int size, xGrabDeviceReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

4
Xi/gtmotion.c
View File

@ -147,7 +147,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
bufptr++;
}
}
WriteToClient(client, length * 4, (char *) coords);
WriteToClient(client, length * 4, coords);
}
free(coords);
return Success;
@ -167,5 +167,5 @@ SRepXGetDeviceMotionEvents(ClientPtr client, int size,
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->nEvents);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/listdev.c
View File

@ -417,5 +417,5 @@ SRepXListInputDevices(ClientPtr client, int size, xListInputDevicesReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

4
Xi/opendev.c
View File

@ -151,7 +151,7 @@ ProcXOpenDevice(ClientPtr client)
rep.length = bytes_to_int32(j * sizeof(xInputClassInfo));
rep.num_classes = j;
WriteReplyToClient(client, sizeof(xOpenDeviceReply), &rep);
WriteToClient(client, j * sizeof(xInputClassInfo), (char *) evbase);
WriteToClient(client, j * sizeof(xInputClassInfo), evbase);
return Success;
}
@ -167,5 +167,5 @@ SRepXOpenDevice(ClientPtr client, int size, xOpenDeviceReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/queryst.c
View File

@ -184,5 +184,5 @@ SRepXQueryDeviceState(ClientPtr client, int size, xQueryDeviceStateReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/setbmap.c
View File

@ -134,5 +134,5 @@ SRepXSetDeviceButtonMapping(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/setdval.c
View File

@ -138,5 +138,5 @@ SRepXSetDeviceValuators(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/setmmap.c
View File

@ -140,5 +140,5 @@ SRepXSetDeviceModifierMapping(ClientPtr client, int size,
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/setmode.c
View File

@ -137,5 +137,5 @@ SRepXSetDeviceMode(ClientPtr client, int size, xSetDeviceModeReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/xigetclientpointer.c
View File

@ -100,5 +100,5 @@ SRepXIGetClientPointer(ClientPtr client, int size,
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->deviceid);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/xigrabdev.c
View File

@ -156,5 +156,5 @@ SRepXIGrabDevice(ClientPtr client, int size, xXIGrabDeviceReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

4
Xi/xipassivegrab.c
View File

@ -224,7 +224,7 @@ ProcXIPassiveGrabDevice(ClientPtr client)
WriteReplyToClient(client, sizeof(rep), &rep);
if (rep.num_modifiers)
WriteToClient(client, rep.length * 4, (char *) modifiers_failed);
WriteToClient(client, rep.length * 4, modifiers_failed);
free(modifiers_failed);
out:
@ -240,7 +240,7 @@ SRepXIPassiveGrabDevice(ClientPtr client, int size,
swapl(&rep->length);
swaps(&rep->num_modifiers);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
int

8
Xi/xiproperty.c
View File

@ -1063,7 +1063,7 @@ SRepXListDeviceProperties(ClientPtr client, int size,
swapl(&rep->length);
swaps(&rep->nAtoms);
/* properties will be swapped later, see ProcXListDeviceProperties */
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
void
@ -1076,7 +1076,7 @@ SRepXGetDeviceProperty(ClientPtr client, int size,
swapl(&rep->bytesAfter);
swapl(&rep->nItems);
/* data will be swapped, see ProcXGetDeviceProperty */
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
/* XI2 Request/reply handling */
@ -1300,7 +1300,7 @@ SRepXIListProperties(ClientPtr client, int size, xXIListPropertiesReply * rep)
swapl(&rep->length);
swaps(&rep->num_properties);
/* properties will be swapped later, see ProcXIListProperties */
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
void
@ -1312,5 +1312,5 @@ SRepXIGetProperty(ClientPtr client, int size, xXIGetPropertyReply * rep)
swapl(&rep->bytes_after);
swapl(&rep->num_items);
/* data will be swapped, see ProcXIGetProperty */
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/xiquerydevice.c
View File

@ -162,7 +162,7 @@ SRepXIQueryDevice(ClientPtr client, int size, xXIQueryDeviceReply * rep)
/* Device info is already swapped, see ProcXIQueryDevice */
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}
/**

2
Xi/xiquerypointer.c
View File

@ -219,5 +219,5 @@ SRepXIQueryPointer(ClientPtr client, int size, xXIQueryPointerReply * rep)
swapl(&rep->win_y);
swaps(&rep->buttons_len);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/xiqueryversion.c
View File

@ -126,5 +126,5 @@ SRepXIQueryVersion(ClientPtr client, int size, xXIQueryVersionReply * rep)
swapl(&rep->length);
swaps(&rep->major_version);
swaps(&rep->minor_version);
WriteToClient(client, size, (char *) rep);
WriteToClient(client, size, rep);
}

2
Xi/xiselectev.c
View File

@ -335,5 +335,5 @@ SRepXIGetSelectedEvents(ClientPtr client,
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->num_masks);
WriteToClient(client, len, (char *) rep);
WriteToClient(client, len, rep);
}

2
Xi/xisetdevfocus.c
View File

@ -121,5 +121,5 @@ SRepXIGetFocus(ClientPtr client, int len, xXIGetFocusReply * rep)
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->focus);
WriteToClient(client, len, (char *) rep);
WriteToClient(client, len, rep);
}

8
composite/compext.c
View File

@ -131,7 +131,7 @@ ProcCompositeQueryVersion(ClientPtr client)
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xCompositeQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xCompositeQueryVersionReply), &rep);
return Success;
}
@ -321,8 +321,7 @@ ProcCompositeGetOverlayWindow(ClientPtr client)
swapl(&rep.length);
swapl(&rep.overlayWin);
}
(void) WriteToClient(client, sz_xCompositeGetOverlayWindowReply,
(char *) &rep);
WriteToClient(client, sz_xCompositeGetOverlayWindowReply, &rep);
return Success;
}
@ -853,8 +852,7 @@ PanoramiXCompositeGetOverlayWindow(ClientPtr client)
swapl(&rep.length);
swapl(&rep.overlayWin);
}
(void) WriteToClient(client, sz_xCompositeGetOverlayWindowReply,
(char *) &rep);
WriteToClient(client, sz_xCompositeGetOverlayWindowReply, &rep);
return Success;
}

2
damageext/damageext.c
View File

@ -154,7 +154,7 @@ ProcDamageQueryVersion(ClientPtr client)
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xDamageQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xDamageQueryVersionReply), &rep);
return Success;
}

12
dbe/dbe.c
View File

@ -132,7 +132,7 @@ ProcDbeGetVersion(ClientPtr client)
swaps(&rep.sequenceNumber);
}
WriteToClient(client, sizeof(xDbeGetVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xDbeGetVersionReply), &rep);
return Success;
@ -679,7 +679,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
}
/* Send off reply. */
WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xDbeGetVisualInfoReply), &rep);
for (i = 0; i < count; i++) {
CARD32 data32;
@ -693,7 +693,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
swapl(&data32);
}
WriteToClient(client, sizeof(CARD32), (char *) &data32);
WriteToClient(client, sizeof(CARD32), &data32);
/* Now send off visual info items. */
for (j = 0; j < pScrVisInfo[i].count; j++) {
@ -717,8 +717,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
}
/* Write visualID(32), depth(8), perfLevel(8), and pad(16). */
WriteToClient(client, 2 * sizeof(CARD32),
(char *) &visInfo.visualID);
WriteToClient(client, 2 * sizeof(CARD32), &visInfo.visualID);
}
}
@ -782,8 +781,7 @@ ProcDbeGetBackBufferAttributes(ClientPtr client)
swapl(&rep.attributes);
}
WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),
(char *) &rep);
WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply), &rep);
return Success;
} /* ProcDbeGetbackBufferAttributes() */

4
dix/devices.c
View File

@ -1704,7 +1704,7 @@ ProcGetModifierMapping(ClientPtr client)
rep.length = max_keys_per_mod << 1;
WriteReplyToClient(client, sizeof(xGetModifierMappingReply), &rep);
(void) WriteToClient(client, max_keys_per_mod * 8, (char *) modkeymap);
WriteToClient(client, max_keys_per_mod * 8, modkeymap);
free(modkeymap);
@ -1898,7 +1898,7 @@ ProcGetPointerMapping(ClientPtr client)
rep.length = ((unsigned) rep.nElts + (4 - 1)) / 4;
WriteReplyToClient(client, sizeof(xGetPointerMappingReply), &rep);
if (butc)
WriteToClient(client, (int) rep.nElts, (char *) &butc->map[1]);
WriteToClient(client, (int) rep.nElts, &butc->map[1]);
return Success;
}

24
dix/dispatch.c
View File

@ -1035,7 +1035,7 @@ ProcGetAtomName(ClientPtr client)
reply.sequenceNumber = client->sequence;
reply.nameLength = len;
WriteReplyToClient(client, sizeof(xGetAtomNameReply), &reply);
(void) WriteToClient(client, len, str);
WriteToClient(client, len, str);
return Success;
}
else {
@ -2143,8 +2143,7 @@ DoGetImage(ClientPtr client, int format, Drawable drawable,
BitsPerPixel(pDraw->depth), ClientOrder(client));
/* Don't split me, gcc pukes when you do */
(void) WriteToClient(client,
(int) (nlines * widthBytesLine), pBuf);
WriteToClient(client, (int) (nlines * widthBytesLine), pBuf);
}
linesDone += nlines;
}
@ -2179,9 +2178,8 @@ DoGetImage(ClientPtr client, int format, Drawable drawable,
1, ClientOrder(client));
/* Don't split me, gcc pukes when you do */
(void) WriteToClient(client,
(int) (nlines * widthBytesLine),
pBuf);
WriteToClient(client, (int) (nlines * widthBytesLine),
pBuf);
}
linesDone += nlines;
}
@ -3250,8 +3248,7 @@ ProcGetFontPath(ClientPtr client)
WriteReplyToClient(client, sizeof(xGetFontPathReply), &reply);
if (stringLens || numpaths)
(void) WriteToClient(client, stringLens + numpaths,
(char *) bufferStart);
WriteToClient(client, stringLens + numpaths, bufferStart);
return Success;
}
@ -3523,8 +3520,8 @@ SendConnSetup(ClientPtr client, const char *reason)
if (client->swapped)
WriteSConnSetupPrefix(client, &csp);
else
(void) WriteToClient(client, sz_xConnSetupPrefix, (char *) &csp);
(void) WriteToClient(client, (int) csp.lengthReason, reason);
WriteToClient(client, sz_xConnSetupPrefix, &csp);
WriteToClient(client, (int) csp.lengthReason, reason);
return client->noClientException = -1;
}
@ -3577,10 +3574,9 @@ SendConnSetup(ClientPtr client, const char *reason)
lConnectionInfo);
}
else {
(void) WriteToClient(client, sizeof(xConnSetupPrefix),
(char *) lconnSetupPrefix);
(void) WriteToClient(client, (int) (lconnSetupPrefix->length << 2),
lConnectionInfo);
WriteToClient(client, sizeof(xConnSetupPrefix), lconnSetupPrefix);
WriteToClient(client, (int) (lconnSetupPrefix->length << 2),
lConnectionInfo);
}
client->clientState = ClientStateRunning;
if (ClientStateCallback) {

4
dix/dixfonts.c
View File

@ -782,7 +782,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
reply.length = bytes_to_int32(stringLens + nnames);
client->pSwapReplyFunc = ReplySwapVector[X_ListFonts];
WriteSwappedDataToClient(client, sizeof(xListFontsReply), &reply);
(void) WriteToClient(client, stringLens + nnames, bufferStart);
WriteToClient(client, stringLens + nnames, bufferStart);
free(bufferStart);
bail:
@ -1020,7 +1020,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
pFP++;
}
WriteSwappedDataToClient(client, length, reply);
(void) WriteToClient(client, namelen, name);
WriteToClient(client, namelen, name);
if (pFontInfo == &fontInfo) {
free(fontInfo.props);
free(fontInfo.isStringProp);

4
dix/events.c
View File

@ -5898,14 +5898,14 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
(*EventSwapVector[eventFrom->u.u.type & 0177])
(eventFrom, eventTo);
WriteToClient(pClient, eventlength, (char *) eventTo);
WriteToClient(pClient, eventlength, eventTo);
}
}
else {
/* only one GenericEvent, remember? that means either count is 1 and
* eventlength is arbitrary or eventlength is 32 and count doesn't
* matter. And we're all set. Woohoo. */
WriteToClient(pClient, count * eventlength, (char *) events);
WriteToClient(pClient, count * eventlength, events);
}
}

88
dix/swaprep.c
View File

@ -80,7 +80,7 @@ Swap32Write(ClientPtr pClient, int size, CARD32 *pbuf)
{
swapl(&pbuf[i]);
}
(void) WriteToClient(pClient, size << 2, (char *) pbuf);
WriteToClient(pClient, size << 2, pbuf);
}
/**
@ -123,7 +123,7 @@ CopySwap32Write(ClientPtr pClient, int size, CARD32 *pbuf)
from++;
to++;
}
(void) WriteToClient(pClient, nbytes, (char *) pbufT);
WriteToClient(pClient, nbytes, pbufT);
}
if (pbufT != tmpbuf)
@ -170,7 +170,7 @@ CopySwap16Write(ClientPtr pClient, int size, short *pbuf)
from++;
to++;
}
(void) WriteToClient(pClient, nbytes, (char *) pbufT);
WriteToClient(pClient, nbytes, pbufT);
}
if (pbufT != tmpbuf)
@ -182,7 +182,7 @@ void
SGenericReply(ClientPtr pClient, int size, xGenericReply * pRep)
{
swaps(&pRep->sequenceNumber);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
/* Extra-large reply */
@ -200,7 +200,7 @@ SGetWindowAttributesReply(ClientPtr pClient, int size,
swapl(&pRep->allEventMasks);
swapl(&pRep->yourEventMask);
swaps(&pRep->doNotPropagateMask);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -213,7 +213,7 @@ SGetGeometryReply(ClientPtr pClient, int size, xGetGeometryReply * pRep)
swaps(&pRep->width);
swaps(&pRep->height);
swaps(&pRep->borderWidth);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -224,7 +224,7 @@ SQueryTreeReply(ClientPtr pClient, int size, xQueryTreeReply * pRep)
swapl(&pRep->root);
swapl(&pRep->parent);
swaps(&pRep->nChildren);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -232,7 +232,7 @@ SInternAtomReply(ClientPtr pClient, int size, xInternAtomReply * pRep)
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->atom);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -241,7 +241,7 @@ SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nameLength);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -252,7 +252,7 @@ SGetPropertyReply(ClientPtr pClient, int size, xGetPropertyReply * pRep)
swapl(&pRep->propertyType);
swapl(&pRep->bytesAfter);
swapl(&pRep->nItems);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -261,7 +261,7 @@ SListPropertiesReply(ClientPtr pClient, int size, xListPropertiesReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nProperties);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -270,7 +270,7 @@ SGetSelectionOwnerReply(ClientPtr pClient, int size,
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->owner);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -284,7 +284,7 @@ SQueryPointerReply(ClientPtr pClient, int size, xQueryPointerReply * pRep)
swaps(&pRep->winX);
swaps(&pRep->winY);
swaps(&pRep->mask);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
static void
@ -307,7 +307,7 @@ SwapTimeCoordWrite(ClientPtr pClient, int size, xTimecoord * pRep)
SwapTimecoord(pRepT);
pRepT++;
}
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
@ -317,7 +317,7 @@ SGetMotionEventsReply(ClientPtr pClient, int size, xGetMotionEventsReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swapl(&pRep->nEvents);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -327,7 +327,7 @@ STranslateCoordsReply(ClientPtr pClient, int size, xTranslateCoordsReply * pRep)
swapl(&pRep->child);
swaps(&pRep->dstX);
swaps(&pRep->dstY);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -335,7 +335,7 @@ SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply * pRep)
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->focus);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
/* extra long reply */
@ -344,7 +344,7 @@ SQueryKeymapReply(ClientPtr pClient, int size, xQueryKeymapReply * pRep)
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
static void
@ -405,7 +405,7 @@ void
SQueryFontReply(ClientPtr pClient, int size, xQueryFontReply * pRep)
{
SwapFont(pRep, TRUE);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -420,7 +420,7 @@ SQueryTextExtentsReply(ClientPtr pClient, int size,
swapl(&pRep->overallWidth);
swapl(&pRep->overallLeft);
swapl(&pRep->overallRight);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -429,7 +429,7 @@ SListFontsReply(ClientPtr pClient, int size, xListFontsReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nFonts);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -437,7 +437,7 @@ SListFontsWithInfoReply(ClientPtr pClient, int size,
xListFontsWithInfoReply * pRep)
{
SwapFont((xQueryFontReply *) pRep, FALSE);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -446,7 +446,7 @@ SGetFontPathReply(ClientPtr pClient, int size, xGetFontPathReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nPaths);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -455,7 +455,7 @@ SGetImageReply(ClientPtr pClient, int size, xGetImageReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swapl(&pRep->visual);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
/* Fortunately, image doesn't need swapping */
}
@ -466,7 +466,7 @@ SListInstalledColormapsReply(ClientPtr pClient, int size,
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nColormaps);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -477,7 +477,7 @@ SAllocColorReply(ClientPtr pClient, int size, xAllocColorReply * pRep)
swaps(&pRep->green);
swaps(&pRep->blue);
swapl(&pRep->pixel);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -491,7 +491,7 @@ SAllocNamedColorReply(ClientPtr pClient, int size, xAllocNamedColorReply * pRep)
swaps(&pRep->screenRed);
swaps(&pRep->screenGreen);
swaps(&pRep->screenBlue);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -501,7 +501,7 @@ SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply * pRep)
swapl(&pRep->length);
swaps(&pRep->nPixels);
swaps(&pRep->nMasks);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -514,7 +514,7 @@ SAllocColorPlanesReply(ClientPtr pClient, int size,
swapl(&pRep->redMask);
swapl(&pRep->greenMask);
swapl(&pRep->blueMask);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
static void
@ -537,7 +537,7 @@ SQColorsExtend(ClientPtr pClient, int size, xrgb * prgb)
SwapRGB(prgbT);
prgbT++;
}
(void) WriteToClient(pClient, size, (char *) prgb);
WriteToClient(pClient, size, prgb);
}
void
@ -546,7 +546,7 @@ SQueryColorsReply(ClientPtr pClient, int size, xQueryColorsReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nColors);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -559,7 +559,7 @@ SLookupColorReply(ClientPtr pClient, int size, xLookupColorReply * pRep)
swaps(&pRep->screenRed);
swaps(&pRep->screenGreen);
swaps(&pRep->screenBlue);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -568,7 +568,7 @@ SQueryBestSizeReply(ClientPtr pClient, int size, xQueryBestSizeReply * pRep)
swaps(&pRep->sequenceNumber);
swaps(&pRep->width);
swaps(&pRep->height);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -576,7 +576,7 @@ SListExtensionsReply(ClientPtr pClient, int size, xListExtensionsReply * pRep)
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -585,7 +585,7 @@ SGetKeyboardMappingReply(ClientPtr pClient, int size,
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -594,7 +594,7 @@ SGetPointerMappingReply(ClientPtr pClient, int size,
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -603,7 +603,7 @@ SGetModifierMappingReply(ClientPtr pClient, int size,
{
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -615,7 +615,7 @@ SGetKeyboardControlReply(ClientPtr pClient, int size,
swapl(&pRep->ledMask);
swaps(&pRep->bellPitch);
swaps(&pRep->bellDuration);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -626,7 +626,7 @@ SGetPointerControlReply(ClientPtr pClient, int size,
swaps(&pRep->accelNumerator);
swaps(&pRep->accelDenominator);
swaps(&pRep->threshold);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -635,7 +635,7 @@ SGetScreenSaverReply(ClientPtr pClient, int size, xGetScreenSaverReply * pRep)
swaps(&pRep->sequenceNumber);
swaps(&pRep->timeout);
swaps(&pRep->interval);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -651,7 +651,7 @@ SLHostsExtend(ClientPtr pClient, int size, char *buf)
swaps(&host->length);
bufT += sizeof(xHostEntry) + pad_to_int32(len);
}
(void) WriteToClient(pClient, size, buf);
WriteToClient(pClient, size, buf);
}
void
@ -660,7 +660,7 @@ SListHostsReply(ClientPtr pClient, int size, xListHostsReply * pRep)
swaps(&pRep->sequenceNumber);
swapl(&pRep->length);
swaps(&pRep->nHosts);
(void) WriteToClient(pClient, size, (char *) pRep);
WriteToClient(pClient, size, pRep);
}
void
@ -1140,7 +1140,7 @@ WriteSConnectionInfo(ClientPtr pClient, unsigned long size, char *pInfo)
return;
}
SwapConnSetupInfo(pInfo, pInfoTBase);
(void) WriteToClient(pClient, (int) size, (char *) pInfoTBase);
WriteToClient(pClient, (int) size, pInfoTBase);
free(pInfoTBase);
}
@ -1160,7 +1160,7 @@ WriteSConnSetupPrefix(ClientPtr pClient, xConnSetupPrefix * pcsp)
xConnSetupPrefix cspT;
SwapConnSetupPrefix(pcsp, &cspT);
(void) WriteToClient(pClient, sizeof(cspT), (char *) &cspT);
WriteToClient(pClient, sizeof(cspT), &cspT);
}
/*

29
glx/glxcmds.c
View File

@ -667,7 +667,7 @@ DoMakeCurrent(__GLXclientState * cl,
__glXSwapMakeCurrentReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXMakeCurrentReply, (char *) &reply);
WriteToClient(client, sz_xGLXMakeCurrentReply, &reply);
}
return Success;
}
@ -731,7 +731,7 @@ __glXDisp_IsDirect(__GLXclientState * cl, GLbyte * pc)
__glXSwapIsDirectReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXIsDirectReply, (char *) &reply);
WriteToClient(client, sz_xGLXIsDirectReply, &reply);
}
return Success;
@ -767,7 +767,7 @@ __glXDisp_QueryVersion(__GLXclientState * cl, GLbyte * pc)
__glXSwapQueryVersionReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXQueryVersionReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryVersionReply, &reply);
}
return Success;
}
@ -949,7 +949,7 @@ __glXDisp_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&reply.numProps);
}
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);
for (i = 0; i < pGlxScreen->numVisuals; i++) {
modes = pGlxScreen->visuals[i];
@ -1006,7 +1006,7 @@ __glXDisp_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
if (client->swapped) {
__GLX_SWAP_INT_ARRAY(buf, p);
}
WriteToClient(client, __GLX_SIZE_CARD32 * p, (char *) buf);
WriteToClient(client, __GLX_SIZE_CARD32 * p, buf);
}
return Success;
}
@ -1052,7 +1052,7 @@ DoGetFBConfigs(__GLXclientState * cl, unsigned screen)
__GLX_SWAP_INT(&reply.numAttribs);
}
WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetFBConfigsReply, &reply);
for (modes = pGlxScreen->fbconfigs; modes != NULL; modes = modes->next) {
p = 0;
@ -1685,8 +1685,8 @@ DoQueryContext(__GLXclientState * cl, GLXContextID gcId)
__glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
}
else {
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *) &reply);
WriteToClient(client, nReplyBytes, (char *) sendBuf);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, &reply);
WriteToClient(client, nReplyBytes, sendBuf);
}
free((char *) sendBuf);
@ -1887,10 +1887,8 @@ DoGetDrawableAttributes(__GLXclientState * cl, XID drawId)
__glXSwapGetDrawableAttributesReply(client, &reply, attributes);
}
else {
WriteToClient(client, sz_xGLXGetDrawableAttributesReply,
(char *) &reply);
WriteToClient(client, reply.length * sizeof(CARD32),
(char *) attributes);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, &reply);
WriteToClient(client, reply.length * sizeof(CARD32), attributes);
}
return Success;
@ -2326,9 +2324,8 @@ __glXDisp_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
glxSwapQueryExtensionsStringReply(client, &reply, buf);
}
else {
WriteToClient(client, sz_xGLXQueryExtensionsStringReply,
(char *) &reply);
WriteToClient(client, (int) (length << 2), (char *) buf);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, &reply);
WriteToClient(client, (int) (length << 2), buf);
}
free(buf);
@ -2388,7 +2385,7 @@ __glXDisp_QueryServerString(__GLXclientState * cl, GLbyte * pc)
glxSwapQueryServerStringReply(client, &reply, buf);
}
else {
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);
WriteToClient(client, (int) (length << 2), buf);
}

18
glx/glxcmdsswap.c
View File

@ -840,7 +840,7 @@ __glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReply * reply)
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->contextTag);
WriteToClient(client, sz_xGLXMakeCurrentReply, (char *) reply);
WriteToClient(client, sz_xGLXMakeCurrentReply, reply);
}
void
@ -849,7 +849,7 @@ __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
WriteToClient(client, sz_xGLXIsDirectReply, (char *) reply);
WriteToClient(client, sz_xGLXIsDirectReply, reply);
}
void
@ -860,7 +860,7 @@ __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply * reply)
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->majorVersion);
__GLX_SWAP_INT(&reply->minorVersion);
WriteToClient(client, sz_xGLXQueryVersionReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryVersionReply, reply);
}
void
@ -875,7 +875,7 @@ glxSwapQueryExtensionsStringReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, buf);
}
@ -890,7 +890,7 @@ glxSwapQueryServerStringReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryServerStringReply, reply);
/** no swap is needed for an array of chars **/
/* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
WriteToClient(client, length << 2, buf);
@ -908,9 +908,9 @@ __glXSwapQueryContextInfoEXTReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, (char *) buf);
WriteToClient(client, length << 2, buf);
}
void
@ -925,9 +925,9 @@ __glXSwapGetDrawableAttributesReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->numAttribs);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *) reply);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, (char *) buf);
WriteToClient(client, length << 2, buf);
}
/************************************************************************/

8
glx/indirect_util.c
View File

@ -138,10 +138,10 @@ __glXSendReply(ClientPtr client, const void *data, size_t elements,
*/
(void) memcpy(&__glXReply.pad3, data, 8);
WriteToClient(client, sz_xGLXSingleReply, (char *) &__glXReply);
WriteToClient(client, sz_xGLXSingleReply, &__glXReply);
if (reply_ints != 0) {
WriteToClient(client, reply_ints * 4, (char *) data);
WriteToClient(client, reply_ints * 4, data);
}
}
@ -184,10 +184,10 @@ __glXSendReplySwap(ClientPtr client, const void *data, size_t elements,
*/
(void) memcpy(&__glXReply.pad3, data, 8);
WriteToClient(client, sz_xGLXSingleReply, (char *) &__glXReply);
WriteToClient(client, sz_xGLXSingleReply, &__glXReply);
if (reply_ints != 0) {
WriteToClient(client, reply_ints * 4, (char *) data);
WriteToClient(client, reply_ints * 4, data);
}
}

6
glx/single2.c
View File

@ -199,9 +199,9 @@ __glXDisp_RenderMode(__GLXclientState * cl, GLbyte * pc)
reply.retval = retval;
reply.size = nitems;
reply.newMode = newMode;
WriteToClient(client, sz_xGLXRenderModeReply, (char *) &reply);
WriteToClient(client, sz_xGLXRenderModeReply, &reply);
if (retBytes) {
WriteToClient(client, retBytes, (char *) retBuffer);
WriteToClient(client, retBytes, retBuffer);
}
return Success;
}
@ -384,7 +384,7 @@ DoGetString(__GLXclientState * cl, GLbyte * pc, GLboolean need_swap)
}
__GLX_SEND_HEADER();
WriteToClient(client, length, (char *) string);
WriteToClient(client, length, string);
free(buf);
return Success;

4
glx/single2swap.c
View File

@ -216,9 +216,9 @@ __glXDispSwap_RenderMode(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&reply.retval);
__GLX_SWAP_INT(&reply.size);
__GLX_SWAP_INT(&reply.newMode);
WriteToClient(client, sz_xGLXRenderModeReply, (char *) &reply);
WriteToClient(client, sz_xGLXRenderModeReply, &reply);
if (retBytes) {
WriteToClient(client, retBytes, (char *) retBuffer);
WriteToClient(client, retBytes, retBuffer);
}
return Success;
}

12
glx/unpack.h
View File

@ -63,7 +63,7 @@ extern xGLXSingleReply __glXReply;
__glXReply.sequenceNumber = client->sequence;
#define __GLX_SEND_HEADER() \
WriteToClient( client, sz_xGLXSingleReply, (char *)&__glXReply);
WriteToClient (client, sz_xGLXSingleReply, &__glXReply);
#define __GLX_PUT_RETVAL(a) \
__glXReply.retval = (a);
@ -116,19 +116,19 @@ extern xGLXSingleReply __glXReply;
*(GLdouble *)&__glXReply.pad3 = *(GLdouble *)answer
#define __GLX_SEND_BYTE_ARRAY(len) \
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT8), (char *)answer)
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT8), answer)
#define __GLX_SEND_SHORT_ARRAY(len) \
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT16), (char *)answer)
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT16), answer)
#define __GLX_SEND_INT_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_INT32, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_INT32, answer)
#define __GLX_SEND_FLOAT_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_FLOAT32, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_FLOAT32, answer)
#define __GLX_SEND_DOUBLE_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_FLOAT64, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_FLOAT64, answer)
#define __GLX_SEND_VOID_ARRAY(len) __GLX_SEND_BYTE_ARRAY(len)
#define __GLX_SEND_UBYTE_ARRAY(len) __GLX_SEND_BYTE_ARRAY(len)

44
hw/dmx/dmx.c
View File

@ -225,7 +225,7 @@ ProcDMXQueryVersion(ClientPtr client)
swapl(&rep.minorVersion);
swapl(&rep.patchVersion);
}
WriteToClient(client, sizeof(xDMXQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXQueryVersionReply), &rep);
return Success;
}
@ -247,7 +247,7 @@ ProcDMXSync(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client, sizeof(xDMXSyncReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXSyncReply), &rep);
return Success;
}
@ -297,7 +297,7 @@ ProcDMXForceWindowCreation(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client, sizeof(xDMXForceWindowCreationReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXForceWindowCreationReply), &rep);
return Success;
}
@ -317,7 +317,7 @@ ProcDMXGetScreenCount(ClientPtr client)
swapl(&rep.length);
swapl(&rep.screenCount);
}
WriteToClient(client, sizeof(xDMXGetScreenCountReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetScreenCountReply), &rep);
return Success;
}
@ -377,9 +377,9 @@ ProcDMXGetScreenAttributes(ClientPtr client)
swaps(&rep.rootWindowXorigin);
swaps(&rep.rootWindowYorigin);
}
WriteToClient(client, sizeof(xDMXGetScreenAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetScreenAttributesReply), &rep);
if (length)
WriteToClient(client, length, (char *) attr.displayName);
WriteToClient(client, length, attr.displayName);
return Success;
}
@ -453,8 +453,7 @@ ProcDMXChangeScreensAttributes(ClientPtr client)
swapl(&rep.status);
swapl(&rep.errorScreen);
}
WriteToClient(client,
sizeof(xDMXChangeScreensAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXChangeScreensAttributesReply), &rep);
return Success;
}
@ -503,7 +502,7 @@ ProcDMXAddScreen(ClientPtr client)
swapl(&rep.status);
swapl(&rep.physicalScreen);
}
WriteToClient(client, sizeof(xDMXAddScreenReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXAddScreenReply), &rep);
return Success;
}
@ -527,7 +526,7 @@ ProcDMXRemoveScreen(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client, sizeof(xDMXRemoveScreenReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXRemoveScreenReply), &rep);
return Success;
}
@ -663,12 +662,12 @@ ProcDMXGetWindowAttributes(ClientPtr client)
dmxFlushPendingSyncs();
WriteToClient(client, sizeof(xDMXGetWindowAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetWindowAttributesReply), &rep);
if (count) {
WriteToClient(client, count * sizeof(*screens), (char *) screens);
WriteToClient(client, count * sizeof(*windows), (char *) windows);
WriteToClient(client, count * sizeof(*pos), (char *) pos);
WriteToClient(client, count * sizeof(*vis), (char *) vis);
WriteToClient(client, count * sizeof(*screens), screens);
WriteToClient(client, count * sizeof(*windows), windows);
WriteToClient(client, count * sizeof(*pos), pos);
WriteToClient(client, count * sizeof(*vis), vis);
}
free(vis);
@ -706,7 +705,7 @@ ProcDMXGetDesktopAttributes(ClientPtr client)
swaps(&rep.shiftX);
swaps(&rep.shiftY);
}
WriteToClient(client, sizeof(xDMXGetDesktopAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetDesktopAttributesReply), &rep);
return Success;
}
@ -749,8 +748,7 @@ ProcDMXChangeDesktopAttributes(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client,
sizeof(xDMXChangeDesktopAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXChangeDesktopAttributesReply), &rep);
return Success;
}
@ -770,7 +768,7 @@ ProcDMXGetInputCount(ClientPtr client)
swapl(&rep.length);
swapl(&rep.inputCount);
}
WriteToClient(client, sizeof(xDMXGetInputCountReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetInputCountReply), &rep);
return Success;
}
@ -808,9 +806,9 @@ ProcDMXGetInputAttributes(ClientPtr client)
swapl(&rep.physicalId);
swapl(&rep.nameLength);
}
WriteToClient(client, sizeof(xDMXGetInputAttributesReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXGetInputAttributesReply), &rep);
if (length)
WriteToClient(client, length, (char *) attr.name);
WriteToClient(client, length, attr.name);
return Success;
}
@ -862,7 +860,7 @@ ProcDMXAddInput(ClientPtr client)
swapl(&rep.status);
swapl(&rep.physicalId);
}
WriteToClient(client, sizeof(xDMXAddInputReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXAddInputReply), &rep);
return Success;
}
@ -889,7 +887,7 @@ ProcDMXRemoveInput(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client, sizeof(xDMXRemoveInputReply), (char *) &rep);
WriteToClient(client, sizeof(xDMXRemoveInputReply), &rep);
return Success;
}

39
hw/dmx/glxProxy/glxcmds.c
View File

@ -465,8 +465,7 @@ __glXQueryMaxSwapBarriersSGIX(__GLXclientState * cl, GLbyte * pc)
__glXSwapQueryMaxSwapBarriersSGIXReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply,
(char *) &reply);
WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, &reply);
}
return Success;
@ -1388,8 +1387,7 @@ MakeCurrent(__GLXclientState * cl,
__glXSwapMakeCurrentReply(client, &new_reply);
}
else {
WriteToClient(client, sz_xGLXMakeContextCurrentReply,
(char *) &new_reply);
WriteToClient(client, sz_xGLXMakeContextCurrentReply, &new_reply);
}
return Success;
@ -1449,7 +1447,7 @@ __glXIsDirect(__GLXclientState * cl, GLbyte * pc)
__glXSwapIsDirectReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXIsDirectReply, (char *) &reply);
WriteToClient(client, sz_xGLXIsDirectReply, &reply);
}
return Success;
@ -1478,7 +1476,7 @@ __glXQueryVersion(__GLXclientState * cl, GLbyte * pc)
__glXSwapQueryVersionReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXQueryVersionReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryVersionReply, &reply);
}
return Success;
}
@ -1689,7 +1687,7 @@ __glXGetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);
for (i = 0; i < pGlxScreen->numVisuals; i++) {
pGlxVisual = &pGlxScreen->pGlxVisual[i];
@ -1743,8 +1741,7 @@ __glXGetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
buf[p++] = pGlxVisual->visualSelectGroup;
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG,
(char *) buf);
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, buf);
}
return Success;
}
@ -2637,9 +2634,8 @@ __glXQueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
glxSwapQueryExtensionsStringReply(client, &reply, be_buf);
}
else {
WriteToClient(client, sz_xGLXQueryExtensionsStringReply,
(char *) &reply);
WriteToClient(client, (int) (length << 2), (char *) be_buf);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, &reply);
WriteToClient(client, (int) (length << 2), be_buf);
}
return Success;
@ -2719,7 +2715,7 @@ __glXQueryServerString(__GLXclientState * cl, GLbyte * pc)
glxSwapQueryServerStringReply(client, &reply, be_buf);
}
else {
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);
WriteToClient(client, (int) (length << 2), be_buf);
}
@ -2880,7 +2876,7 @@ __glXGetFBConfigs(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&reply.numFBConfigs);
__GLX_SWAP_INT(&reply.numAttribs);
}
WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetFBConfigsReply, &reply);
for (i = 0; i < numFBConfigs; i++) {
int associatedVisualId = 0;
@ -3021,7 +3017,7 @@ __glXGetFBConfigs(__GLXclientState * cl, GLbyte * pc)
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_INT_ARRAY((int *) buf, 2 * numAttribs);
}
WriteToClient(client, 2 * numAttribs * __GLX_SIZE_CARD32, (char *) buf);
WriteToClient(client, 2 * numAttribs * __GLX_SIZE_CARD32, buf);
}
return Success;
}
@ -3218,8 +3214,8 @@ __glXQueryContext(__GLXclientState * cl, GLbyte * pc)
__glXSwapQueryContextReply(client, &reply, sendBuf);
}
else {
WriteToClient(client, sz_xGLXQueryContextReply, (char *) &reply);
WriteToClient(client, nReplyBytes, (char *) sendBuf);
WriteToClient(client, sz_xGLXQueryContextReply, &reply);
WriteToClient(client, nReplyBytes, sendBuf);
}
free((char *) sendBuf);
@ -3270,8 +3266,8 @@ __glXQueryContextInfoEXT(__GLXclientState * cl, GLbyte * pc)
__glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
}
else {
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *) &reply);
WriteToClient(client, nReplyBytes, (char *) sendBuf);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, &reply);
WriteToClient(client, nReplyBytes, sendBuf);
}
free((char *) sendBuf);
@ -3606,9 +3602,8 @@ __glXGetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
__glXSwapGetDrawableAttributesReply(client, &reply, (int *) attribs);
}
else {
WriteToClient(client, sz_xGLXGetDrawableAttributesReply,
(char *) &reply);
WriteToClient(client, attribs_size, (char *) attribs);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, &reply);
WriteToClient(client, attribs_size, attribs);
}
free(attribs);

29
hw/dmx/glxProxy/glxcmdsswap.c
View File

@ -304,7 +304,7 @@ __glXSwapGetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&reply.length);
__GLX_SWAP_INT(&reply.numVisuals);
__GLX_SWAP_INT(&reply.numProps);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);
for (i = 0; i < pGlxScreen->numVisuals; i++) {
pGlxVisual = &pGlxScreen->pGlxVisual[i];
@ -353,8 +353,7 @@ __glXSwapGetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
buf[p++] = pGlxVisual->transparentIndex;
__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG,
(char *) buf);
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, buf);
}
return Success;
}
@ -508,7 +507,7 @@ __glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReadSGIReply * reply)
__GLX_SWAP_INT(&reply->writeType);
__GLX_SWAP_INT(&reply->readVid);
__GLX_SWAP_INT(&reply->readType);
WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, (char *) reply);
WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, reply);
}
void
@ -517,7 +516,7 @@ __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply)
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
WriteToClient(client, sz_xGLXIsDirectReply, (char *) reply);
WriteToClient(client, sz_xGLXIsDirectReply, reply);
}
void
@ -528,7 +527,7 @@ __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply * reply)
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->majorVersion);
__GLX_SWAP_INT(&reply->minorVersion);
WriteToClient(client, sz_xGLXQueryVersionReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryVersionReply, reply);
}
void
@ -543,7 +542,7 @@ glxSwapQueryExtensionsStringReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryExtensionsStringReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, buf);
}
@ -558,7 +557,7 @@ glxSwapQueryServerStringReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryServerStringReply, reply);
/** no swap is needed for an array of chars **/
/* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
WriteToClient(client, length << 2, buf);
@ -576,9 +575,9 @@ __glXSwapQueryContextInfoEXTReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, (char *) buf);
WriteToClient(client, length << 2, buf);
}
void
@ -592,9 +591,9 @@ __glXSwapQueryContextReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->n);
WriteToClient(client, sz_xGLXQueryContextReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryContextReply, reply);
__GLX_SWAP_INT_ARRAY((int *) buf, length);
WriteToClient(client, length << 2, (char *) buf);
WriteToClient(client, length << 2, buf);
}
void
@ -608,8 +607,8 @@ __glXSwapGetDrawableAttributesReply(ClientPtr client,
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->numAttribs);
__GLX_SWAP_INT_ARRAY(buf, reply->length);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *) reply);
WriteToClient(client, reply->length << 2, (char *) buf);
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, reply);
WriteToClient(client, reply->length << 2, buf);
}
void
@ -621,7 +620,7 @@ __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client,
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->max);
WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, (char *) reply);
WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, reply);
}
/************************************************************************/

16
hw/dmx/glxProxy/glxsingle.c
View File

@ -147,9 +147,9 @@ SendSwappedReply(ClientPtr client,
}
WriteToClient(client, sizeof(xGLXSingleReply), (char *) reply);
WriteToClient(client, sizeof(xGLXSingleReply), reply);
if (buf_size > 0)
WriteToClient(client, buf_size, (char *) buf);
WriteToClient(client, buf_size, buf);
}
@ -281,9 +281,9 @@ __glXForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXSingleReply), (char *) &reply);
WriteToClient(client, sizeof(xGLXSingleReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *) be_buf);
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)
@ -383,9 +383,9 @@ __glXForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXSingleReply), (char *) &reply);
WriteToClient(client, sizeof(xGLXSingleReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *) be_buf);
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)
@ -1013,9 +1013,9 @@ __glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc)
__GLX_SWAP_INT(&reply.length);
}
WriteToClient(client, sizeof(xGLXReadPixelsReply), (char *) &reply);
WriteToClient(client, sizeof(xGLXReadPixelsReply), &reply);
if (buf_size > 0) {
WriteToClient(client, buf_size, (char *) buf);
WriteToClient(client, buf_size, buf);
free(buf);
}

12
hw/dmx/glxProxy/glxvendor.c
View File

@ -138,9 +138,9 @@ SendSwappedReply(ClientPtr client,
}
WriteToClient(client, sizeof(xGLXVendorPrivReply), (char *) reply);
WriteToClient(client, sizeof(xGLXVendorPrivReply), reply);
if (buf_size > 0)
WriteToClient(client, buf_size, (char *) buf);
WriteToClient(client, buf_size, buf);
}
@ -265,9 +265,9 @@ __glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply), (char *) &reply);
WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *) be_buf);
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)
@ -364,9 +364,9 @@ __glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply), (char *) &reply);
WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *) be_buf);
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)

12
hw/dmx/glxProxy/unpack.h
View File

@ -59,7 +59,7 @@ extern xGLXSingleReply __glXReply;
__glXReply.sequenceNumber = client->sequence;
#define __GLX_SEND_HEADER() \
WriteToClient( client, sz_xGLXSingleReply, (char *)&__glXReply);
WriteToClient (client, sz_xGLXSingleReply, &__glXReply);
#define __GLX_PUT_RETVAL(a) \
__glXReply.retval = (a);
@ -112,19 +112,19 @@ extern xGLXSingleReply __glXReply;
*(GLdouble *)&__glXReply.pad3 = *(GLdouble *)answer
#define __GLX_SEND_BYTE_ARRAY(len) \
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT8), (char *)answer)
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT8), answer)
#define __GLX_SEND_SHORT_ARRAY(len) \
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT16), (char *)answer)
WriteToClient(client, __GLX_PAD((len)*__GLX_SIZE_INT16), answer)
#define __GLX_SEND_INT_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_INT32, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_INT32, answer)
#define __GLX_SEND_FLOAT_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_FLOAT32, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_FLOAT32, answer)
#define __GLX_SEND_DOUBLE_ARRAY(len) \
WriteToClient(client, (len)*__GLX_SIZE_FLOAT64, (char *)answer)
WriteToClient(client, (len)*__GLX_SIZE_FLOAT64, answer)
#define __GLX_SEND_VOID_ARRAY(len) __GLX_SEND_BYTE_ARRAY(len)
#define __GLX_SEND_UBYTE_ARRAY(len) __GLX_SEND_BYTE_ARRAY(len)

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

@ -536,7 +536,7 @@ ProcXF86DRIQueryVersion(register ClientPtr client)
swaps(&rep.minorVersion);
swapl(&rep.patchVersion);
}
WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), &rep);
EPHYR_LOG("leave\n");
return Success;
}
@ -574,7 +574,7 @@ ProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
}
WriteToClient(client, sizeof(xXF86DRIQueryDirectRenderingCapableReply),
(char *) &rep);
&rep);
EPHYR_LOG("leave\n");
return Success;
@ -617,7 +617,7 @@ ProcXF86DRIOpenConnection(register ClientPtr client)
rep.hSAREAHigh = 0;
#endif
WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), &rep);
if (rep.busIdStringLength)
WriteToClient(client, rep.busIdStringLength, busIdString);
free(busIdString);
@ -648,7 +648,7 @@ ProcXF86DRIAuthConnection(register ClientPtr client)
ErrorF("Failed to authenticate %lu\n", (unsigned long) stuff->magic);
rep.authenticated = 0;
}
WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), &rep);
EPHYR_LOG("leave\n");
return Success;
}
@ -702,8 +702,7 @@ ProcXF86DRIGetClientDriverName(register ClientPtr client)
SIZEOF(xGenericReply) +
pad_to_int32(rep.clientDriverNameLength));
WriteToClient(client,
sizeof(xXF86DRIGetClientDriverNameReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetClientDriverNameReply), &rep);
if (rep.clientDriverNameLength)
WriteToClient(client, rep.clientDriverNameLength, clientDriverName);
EPHYR_LOG("leave\n");
@ -752,7 +751,7 @@ ProcXF86DRICreateContext(register ClientPtr client)
return BadValue;
}
WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRICreateContextReply), &rep);
EPHYR_LOG("leave\n");
return Success;
}
@ -974,7 +973,7 @@ ProcXF86DRICreateDrawable(ClientPtr client)
EPHYR_LOG("paired window '%p' with remote '%d'\n", window, remote_win);
}
WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), &rep);
EPHYR_LOG("leave\n");
return Success;
}
@ -1136,18 +1135,18 @@ ProcXF86DRIGetDrawableInfo(register ClientPtr client)
rep.length = bytes_to_int32(rep.length);
WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), &rep);
if (rep.numClipRects) {
WriteToClient(client,
sizeof(drm_clip_rect_t) * rep.numClipRects,
(char *) clipRects);
clipRects);
}
if (rep.numBackClipRects) {
WriteToClient(client,
sizeof(drm_clip_rect_t) * rep.numBackClipRects,
(char *) backClipRects);
backClipRects);
}
free(clipRects);
clipRects = NULL;
@ -1200,9 +1199,9 @@ ProcXF86DRIGetDeviceInfo(register ClientPtr client)
pad_to_int32(rep.devPrivateSize));
}
WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), &rep);
if (rep.length) {
WriteToClient(client, rep.devPrivateSize, (char *) pDevPrivate);
WriteToClient(client, rep.devPrivateSize, pDevPrivate);
}
EPHYR_LOG("leave\n");
return Success;

14
hw/kdrive/ephyr/ephyrglxext.c
View File

@ -169,7 +169,7 @@ ephyrGLXQueryVersion(__GLXclientState * a_cl, GLbyte * a_pc)
__glXSwapQueryVersionReply(client, &reply);
}
else {
WriteToClient(client, sz_xGLXQueryVersionReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryVersionReply, &reply);
}
res = Success;
@ -228,7 +228,7 @@ ephyrGLXGetVisualConfigsReal(__GLXclientState * a_cl,
__GLX_SWAP_INT(&reply.numProps);
__GLX_SWAP_INT_ARRAY(props_buf, num_props);
}
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);
props_per_visual_size = props_buf_size / num_visuals;
for (i = 0; i < num_visuals; i++) {
WriteToClient(client,
@ -282,7 +282,7 @@ ephyrGLXGetFBConfigsSGIXReal(__GLXclientState * a_cl,
__GLX_SWAP_INT(&reply.numProps);
__GLX_SWAP_INT_ARRAY(props_buf, num_props);
}
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);
props_per_visual_size = props_buf_size / num_visuals;
for (i = 0; i < num_visuals; i++) {
WriteToClient(client,
@ -375,7 +375,7 @@ ephyrGLXQueryServerString(__GLXclientState * a_cl, GLbyte * a_pc)
}
memcpy(buf, server_string, length);
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) &reply);
WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);
WriteToClient(client, (int) (reply.length << 2), server_string);
res = Success;
@ -538,7 +538,7 @@ ephyrGLXMakeCurrentReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
__GLX_SWAP_INT(&reply.length);
__GLX_SWAP_INT(&reply.contextTag);
}
WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, (char *) &reply);
WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, &reply);
res = Success;
out:
@ -601,7 +601,7 @@ ephyrGLXGetStringReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
__GLX_SWAP_REPLY_SIZE();
__GLX_SWAP_REPLY_HEADER();
}
WriteToClient(client, length, (char *) string);
WriteToClient(client, length, string);
res = Success;
out:
@ -690,7 +690,7 @@ ephyrGLXIsDirectReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
reply.length = 0;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
WriteToClient(client, sz_xGLXIsDirectReply, (char *) &reply);
WriteToClient(client, sz_xGLXIsDirectReply, &reply);
res = Success;
out:

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

@ -75,7 +75,7 @@ ephyrProxyProcDispatch(ClientPtr a_client)
reply.sequence_number = a_client->sequence;
res = Success;
WriteToClient(a_client, 32, (char *) &reply);
WriteToClient(a_client, 32, &reply);
out:
return res;

34
hw/xfree86/dixmods/extmod/xf86dga2.c
View File

@ -84,7 +84,7 @@ ProcXDGAQueryVersion(ClientPtr client)
rep.majorVersion = SERVER_XDGA_MAJOR_VERSION;
rep.minorVersion = SERVER_XDGA_MINOR_VERSION;
WriteToClient(client, sizeof(xXDGAQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXDGAQueryVersionReply), &rep);
return Success;
}
@ -117,7 +117,7 @@ ProcXDGAOpenFramebuffer(ClientPtr client)
nameSize = deviceName ? (strlen(deviceName) + 1) : 0;
rep.length = bytes_to_int32(nameSize);
WriteToClient(client, sizeof(xXDGAOpenFramebufferReply), (char *) &rep);
WriteToClient(client, sizeof(xXDGAOpenFramebufferReply), &rep);
if (rep.length)
WriteToClient(client, nameSize, deviceName);
@ -164,12 +164,12 @@ ProcXDGAQueryModes(ClientPtr client)
if (!DGAAvailable(stuff->screen)) {
rep.number = 0;
rep.length = 0;
WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
WriteToClient(client, sz_xXDGAQueryModesReply, &rep);
return Success;
}
if (!(num = DGAGetModes(stuff->screen))) {
WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
WriteToClient(client, sz_xXDGAQueryModesReply, &rep);
return Success;
}
@ -186,7 +186,7 @@ ProcXDGAQueryModes(ClientPtr client)
rep.number = num;
rep.length = bytes_to_int32(size);
WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
WriteToClient(client, sz_xXDGAQueryModesReply, &rep);
for (i = 0; i < num; i++) {
size = strlen(mode[i].name) + 1;
@ -218,7 +218,7 @@ ProcXDGAQueryModes(ClientPtr client)
info.reserved1 = mode[i].reserved1;
info.reserved2 = mode[i].reserved2;
WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
WriteToClient(client, sz_xXDGAModeInfo, (&info));
WriteToClient(client, size, mode[i].name);
}
@ -293,7 +293,7 @@ ProcXDGASetMode(ClientPtr client)
DGA_SETCLIENT(stuff->screen, NULL);
DGASelectInput(stuff->screen, NULL, 0);
DGASetMode(stuff->screen, 0, &mode, &pPix);
WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
WriteToClient(client, sz_xXDGASetModeReply, &rep);
return Success;
}
@ -345,8 +345,8 @@ ProcXDGASetMode(ClientPtr client)
rep.length = bytes_to_int32(sz_xXDGAModeInfo + info.name_size);
WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
WriteToClient(client, sz_xXDGASetModeReply, &rep);
WriteToClient(client, sz_xXDGAModeInfo, (&info));
WriteToClient(client, size, mode.name);
return Success;
@ -494,7 +494,7 @@ ProcXDGAGetViewportStatus(ClientPtr client)
rep.status = DGAGetViewportStatus(stuff->screen);
WriteToClient(client, sizeof(xXDGAGetViewportStatusReply), (char *) &rep);
WriteToClient(client, sizeof(xXDGAGetViewportStatusReply), &rep);
return Success;
}
@ -517,7 +517,7 @@ ProcXDGASync(ClientPtr client)
DGASync(stuff->screen);
WriteToClient(client, sizeof(xXDGASyncReply), (char *) &rep);
WriteToClient(client, sizeof(xXDGASyncReply), &rep);
return Success;
}
@ -568,7 +568,7 @@ ProcXDGAChangePixmapMode(ClientPtr client)
rep.x = x;
rep.y = y;
WriteToClient(client, sizeof(xXDGAChangePixmapModeReply), (char *) &rep);
WriteToClient(client, sizeof(xXDGAChangePixmapModeReply), &rep);
return Success;
}
@ -641,7 +641,7 @@ ProcXF86DGAGetVideoLL(ClientPtr client)
rep.width = mode.bytesPerScanline / (mode.bitsPerPixel >> 3);
rep.ram_size = rep.bank_size >> 10;
WriteToClient(client, SIZEOF(xXF86DGAGetVideoLLReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86DGAGetVideoLLReply), &rep);
return Success;
}
@ -732,7 +732,7 @@ ProcXF86DGAGetViewPortSize(ClientPtr client)
rep.width = mode.viewportWidth;
rep.height = mode.viewportHeight;
WriteToClient(client, SIZEOF(xXF86DGAGetViewPortSizeReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86DGAGetViewPortSizeReply), &rep);
return Success;
}
@ -777,7 +777,7 @@ ProcXF86DGAGetVidPage(ClientPtr client)
rep.sequenceNumber = client->sequence;
rep.vpage = 0; /* silently fail */
WriteToClient(client, SIZEOF(xXF86DGAGetVidPageReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86DGAGetVidPageReply), &rep);
return Success;
}
@ -844,7 +844,7 @@ ProcXF86DGAQueryDirectVideo(ClientPtr client)
if (DGAAvailable(stuff->screen))
rep.flags = XF86DGADirectPresent;
WriteToClient(client, SIZEOF(xXF86DGAQueryDirectVideoReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86DGAQueryDirectVideoReply), &rep);
return Success;
}
@ -870,7 +870,7 @@ ProcXF86DGAViewPortChanged(ClientPtr client)
rep.sequenceNumber = client->sequence;
rep.result = 1;
WriteToClient(client, SIZEOF(xXF86DGAViewPortChangedReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86DGAViewPortChangedReply), &rep);
return Success;
}

48
hw/xfree86/dixmods/extmod/xf86vmode.c
View File

@ -296,7 +296,7 @@ ProcXF86VidModeQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep);
return Success;
}
@ -391,12 +391,10 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
oldrep.vtotal = rep.vtotal;
oldrep.flags = rep.flags;
oldrep.privsize = rep.privsize;
WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply),
(char *) &oldrep);
WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep);
}
else {
WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply),
(char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep);
}
return Success;
}
@ -443,8 +441,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
swapl(&rep.length);
swapl(&rep.modecount);
}
WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply),
(char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep);
do {
mdinf.dotclock = dotClock;
@ -485,12 +482,10 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
oldmdinf.vtotal = mdinf.vtotal;
oldmdinf.flags = mdinf.flags;
oldmdinf.privsize = mdinf.privsize;
WriteToClient(client, sizeof(xXF86OldVidModeModeInfo),
(char *) &oldmdinf);
WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf);
}
else {
WriteToClient(client, sizeof(xXF86VidModeModeInfo),
(char *) &mdinf);
WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
}
} while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
@ -1040,8 +1035,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
swapl(&rep.length);
swapl(&rep.status);
}
WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply),
(char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status);
return Success;
@ -1262,20 +1256,16 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), &rep);
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata);
WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
if (rep.vendorLength)
WriteToClient(client, rep.vendorLength,
(char
*) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR,
0)).ptr);
(VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr);
if (rep.modelLength)
WriteToClient(client, rep.modelLength,
(char
*) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL,
0)).ptr);
(VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr);
free(hsyncdata);
free(vsyncdata);
@ -1311,7 +1301,7 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
swapl(&rep.x);
swapl(&rep.y);
}
WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *) &rep);
WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), &rep);
return Success;
}
@ -1380,7 +1370,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
swapl(&rep.maxclocks);
swapl(&rep.flags);
}
WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep);
if (!ClockProg) {
for (n = 0; n < numClocks; n++) {
dotclock = *Clocks++;
@ -1388,7 +1378,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
WriteSwappedDataToClient(client, 4, (char *) &dotclock);
}
else {
WriteToClient(client, 4, (char *) &dotclock);
WriteToClient(client, 4, &dotclock);
}
}
}
@ -1446,7 +1436,7 @@ ProcXF86VidModeGetGamma(ClientPtr client)
swapl(&rep.green);
swapl(&rep.blue);
}
WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep);
return Success;
}
@ -1520,10 +1510,10 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
swaps(&rep.size);
SwapShorts((short *) ramp, length * 3);
}
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep);
if (stuff->size) {
WriteToClient(client, ramplen, (char *) ramp);
WriteToClient(client, ramplen, ramp);
free(ramp);
}
@ -1551,8 +1541,7 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
swapl(&rep.length);
swaps(&rep.size);
}
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply),
(char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep);
return Success;
}
@ -1582,8 +1571,7 @@ ProcXF86VidModeGetPermissions(ClientPtr client)
swapl(&rep.length);
swapl(&rep.permissions);
}
WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply),
(char *) &rep);
WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep);
return Success;
}

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

@ -94,7 +94,7 @@ ProcXF86DRIQueryVersion(register ClientPtr client)
swaps(&rep.minorVersion);
swapl(&rep.patchVersion);
}
WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), &rep);
return Success;
}
@ -131,7 +131,7 @@ ProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
WriteToClient(client,
sizeof(xXF86DRIQueryDirectRenderingCapableReply),
(char *) &rep);
&rep);
return Success;
}
@ -171,7 +171,7 @@ ProcXF86DRIOpenConnection(register ClientPtr client)
rep.hSAREAHigh = 0;
#endif
WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), &rep);
if (rep.busIdStringLength)
WriteToClient(client, rep.busIdStringLength, busIdString);
return Success;
@ -198,7 +198,7 @@ ProcXF86DRIAuthConnection(register ClientPtr client)
ErrorF("Failed to authenticate %lu\n", (unsigned long) stuff->magic);
rep.authenticated = 0;
}
WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), &rep);
return Success;
}
@ -245,8 +245,7 @@ ProcXF86DRIGetClientDriverName(register ClientPtr client)
SIZEOF(xGenericReply) +
pad_to_int32(rep.clientDriverNameLength));
WriteToClient(client,
sizeof(xXF86DRIGetClientDriverNameReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetClientDriverNameReply), &rep);
if (rep.clientDriverNameLength)
WriteToClient(client, rep.clientDriverNameLength, clientDriverName);
return Success;
@ -277,7 +276,7 @@ ProcXF86DRICreateContext(register ClientPtr client)
return BadValue;
}
WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRICreateContextReply), &rep);
return Success;
}
@ -326,7 +325,7 @@ ProcXF86DRICreateDrawable(ClientPtr client)
return BadValue;
}
WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), &rep);
return Success;
}
@ -444,19 +443,19 @@ ProcXF86DRIGetDrawableInfo(register ClientPtr client)
rep.length = bytes_to_int32(rep.length);
WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), &rep);
if (rep.numClipRects) {
WriteToClient(client,
sizeof(drm_clip_rect_t) * rep.numClipRects,
(char *) pClippedRects);
pClippedRects);
free(pClippedRects);
}
if (rep.numBackClipRects) {
WriteToClient(client,
sizeof(drm_clip_rect_t) * rep.numBackClipRects,
(char *) pBackClipRects);
pBackClipRects);
}
return Success;
@ -503,9 +502,9 @@ ProcXF86DRIGetDeviceInfo(register ClientPtr client)
pad_to_int32(rep.devPrivateSize));
}
WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), &rep);
if (rep.length) {
WriteToClient(client, rep.devPrivateSize, (char *) pDevPrivate);
WriteToClient(client, rep.devPrivateSize, pDevPrivate);
}
return Success;
}

6
hw/xquartz/applewm.c
View File

@ -157,7 +157,7 @@ ProcAppleWMQueryVersion(register ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xAppleWMQueryVersionReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleWMQueryVersionReply),&rep);
return Success;
}
@ -533,7 +533,7 @@ ProcAppleWMFrameGetRect(register ClientPtr client)
rep.w = rr.x2 - rr.x1;
rep.h = rr.y2 - rr.y1;
WriteToClient(client, sizeof(xAppleWMFrameGetRectReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleWMFrameGetRectReply),&rep);
return Success;
}
@ -560,7 +560,7 @@ ProcAppleWMFrameHitTest(register ClientPtr client)
rep.ret = ret;
WriteToClient(client, sizeof(xAppleWMFrameHitTestReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleWMFrameHitTestReply),&rep);
return Success;
}

12
hw/xquartz/pseudoramiX.c
View File

@ -216,7 +216,7 @@ ProcPseudoramiXGetState(ClientPtr client)
swapl(&rep.length);
swaps(&rep.state);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *)&rep);
WriteToClient(client, sizeof(xPanoramiXGetStateReply),&rep);
return Success;
}
@ -245,7 +245,7 @@ ProcPseudoramiXGetScreenCount(ClientPtr client)
swapl(&rep.length);
swaps(&rep.ScreenCount);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *)&rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply),&rep);
return Success;
}
@ -279,7 +279,7 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
swaps(&rep.width);
swaps(&rep.height);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply),&rep);
return Success;
}
@ -303,7 +303,7 @@ ProcPseudoramiXIsActive(ClientPtr client)
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *)&rep);
WriteToClient(client, sizeof(xXineramaIsActiveReply),&rep);
return Success;
}
@ -329,7 +329,7 @@ ProcPseudoramiXQueryScreens(ClientPtr client)
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep);
WriteToClient(client, sizeof(xXineramaQueryScreensReply),&rep);
if (!noPseudoramiXExtension) {
xXineramaScreenInfo scratch;
@ -347,7 +347,7 @@ ProcPseudoramiXQueryScreens(ClientPtr client)
swaps(&scratch.width);
swaps(&scratch.height);
}
WriteToClient(client, sz_XineramaScreenInfo, (char *)&scratch);
WriteToClient(client, sz_XineramaScreenInfo,&scratch);
}
}

8
hw/xquartz/xpr/appledri.c
View File

@ -105,7 +105,7 @@ ProcAppleDRIQueryVersion(register ClientPtr client)
swaps(&rep.minorVersion);
swapl(&rep.patchVersion);
}
WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), &rep);
return Success;
}
@ -139,7 +139,7 @@ ProcAppleDRIQueryDirectRenderingCapable(register ClientPtr client)
WriteToClient(client,
sizeof(xAppleDRIQueryDirectRenderingCapableReply),
(char *)&rep);
&rep);
return Success;
}
@ -168,7 +168,7 @@ ProcAppleDRIAuthConnection(register ClientPtr client)
swapl(&rep.authenticated); /* Yes, this is a CARD32 ... sigh */
}
WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), &rep);
return Success;
}
@ -232,7 +232,7 @@ ProcAppleDRICreateSurface(ClientPtr client)
swapl(&rep.uid);
}
WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), (char *)&rep);
WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), &rep);
return Success;
}

4
hw/xwin/winwindowswm.c
View File

@ -95,7 +95,7 @@ ProcWindowsWMQueryVersion(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xWindowsWMQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xWindowsWMQueryVersionReply), &rep);
return Success;
}
@ -366,7 +366,7 @@ ProcWindowsWMFrameGetRect(ClientPtr client)
rep.x, rep.y, rep.w, rep.h);
#endif
WriteToClient(client, sizeof(xWindowsWMFrameGetRectReply), (char *) &rep);
WriteToClient(client, sizeof(xWindowsWMFrameGetRectReply), &rep);
return Success;
}

4
include/dix.h
View File

@ -102,12 +102,12 @@ SOFTWARE.
if ((pClient)->swapped) \
(*ReplySwapVector[((xReq *)(pClient)->requestBuffer)->reqType]) \
(pClient, (int)(size), pReply); \
else (void) WriteToClient(pClient, (int)(size), (char *)(pReply)); }
else WriteToClient(pClient, (int)(size), (pReply)); }
#define WriteSwappedDataToClient(pClient, size, pbuf) \
if ((pClient)->swapped) \
(*(pClient)->pSwapReplyFunc)(pClient, (int)(size), pbuf); \
else (void) WriteToClient (pClient, (int)(size), (char *)(pbuf));
else WriteToClient(pClient, (int)(size), (pbuf));
typedef struct _TimeStamp *TimeStampPtr;

17
randr/rrcrtc.c
View File

@ -975,9 +975,9 @@ ProcRRGetCrtcInfo(ClientPtr client)
swaps(&rep.nOutput);
swaps(&rep.nPossibleOutput);
}
WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetCrtcInfoReply), &rep);
if (extraLen) {
WriteToClient(client, extraLen, (char *) extra);
WriteToClient(client, extraLen, extra);
free(extra);
}
@ -1181,7 +1181,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
swapl(&rep.length);
swapl(&rep.newTimestamp);
}
WriteToClient(client, sizeof(xRRSetCrtcConfigReply), (char *) &rep);
WriteToClient(client, sizeof(xRRSetCrtcConfigReply), &rep);
return Success;
}
@ -1250,7 +1250,7 @@ ProcRRGetPanning(ClientPtr client)
swaps(&rep.border_right);
swaps(&rep.border_bottom);
}
WriteToClient(client, sizeof(xRRGetPanningReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetPanningReply), &rep);
return Success;
}
@ -1318,7 +1318,7 @@ ProcRRSetPanning(ClientPtr client)
swapl(&rep.length);
swapl(&rep.newTimestamp);
}
WriteToClient(client, sizeof(xRRSetPanningReply), (char *) &rep);
WriteToClient(client, sizeof(xRRSetPanningReply), &rep);
return Success;
}
@ -1345,7 +1345,7 @@ ProcRRGetCrtcGammaSize(ClientPtr client)
swapl(&reply.length);
swaps(&reply.size);
}
WriteToClient(client, sizeof(xRRGetCrtcGammaSizeReply), (char *) &reply);
WriteToClient(client, sizeof(xRRGetCrtcGammaSizeReply), &reply);
return Success;
}
@ -1382,7 +1382,7 @@ ProcRRGetCrtcGamma(ClientPtr client)
swapl(&reply.length);
swaps(&reply.size);
}
WriteToClient(client, sizeof(xRRGetCrtcGammaReply), (char *) &reply);
WriteToClient(client, sizeof(xRRGetCrtcGammaReply), &reply);
if (crtc->gammaSize) {
memcpy(extra, crtc->gammaRed, len);
client->pSwapReplyFunc = (ReplySwapPtr) CopySwap16Write;
@ -1548,8 +1548,7 @@ ProcRRGetCrtcTransform(ClientPtr client)
swaps(&reply->sequenceNumber);
swapl(&reply->length);
}
WriteToClient(client, sizeof(xRRGetCrtcTransformReply) + nextra,
(char *) reply);
WriteToClient(client, sizeof(xRRGetCrtcTransformReply) + nextra, reply);
free(reply);
return Success;
}

2
randr/rrdispatch.c
View File

@ -63,7 +63,7 @@ ProcRRQueryVersion(ClientPtr client)
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRRQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xRRQueryVersionReply), &rep);
return Success;
}

2
randr/rrmode.c
View File

@ -320,7 +320,7 @@ ProcRRCreateMode(ClientPtr client)
swapl(&rep.length);
swapl(&rep.mode);
}
WriteToClient(client, sizeof(xRRCreateModeReply), (char *) &rep);
WriteToClient(client, sizeof(xRRCreateModeReply), &rep);
/* Drop out reference to this mode */
RRModeDestroy(mode);
return Success;

4
randr/rroutput.c
View File

@ -489,9 +489,9 @@ ProcRRGetOutputInfo(ClientPtr client)
swaps(&rep.nClones);
swaps(&rep.nameLength);
}
WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetOutputInfoReply), &rep);
if (extraLen) {
WriteToClient(client, extraLen, (char *) extra);
WriteToClient(client, extraLen, extra);
free(extra);
}

4
randr/rrproperty.c
View File

@ -407,7 +407,7 @@ ProcRRListOutputProperties(ClientPtr client)
for (prop = output->properties; prop; prop = prop->next)
*temppAtoms++ = prop->propertyName;
WriteToClient(client, sizeof(xRRListOutputPropertiesReply), (char *) &rep);
WriteToClient(client, sizeof(xRRListOutputPropertiesReply), &rep);
if (numProps) {
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
@ -448,7 +448,7 @@ ProcRRQueryOutputProperty(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xRRQueryOutputPropertyReply), (char *) &rep);
WriteToClient(client, sizeof(xRRQueryOutputPropertyReply), &rep);
if (prop->num_valid) {
memcpy(extra, prop->valid_values, prop->num_valid * sizeof(INT32));
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

12
randr/rrscreen.c
View File

@ -228,7 +228,7 @@ ProcRRGetScreenSizeRange(ClientPtr client)
swaps(&rep.maxWidth);
swaps(&rep.maxHeight);
}
WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), &rep);
return Success;
}
@ -450,9 +450,9 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
swaps(&rep.nModes);
swaps(&rep.nbytesNames);
}
WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetScreenResourcesReply), &rep);
if (extraLen) {
WriteToClient(client, extraLen, (char *) extra);
WriteToClient(client, extraLen, extra);
free(extra);
}
return Success;
@ -860,9 +860,9 @@ ProcRRGetScreenInfo(ClientPtr client)
swaps(&rep.rate);
swaps(&rep.nrateEnts);
}
WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *) &rep);
WriteToClient(client, sizeof(xRRGetScreenInfoReply), &rep);
if (extraLen) {
WriteToClient(client, extraLen, (char *) extra);
WriteToClient(client, extraLen, extra);
free(extra);
}
return Success;
@ -1092,7 +1092,7 @@ ProcRRSetScreenConfig(ClientPtr client)
swapl(&rep.newConfigTimestamp);
swapl(&rep.root);
}
WriteToClient(client, sizeof(xRRSetScreenConfigReply), (char *) &rep);
WriteToClient(client, sizeof(xRRSetScreenConfigReply), &rep);
return Success;
}

12
randr/rrxinerama.c
View File

@ -103,7 +103,7 @@ ProcRRXineramaQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), &rep);
return Success;
}
@ -140,7 +140,7 @@ ProcRRXineramaGetState(ClientPtr client)
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetStateReply), &rep);
return Success;
}
@ -194,7 +194,7 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), &rep);
return Success;
}
@ -230,7 +230,7 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
swapl(&rep.window);
swapl(&rep.screen);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *) &rep);
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), &rep);
return Success;
}
@ -251,7 +251,7 @@ ProcRRXineramaIsActive(ClientPtr client)
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
WriteToClient(client, sizeof(xXineramaIsActiveReply), &rep);
return Success;
}
@ -314,7 +314,7 @@ ProcRRXineramaQueryScreens(ClientPtr client)
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *) &rep);
WriteToClient(client, sizeof(xXineramaQueryScreensReply), &rep);
if (rep.number) {
rrScrPriv(pScreen);

15
record/record.c
View File

@ -241,12 +241,12 @@ RecordFlushReplyBuffer(RecordContextPtr pContext,
++pContext->inFlush;
if (pContext->numBufBytes)
WriteToClient(pContext->pRecordingClient, pContext->numBufBytes,
(char *) pContext->replyBuffer);
pContext->replyBuffer);
pContext->numBufBytes = 0;
if (len1)
WriteToClient(pContext->pRecordingClient, len1, (char *) data1);
WriteToClient(pContext->pRecordingClient, len1, data1);
if (len2)
WriteToClient(pContext->pRecordingClient, len2, (char *) data2);
WriteToClient(pContext->pRecordingClient, len2, data2);
--pContext->inFlush;
} /* RecordFlushReplyBuffer */
@ -1829,8 +1829,7 @@ ProcRecordQueryVersion(ClientPtr client)
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
(void) WriteToClient(client, sizeof(xRecordQueryVersionReply),
(char *) &rep);
WriteToClient(client, sizeof(xRecordQueryVersionReply), &rep);
return Success;
} /* ProcRecordQueryVersion */
@ -2240,7 +2239,7 @@ ProcRecordGetContext(ClientPtr client)
swapl(&rep.length);
swapl(&rep.nClients);
}
(void) WriteToClient(client, sizeof(xRecordGetContextReply), (char *) &rep);
WriteToClient(client, sizeof(xRecordGetContextReply), &rep);
/* write all the CLIENT_INFOs */
@ -2257,9 +2256,9 @@ ProcRecordGetContext(ClientPtr client)
rci.clientResource = pRCAP->pClientIDs[i];
if (client->swapped)
swapl(&rci.clientResource);
WriteToClient(client, sizeof(xRecordClientInfo), (char *) &rci);
WriteToClient(client, sizeof(xRecordClientInfo), &rci);
WriteToClient(client, sizeof(xRecordRange) * pri->nRanges,
(char *) pri->pRanges);
pri->pRanges);
}
}
err = Success;

8
render/render.c
View File

@ -296,7 +296,7 @@ ProcRenderQueryVersion(ClientPtr client)
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xRenderQueryVersionReply), &rep);
return Success;
}
@ -500,7 +500,7 @@ ProcRenderQueryPictFormats(ClientPtr client)
swapl(&reply->numVisuals);
swapl(&reply->numSubpixel);
}
WriteToClient(client, rlength, (char *) reply);
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
@ -557,7 +557,7 @@ ProcRenderQueryPictIndexValues(ClientPtr client)
swapl(&reply->numIndexValues);
}
WriteToClient(client, rlength, (char *) reply);
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
@ -1748,7 +1748,7 @@ ProcRenderQueryFilters(ClientPtr client)
swapl(&reply->numAliases);
swapl(&reply->numFilters);
}
WriteToClient(client, total_bytes, (char *) reply);
WriteToClient(client, total_bytes, reply);
free(reply);
return Success;

6
xfixes/cursor.c
View File

@ -409,8 +409,8 @@ ProcXFixesGetCursorImage(ClientPtr client)
swapl(&rep->cursorSerial);
SwapLongs(image, npixels);
}
WriteToClient(client, sizeof(xXFixesGetCursorImageReply) +
(npixels << 2), (char *) rep);
WriteToClient(client,
sizeof(xXFixesGetCursorImageReply) + (npixels << 2), rep);
free(rep);
return Success;
}
@ -565,7 +565,7 @@ ProcXFixesGetCursorImageAndName(ClientPtr client)
SwapLongs(image, npixels);
}
WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply) +
(npixels << 2) + nbytesRound, (char *) rep);
(npixels << 2) + nbytesRound, rep);
free(rep);
return Success;
}

2
xfixes/region.c
View File

@ -584,7 +584,7 @@ ProcXFixesFetchRegion(ClientPtr client)
swaps(&reply->height);
SwapShorts((INT16 *) pRect, nBox * 4);
}
(void) WriteToClient(client, sizeof(xXFixesFetchRegionReply) +
WriteToClient(client, sizeof(xXFixesFetchRegionReply) +
nBox * sizeof(xRectangle), (char *) reply);
free(reply);
return Success;

2
xfixes/xfixes.c
View File

@ -90,7 +90,7 @@ ProcXFixesQueryVersion(ClientPtr client)
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *) &rep);
WriteToClient(client, sizeof(xXFixesQueryVersionReply), &rep);
return Success;
}

42
xkb/xkb.c
View File

@ -193,7 +193,7 @@ ProcXkbUseExtension(ClientPtr client)
swaps(&rep.serverMajor);
swaps(&rep.serverMinor);
}
WriteToClient(client, SIZEOF(xkbUseExtensionReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbUseExtensionReply), &rep);
return Success;
}
@ -596,7 +596,7 @@ ProcXkbGetState(ClientPtr client)
swaps(&rep.sequenceNumber);
swaps(&rep.ptrBtnState);
}
WriteToClient(client, SIZEOF(xkbGetStateReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetStateReply), &rep);
return Success;
}
@ -741,7 +741,7 @@ ProcXkbGetControls(ClientPtr client)
swaps(&rep.axtOptsValues);
swaps(&rep.axOptions);
}
WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetControlsReply), &rep);
return Success;
}
@ -1433,7 +1433,7 @@ XkbSendMap(ClientPtr client, XkbDescPtr xkb, xkbGetMapReply * rep)
swaps(&rep->totalSyms);
swaps(&rep->totalActs);
}
WriteToClient(client, (i = SIZEOF(xkbGetMapReply)), (char *) rep);
WriteToClient(client, (i = SIZEOF(xkbGetMapReply)), rep);
WriteToClient(client, len, start);
free((char *) start);
return Success;
@ -2744,7 +2744,7 @@ XkbSendCompatMap(ClientPtr client,
swaps(&rep->nTotalSI);
}
WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *) rep);
WriteToClient(client, SIZEOF(xkbGetCompatMapReply), rep);
if (data) {
WriteToClient(client, size, data);
free((char *) data);
@ -3044,7 +3044,7 @@ ProcXkbGetIndicatorState(ClientPtr client)
swaps(&rep.sequenceNumber);
swapl(&rep.state);
}
WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), &rep);
return Success;
}
@ -3118,9 +3118,9 @@ XkbSendIndicatorMap(ClientPtr client,
swapl(&rep->which);
swapl(&rep->realIndicators);
}
WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *) rep);
WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), rep);
if (map) {
WriteToClient(client, length, (char *) map);
WriteToClient(client, length, map);
free((char *) map);
}
return Success;
@ -3343,7 +3343,7 @@ ProcXkbGetNamedIndicator(ClientPtr client)
swapl(&rep.ctrls);
}
WriteToClient(client, SIZEOF(xkbGetNamedIndicatorReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetNamedIndicatorReply), &rep);
return Success;
}
@ -3857,7 +3857,7 @@ XkbSendNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply * rep)
ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
length, (unsigned long) (desc - start));
}
WriteToClient(client, SIZEOF(xkbGetNamesReply), (char *) rep);
WriteToClient(client, SIZEOF(xkbGetNamesReply), rep);
WriteToClient(client, length, start);
free((char *) start);
return Success;
@ -4904,7 +4904,7 @@ XkbSendGeometry(ClientPtr client,
swaps(&rep->nDoodads);
swaps(&rep->nKeyAliases);
}
WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *) rep);
WriteToClient(client, SIZEOF(xkbGetGeometryReply), rep);
if (len > 0)
WriteToClient(client, len, start);
if (start != NULL)
@ -5538,7 +5538,7 @@ ProcXkbPerClientFlags(ClientPtr client)
swapl(&rep.autoCtrls);
swapl(&rep.autoCtrlValues);
}
WriteToClient(client, SIZEOF(xkbPerClientFlagsReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbPerClientFlagsReply), &rep);
return Success;
}
@ -5667,9 +5667,9 @@ ProcXkbListComponents(ClientPtr client)
swaps(&rep.nGeometries);
swaps(&rep.extra);
}
WriteToClient(client, SIZEOF(xkbListComponentsReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbListComponentsReply), &rep);
if (list.nPool && list.pool) {
WriteToClient(client, XkbPaddedSize(list.nPool), (char *) list.pool);
WriteToClient(client, XkbPaddedSize(list.nPool), list.pool);
free(list.pool);
list.pool = NULL;
}
@ -5939,7 +5939,7 @@ ProcXkbGetKbdByName(ClientPtr client)
swaps(&rep.found);
swaps(&rep.reported);
}
WriteToClient(client, SIZEOF(xkbGetKbdByNameReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetKbdByNameReply), &rep);
if (reported & (XkbGBN_SymbolsMask | XkbGBN_TypesMask))
XkbSendMap(client, new, &mrep);
if (reported & XkbGBN_CompatMapMask)
@ -6136,7 +6136,7 @@ SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
swapl(&wire.physIndicators);
swapl(&wire.state);
}
WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), (char *) &wire);
WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), &wire);
length += SIZEOF(xkbDeviceLedsWireDesc);
if (sli->namesPresent | sli->mapsPresent) {
register unsigned i, bit;
@ -6150,7 +6150,7 @@ SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
if (client->swapped) {
swapl(&awire);
}
WriteToClient(client, 4, (char *) &awire);
WriteToClient(client, 4, &awire);
length += 4;
}
}
@ -6173,7 +6173,7 @@ SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
swapl(&iwire.ctrls);
}
WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc),
(char *) &iwire);
&iwire);
length += SIZEOF(xkbIndicatorMapWireDesc);
}
}
@ -6343,7 +6343,7 @@ ProcXkbGetDeviceInfo(ClientPtr client)
swaps(&rep.dfltLedFB);
swapl(&rep.devType);
}
WriteToClient(client, SIZEOF(xkbGetDeviceInfoReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbGetDeviceInfoReply), &rep);
str = malloc(nameLen);
if (!str)
@ -6359,7 +6359,7 @@ ProcXkbGetDeviceInfo(ClientPtr client)
sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc);
awire = (xkbActionWireDesc *) & dev->button->xkb_acts[rep.firstBtnRtrn];
WriteToClient(client, sz, (char *) awire);
WriteToClient(client, sz, awire);
length -= sz;
}
if (nDeviceLedFBs > 0) {
@ -6760,7 +6760,7 @@ ProcXkbSetDebuggingFlags(ClientPtr client)
swapl(&rep.supportedFlags);
swapl(&rep.supportedCtrls);
}
WriteToClient(client, SIZEOF(xkbSetDebuggingFlagsReply), (char *) &rep);
WriteToClient(client, SIZEOF(xkbSetDebuggingFlagsReply), &rep);
return Success;
}

18
xkb/xkbEvents.c
View File

@ -243,7 +243,7 @@ XkbSendStateNotify(DeviceIntPtr kbd, xkbStateNotify * pSN)
swaps(&pSN->changed);
swaps(&pSN->ptrBtnState);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pSN);
WriteToClient(interest->client, sizeof(xEvent), pSN);
}
interest = interest->next;
}
@ -416,7 +416,7 @@ XkbSendControlsNotify(DeviceIntPtr kbd, xkbControlsNotify * pCN)
swapl(&pCN->enabledControlChanges);
swapl(&pCN->time);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pCN);
WriteToClient(interest->client, sizeof(xEvent), pCN);
}
interest = interest->next;
}
@ -463,7 +463,7 @@ XkbSendIndicatorNotify(DeviceIntPtr kbd, int xkbType, xkbIndicatorNotify * pEv)
swapl(&pEv->changed);
swapl(&pEv->state);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}
@ -550,7 +550,7 @@ XkbHandleBell(BOOL force,
swapl(&bn.name);
swapl(&bn.window);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) &bn);
WriteToClient(interest->client, sizeof(xEvent), &bn);
}
interest = interest->next;
}
@ -594,7 +594,7 @@ XkbSendAccessXNotify(DeviceIntPtr kbd, xkbAccessXNotify * pEv)
swaps(&pEv->slowKeysDelay);
swaps(&pEv->debounceDelay);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}
@ -642,7 +642,7 @@ XkbSendNamesNotify(DeviceIntPtr kbd, xkbNamesNotify * pEv)
swapl(&pEv->changedIndicators);
swaps(&pEv->changedVirtualMods);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}
@ -689,7 +689,7 @@ XkbSendCompatMapNotify(DeviceIntPtr kbd, xkbCompatMapNotify * pEv)
swaps(&pEv->nSI);
swaps(&pEv->nTotalSI);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}
@ -732,7 +732,7 @@ XkbSendActionMessage(DeviceIntPtr kbd, xkbActionMessage * pEv)
swaps(&pEv->sequenceNumber);
swapl(&pEv->time);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}
@ -786,7 +786,7 @@ XkbSendExtensionDeviceNotify(DeviceIntPtr dev,
swaps(&pEv->reason);
swaps(&pEv->supported);
}
WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
WriteToClient(interest->client, sizeof(xEvent), pEv);
}
interest = interest->next;
}