SwallowOS/xserver_xsdl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use internal temp variable for swap macros

Browse Source 
Also, fix whitespace, mainly around
	swaps(&rep.sequenceNumber)

Reviewed-by: Peter Harris <pharris@opentext.com>
Signed-off-by: Matt Turner <mattst88@gmail.com>
This commit is contained in:
Matt Turner
2011-08-04 15:35:41 -04:00
parent c10bad3d3e
commit 2c7c520cfe
115 changed files with 3164 additions and 4140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
randr/rrcrtc.c
View File

@@ -751,7 +751,7 @@ ProcRRGetCrtcInfo (ClientPtr client)
RRModePtr mode;
RROutput *outputs;
RROutput *possible;
int i, j, k, n;
int i, j, k;
int width, height;
BoxRec panned_area;
@@ -818,7 +818,7 @@ ProcRRGetCrtcInfo (ClientPtr client)
{
outputs[i] = crtc->outputs[i]->id;
if (client->swapped)
swapl (&outputs[i], n);
swapl(&outputs[i]);
}
k = 0;
for (i = 0; i < pScrPriv->numOutputs; i++)
@@ -827,23 +827,23 @@ ProcRRGetCrtcInfo (ClientPtr client)
{
possible[k] = pScrPriv->outputs[i]->id;
if (client->swapped)
swapl (&possible[k], n);
swapl(&possible[k]);
k++;
}
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.timestamp, n);
swaps(&rep.x, n);
swaps(&rep.y, n);
swaps(&rep.width, n);
swaps(&rep.height, n);
swapl(&rep.mode, n);
swaps(&rep.rotation, n);
swaps(&rep.rotations, n);
swaps(&rep.nOutput, n);
swaps(&rep.nPossibleOutput, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.timestamp);
swaps(&rep.x);
swaps(&rep.y);
swaps(&rep.width);
swaps(&rep.height);
swapl(&rep.mode);
swaps(&rep.rotation);
swaps(&rep.rotations);
swaps(&rep.nOutput);
swaps(&rep.nPossibleOutput);
}
WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *)&rep);
if (extraLen)
@@ -1058,10 +1058,9 @@ sendReply:
if (client->swapped)
{
int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.newTimestamp, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.newTimestamp);
}
WriteToClient(client, sizeof(xRRSetCrtcConfigReply), (char *)&rep);
@@ -1079,7 +1078,6 @@ ProcRRGetPanning (ClientPtr client)
BoxRec total;
BoxRec tracking;
INT16 border[4];
int n;
REQUEST_SIZE_MATCH(xRRGetPanningReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1117,21 +1115,21 @@ ProcRRGetPanning (ClientPtr client)
}
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.timestamp, n);
swaps(&rep.left, n);
swaps(&rep.top, n);
swaps(&rep.width, n);
swaps(&rep.height, n);
swaps(&rep.track_left, n);
swaps(&rep.track_top, n);
swaps(&rep.track_width, n);
swaps(&rep.track_height, n);
swaps(&rep.border_left, n);
swaps(&rep.border_top, n);
swaps(&rep.border_right, n);
swaps(&rep.border_bottom, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.timestamp);
swaps(&rep.left);
swaps(&rep.top);
swaps(&rep.width);
swaps(&rep.height);
swaps(&rep.track_left);
swaps(&rep.track_top);
swaps(&rep.track_width);
swaps(&rep.track_height);
swaps(&rep.border_left);
swaps(&rep.border_top);
swaps(&rep.border_right);
swaps(&rep.border_bottom);
}
WriteToClient(client, sizeof(xRRGetPanningReply), (char *)&rep);
return Success;
@@ -1149,7 +1147,6 @@ ProcRRSetPanning (ClientPtr client)
BoxRec total;
BoxRec tracking;
INT16 border[4];
int n;
REQUEST_SIZE_MATCH(xRRSetPanningReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1198,9 +1195,9 @@ sendReply:
rep.newTimestamp = pScrPriv->lastSetTime.milliseconds;
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.newTimestamp, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.newTimestamp);
}
WriteToClient(client, sizeof(xRRSetPanningReply), (char *)&rep);
return Success;
@@ -1212,7 +1209,6 @@ ProcRRGetCrtcGammaSize (ClientPtr client)
REQUEST(xRRGetCrtcGammaSizeReq);
xRRGetCrtcGammaSizeReply reply;
RRCrtcPtr crtc;
int n;
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1226,9 +1222,9 @@ ProcRRGetCrtcGammaSize (ClientPtr client)
reply.length = 0;
reply.size = crtc->gammaSize;
if (client->swapped) {
swaps (&reply.sequenceNumber, n);
swapl (&reply.length, n);
swaps (&reply.size, n);
swaps(&reply.sequenceNumber);
swapl(&reply.length);
swaps(&reply.size);
}
WriteToClient (client, sizeof (xRRGetCrtcGammaSizeReply), (char *) &reply);
return Success;
@@ -1240,7 +1236,6 @@ ProcRRGetCrtcGamma (ClientPtr client)
REQUEST(xRRGetCrtcGammaReq);
xRRGetCrtcGammaReply reply;
RRCrtcPtr crtc;
int n;
unsigned long len;
char *extra = NULL;
@@ -1264,9 +1259,9 @@ ProcRRGetCrtcGamma (ClientPtr client)
reply.length = bytes_to_int32(len);
reply.size = crtc->gammaSize;
if (client->swapped) {
swaps (&reply.sequenceNumber, n);
swapl (&reply.length, n);
swaps (&reply.size, n);
swaps(&reply.sequenceNumber);
swapl(&reply.length);
swaps(&reply.size);
}
WriteToClient (client, sizeof (xRRGetCrtcGammaReply), (char *) &reply);
if (crtc->gammaSize)
@@ -1361,7 +1356,6 @@ transform_filter_encode (ClientPtr client, char *output,
RRTransformPtr transform)
{
int nbytes, nparams;
int n;
if (transform->filter == NULL) {
*nbytesFilter = 0;
@@ -1377,8 +1371,8 @@ transform_filter_encode (ClientPtr client, char *output,
output[nbytes++] = 0;
memcpy (output + nbytes, transform->params, nparams * sizeof (xFixed));
if (client->swapped) {
swaps (nbytesFilter, n);
swaps (nparamsFilter, n);
swaps(nbytesFilter);
swaps(nparamsFilter);
SwapLongs ((CARD32 *) (output + nbytes), nparams);
}
nbytes += nparams * sizeof (xFixed);
@@ -1399,7 +1393,7 @@ ProcRRGetCrtcTransform (ClientPtr client)
REQUEST(xRRGetCrtcTransformReq);
xRRGetCrtcTransformReply *reply;
RRCrtcPtr crtc;
int n, nextra;
int nextra;
RRTransformPtr current, pending;
char *extra;
@@ -1436,8 +1430,8 @@ ProcRRGetCrtcTransform (ClientPtr client)
current);
if (client->swapped) {
swaps (&reply->sequenceNumber, n);
swapl (&reply->length, n);
swaps(&reply->sequenceNumber);
swapl(&reply->length);
}
WriteToClient (client, sizeof (xRRGetCrtcTransformReply) + nextra, (char *) reply);
free(reply);

9
randr/rrdispatch.c
View File

@@ -36,7 +36,6 @@ static int
ProcRRQueryVersion (ClientPtr client)
{
xRRQueryVersionReply rep = {0};
register int n;
REQUEST(xRRQueryVersionReq);
rrClientPriv(client);
@@ -59,10 +58,10 @@ ProcRRQueryVersion (ClientPtr client)
}
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.majorVersion, n);
swapl(&rep.minorVersion, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRRQueryVersionReply), (char *)&rep);
return Success;

7
randr/rrmode.c
View File

@@ -325,10 +325,9 @@ ProcRRCreateMode (ClientPtr client)
rep.mode = mode->mode.id;
if (client->swapped)
{
int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.mode, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.mode);
}
WriteToClient(client, sizeof(xRRCreateModeReply), (char *)&rep);
/* Drop out reference to this mode */

33
randr/rroutput.c
View File

@@ -447,7 +447,7 @@ ProcRRGetOutputInfo (ClientPtr client)
RRMode *modes;
RROutput *clones;
char *name;
int i, n;
int i;
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
@@ -494,7 +494,7 @@ ProcRRGetOutputInfo (ClientPtr client)
{
crtcs[i] = output->crtcs[i]->id;
if (client->swapped)
swapl (&crtcs[i], n);
swapl(&crtcs[i]);
}
for (i = 0; i < output->numModes + output->numUserModes; i++)
{
@@ -503,26 +503,26 @@ ProcRRGetOutputInfo (ClientPtr client)
else
modes[i] = output->userModes[i - output->numModes]->mode.id;
if (client->swapped)
swapl (&modes[i], n);
swapl(&modes[i]);
}
for (i = 0; i < output->numClones; i++)
{
clones[i] = output->clones[i]->id;
if (client->swapped)
swapl (&clones[i], n);
swapl(&clones[i]);
}
memcpy (name, output->name, output->nameLength);
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.timestamp, n);
swapl(&rep.crtc, n);
swapl(&rep.mmWidth, n);
swapl(&rep.mmHeight, n);
swaps(&rep.nCrtcs, n);
swaps(&rep.nModes, n);
swaps(&rep.nClones, n);
swaps(&rep.nameLength, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.timestamp);
swapl(&rep.crtc);
swapl(&rep.mmWidth);
swapl(&rep.mmHeight);
swaps(&rep.nCrtcs);
swaps(&rep.nModes);
swaps(&rep.nClones);
swaps(&rep.nameLength);
}
WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *)&rep);
if (extraLen)
@@ -614,9 +614,8 @@ ProcRRGetOutputPrimary(ClientPtr client)
rep.output = primary ? primary->id : None;
if (client->swapped) {
int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.output, n);
swaps(&rep.sequenceNumber);
swapl(&rep.output);
}
WriteToClient(client, sizeof(xRRGetOutputPrimaryReply), &rep);

48
randr/rrproperty.c
View File

@@ -409,10 +409,9 @@ ProcRRListOutputProperties (ClientPtr client)
rep.nAtoms = numProps;
if (client->swapped)
{
int n;
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
swaps (&rep.nAtoms, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.nAtoms);
}
temppAtoms = pAtoms;
for (prop = output->properties; prop; prop = prop->next)
@@ -458,9 +457,8 @@ ProcRRQueryOutputProperty (ClientPtr client)
rep.immutable = prop->immutable;
if (client->swapped)
{
int n;
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient (client, sizeof (xRRQueryOutputPropertyReply), (char*)&rep);
if (prop->num_valid)
@@ -615,13 +613,11 @@ ProcRRGetOutputProperty (ClientPtr client)
reply.propertyType = None;
reply.format = 0;
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
swaps(&reply.sequenceNumber);
swapl(&reply.length);
swapl(&reply.propertyType);
swapl(&reply.bytesAfter);
swapl(&reply.nItems);
}
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
return Success;
@@ -647,13 +643,11 @@ ProcRRGetOutputProperty (ClientPtr client)
reply.nItems = 0;
reply.propertyType = prop_value->type;
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
swaps(&reply.sequenceNumber);
swapl(&reply.length);
swapl(&reply.propertyType);
swapl(&reply.bytesAfter);
swapl(&reply.nItems);
}
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
return Success;
@@ -704,13 +698,11 @@ ProcRRGetOutputProperty (ClientPtr client)
}
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
swaps(&reply.sequenceNumber);
swapl(&reply.length);
swapl(&reply.propertyType);
swapl(&reply.bytesAfter);
swapl(&reply.nItems);
}
WriteToClient(client, sizeof(xGenericReply), &reply);
if (len)

106
randr/rrscreen.c
View File

@@ -232,14 +232,12 @@ ProcRRGetScreenSizeRange (ClientPtr client)
}
if (client->swapped)
{
int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.minWidth, n);
swaps(&rep.minHeight, n);
swaps(&rep.maxWidth, n);
swaps(&rep.maxHeight, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.minWidth);
swaps(&rep.minHeight);
swaps(&rep.maxWidth);
swaps(&rep.maxHeight);
}
WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), (char *)&rep);
return Success;
@@ -318,7 +316,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
rrScrPrivPtr pScrPriv;
CARD8 *extra;
unsigned long extraLen;
int i, n, rc, has_primary = 0;
int i, rc, has_primary = 0;
RRCrtc *crtcs;
RROutput *outputs;
xRRModeInfo *modeinfos;
@@ -401,7 +399,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
has_primary = 1;
crtcs[0] = pScrPriv->primaryOutput->crtc->id;
if (client->swapped)
swapl (&crtcs[0], n);
swapl(&crtcs[0]);
}
for (i = 0; i < pScrPriv->numCrtcs; i++)
@@ -414,14 +412,14 @@ rrGetScreenResources(ClientPtr client, Bool query)
}
crtcs[i + has_primary] = pScrPriv->crtcs[i]->id;
if (client->swapped)
swapl (&crtcs[i + has_primary], n);
swapl(&crtcs[i + has_primary]);
}
for (i = 0; i < pScrPriv->numOutputs; i++)
{
outputs[i] = pScrPriv->outputs[i]->id;
if (client->swapped)
swapl (&outputs[i], n);
swapl(&outputs[i]);
}
for (i = 0; i < num_modes; i++)
@@ -430,19 +428,19 @@ rrGetScreenResources(ClientPtr client, Bool query)
modeinfos[i] = mode->mode;
if (client->swapped)
{
swapl (&modeinfos[i].id, n);
swaps (&modeinfos[i].width, n);
swaps (&modeinfos[i].height, n);
swapl (&modeinfos[i].dotClock, n);
swaps (&modeinfos[i].hSyncStart, n);
swaps (&modeinfos[i].hSyncEnd, n);
swaps (&modeinfos[i].hTotal, n);
swaps (&modeinfos[i].hSkew, n);
swaps (&modeinfos[i].vSyncStart, n);
swaps (&modeinfos[i].vSyncEnd, n);
swaps (&modeinfos[i].vTotal, n);
swaps (&modeinfos[i].nameLength, n);
swapl (&modeinfos[i].modeFlags, n);
swapl(&modeinfos[i].id);
swaps(&modeinfos[i].width);
swaps(&modeinfos[i].height);
swapl(&modeinfos[i].dotClock);
swaps(&modeinfos[i].hSyncStart);
swaps(&modeinfos[i].hSyncEnd);
swaps(&modeinfos[i].hTotal);
swaps(&modeinfos[i].hSkew);
swaps(&modeinfos[i].vSyncStart);
swaps(&modeinfos[i].vSyncEnd);
swaps(&modeinfos[i].vTotal);
swaps(&modeinfos[i].nameLength);
swapl(&modeinfos[i].modeFlags);
}
memcpy (names, mode->name,
mode->mode.nameLength);
@@ -453,14 +451,14 @@ rrGetScreenResources(ClientPtr client, Bool query)
}
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.timestamp, n);
swapl(&rep.configTimestamp, n);
swaps(&rep.nCrtcs, n);
swaps(&rep.nOutputs, n);
swaps(&rep.nModes, n);
swaps(&rep.nbytesNames, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.timestamp);
swapl(&rep.configTimestamp);
swaps(&rep.nCrtcs);
swaps(&rep.nOutputs);
swaps(&rep.nModes);
swaps(&rep.nbytesNames);
}
WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *)&rep);
if (extraLen)
@@ -592,7 +590,7 @@ ProcRRGetScreenInfo (ClientPtr client)
REQUEST(xRRGetScreenInfoReq);
xRRGetScreenInfoReply rep;
WindowPtr pWin;
int n, rc;
int rc;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
CARD8 *extra;
@@ -688,10 +686,10 @@ ProcRRGetScreenInfo (ClientPtr client)
size->heightInMillimeters = pSize->mmHeight;
if (client->swapped)
{
swaps (&size->widthInPixels, n);
swaps (&size->heightInPixels, n);
swaps (&size->widthInMillimeters, n);
swaps (&size->heightInMillimeters, n);
swaps(&size->widthInPixels);
swaps(&size->heightInPixels);
swaps(&size->widthInMillimeters);
swaps(&size->heightInMillimeters);
}
size++;
if (has_rate)
@@ -699,7 +697,7 @@ ProcRRGetScreenInfo (ClientPtr client)
*rates = pSize->nRates;
if (client->swapped)
{
swaps (rates, n);
swaps(rates);
}
rates++;
for (j = 0; j < pSize->nRates; j++)
@@ -707,7 +705,7 @@ ProcRRGetScreenInfo (ClientPtr client)
*rates = pSize->pRates[j].rate;
if (client->swapped)
{
swaps (rates, n);
swaps(rates);
}
rates++;
}
@@ -723,14 +721,14 @@ ProcRRGetScreenInfo (ClientPtr client)
rep.length = bytes_to_int32(extraLen);
}
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.timestamp, n);
swaps(&rep.rotation, n);
swaps(&rep.nSizes, n);
swaps(&rep.sizeID, n);
swaps(&rep.rate, n);
swaps(&rep.nrateEnts, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.timestamp);
swaps(&rep.rotation);
swaps(&rep.nSizes);
swaps(&rep.sizeID);
swaps(&rep.rate);
swaps(&rep.nrateEnts);
}
WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *)&rep);
if (extraLen)
@@ -747,7 +745,7 @@ ProcRRSetScreenConfig (ClientPtr client)
REQUEST(xRRSetScreenConfigReq);
xRRSetScreenConfigReply rep;
DrawablePtr pDraw;
int n, rc;
int rc;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
TimeStamp time;
@@ -976,11 +974,11 @@ sendReply:
if (client->swapped)
{
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.newTimestamp, n);
swapl(&rep.newConfigTimestamp, n);
swapl(&rep.root, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.newTimestamp);
swapl(&rep.newConfigTimestamp);
swapl(&rep.root);
}
WriteToClient(client, sizeof(xRRSetScreenConfigReply), (char *)&rep);

262
randr/rrsdispatch.c
View File

@@ -25,149 +25,138 @@
static int
SProcRRQueryVersion (ClientPtr client)
{
register int n;
REQUEST(xRRQueryVersionReq);
swaps(&stuff->length, n);
swapl(&stuff->majorVersion, n);
swapl(&stuff->minorVersion, n);
swaps(&stuff->length);
swapl(&stuff->majorVersion);
swapl(&stuff->minorVersion);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetScreenInfo (ClientPtr client)
{
register int n;
REQUEST(xRRGetScreenInfoReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->length);
swapl(&stuff->window);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetScreenConfig (ClientPtr client)
{
register int n;
REQUEST(xRRSetScreenConfigReq);
if (RRClientKnowsRates (client))
{
REQUEST_SIZE_MATCH (xRRSetScreenConfigReq);
swaps (&stuff->rate, n);
swaps(&stuff->rate);
}
else
{
REQUEST_SIZE_MATCH (xRR1_0SetScreenConfigReq);
}
swaps(&stuff->length, n);
swapl(&stuff->drawable, n);
swapl(&stuff->timestamp, n);
swaps(&stuff->sizeID, n);
swaps(&stuff->rotation, n);
swaps(&stuff->length);
swapl(&stuff->drawable);
swapl(&stuff->timestamp);
swaps(&stuff->sizeID);
swaps(&stuff->rotation);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSelectInput (ClientPtr client)
{
register int n;
REQUEST(xRRSelectInputReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->enable, n);
swaps(&stuff->length);
swapl(&stuff->window);
swaps(&stuff->enable);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetScreenSizeRange (ClientPtr client)
{
int n;
REQUEST(xRRGetScreenSizeRangeReq);
REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->length);
swapl(&stuff->window);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetScreenSize (ClientPtr client)
{
int n;
REQUEST(xRRSetScreenSizeReq);
REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->width, n);
swaps(&stuff->height, n);
swapl(&stuff->widthInMillimeters, n);
swapl(&stuff->heightInMillimeters, n);
swaps(&stuff->length);
swapl(&stuff->window);
swaps(&stuff->width);
swaps(&stuff->height);
swapl(&stuff->widthInMillimeters);
swapl(&stuff->heightInMillimeters);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetScreenResources (ClientPtr client)
{
int n;
REQUEST(xRRGetScreenResourcesReq);
REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->length);
swapl(&stuff->window);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetOutputInfo (ClientPtr client)
{
int n;
REQUEST(xRRGetOutputInfoReq);
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->configTimestamp, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->configTimestamp);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRListOutputProperties (ClientPtr client)
{
int n;
REQUEST(xRRListOutputPropertiesReq);
REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swaps(&stuff->length);
swapl(&stuff->output);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRQueryOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRQueryOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->property);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRConfigureOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRConfigureOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->property);
SwapRestL(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
@@ -175,15 +164,14 @@ SProcRRConfigureOutputProperty (ClientPtr client)
static int
SProcRRChangeOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRChangeOutputPropertyReq);
REQUEST_AT_LEAST_SIZE (xRRChangeOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swapl(&stuff->type, n);
swapl(&stuff->nUnits, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch(stuff->format) {
case 8:
break;
@@ -203,125 +191,117 @@ SProcRRChangeOutputProperty (ClientPtr client)
static int
SProcRRDeleteOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRDeleteOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->property);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRGetOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swapl(&stuff->type, n);
swapl(&stuff->longOffset, n);
swapl(&stuff->longLength, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->longOffset);
swapl(&stuff->longLength);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRCreateMode (ClientPtr client)
{
int n;
xRRModeInfo *modeinfo;
REQUEST(xRRCreateModeReq);
REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->length);
swapl(&stuff->window);
modeinfo = &stuff->modeInfo;
swapl(&modeinfo->id, n);
swaps(&modeinfo->width, n);
swaps(&modeinfo->height, n);
swapl(&modeinfo->dotClock, n);
swaps(&modeinfo->hSyncStart, n);
swaps(&modeinfo->hSyncEnd, n);
swaps(&modeinfo->hTotal, n);
swaps(&modeinfo->vSyncStart, n);
swaps(&modeinfo->vSyncEnd, n);
swaps(&modeinfo->vTotal, n);
swaps(&modeinfo->nameLength, n);
swapl(&modeinfo->modeFlags, n);
swapl(&modeinfo->id);
swaps(&modeinfo->width);
swaps(&modeinfo->height);
swapl(&modeinfo->dotClock);
swaps(&modeinfo->hSyncStart);
swaps(&modeinfo->hSyncEnd);
swaps(&modeinfo->hTotal);
swaps(&modeinfo->vSyncStart);
swaps(&modeinfo->vSyncEnd);
swaps(&modeinfo->vTotal);
swaps(&modeinfo->nameLength);
swapl(&modeinfo->modeFlags);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRDestroyMode (ClientPtr client)
{
int n;
REQUEST(xRRDestroyModeReq);
REQUEST_SIZE_MATCH(xRRDestroyModeReq);
swaps(&stuff->length, n);
swapl(&stuff->mode, n);
swaps(&stuff->length);
swapl(&stuff->mode);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRAddOutputMode (ClientPtr client)
{
int n;
REQUEST(xRRAddOutputModeReq);
REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->mode, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->mode);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRDeleteOutputMode (ClientPtr client)
{
int n;
REQUEST(xRRDeleteOutputModeReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->mode, n);
swaps(&stuff->length);
swapl(&stuff->output);
swapl(&stuff->mode);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetCrtcInfo (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcInfoReq);
REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swapl(&stuff->configTimestamp, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
swapl(&stuff->configTimestamp);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetCrtcConfig (ClientPtr client)
{
int n;
REQUEST(xRRSetCrtcConfigReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swapl(&stuff->timestamp, n);
swapl(&stuff->configTimestamp, n);
swaps(&stuff->x, n);
swaps(&stuff->y, n);
swapl(&stuff->mode, n);
swaps(&stuff->rotation, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swapl(&stuff->configTimestamp);
swaps(&stuff->x);
swaps(&stuff->y);
swapl(&stuff->mode);
swaps(&stuff->rotation);
SwapRestL(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
@@ -329,37 +309,34 @@ SProcRRSetCrtcConfig (ClientPtr client)
static int
SProcRRGetCrtcGammaSize (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcGammaSizeReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetCrtcGamma (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcGammaReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetCrtcGamma (ClientPtr client)
{
int n;
REQUEST(xRRSetCrtcGammaReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->size, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
swaps(&stuff->size);
SwapRestS(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
@@ -367,16 +344,16 @@ SProcRRSetCrtcGamma (ClientPtr client)
static int
SProcRRSetCrtcTransform (ClientPtr client)
{
int n, nparams;
int nparams;
char *filter;
CARD32 *params;
REQUEST(xRRSetCrtcTransformReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
SwapLongs((CARD32 *)&stuff->transform, bytes_to_int32(sizeof(xRenderTransform)));
swaps(&stuff->nbytesFilter, n);
swaps(&stuff->nbytesFilter);
filter = (char *)(stuff + 1);
params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
nparams = ((CARD32 *) stuff + client->req_len) - params;
@@ -390,74 +367,69 @@ SProcRRSetCrtcTransform (ClientPtr client)
static int
SProcRRGetCrtcTransform (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcTransformReq);
REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetPanning (ClientPtr client)
{
int n;
REQUEST(xRRGetPanningReq);
REQUEST_SIZE_MATCH(xRRGetPanningReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetPanning (ClientPtr client)
{
int n;
REQUEST(xRRSetPanningReq);
REQUEST_SIZE_MATCH(xRRSetPanningReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swapl(&stuff->timestamp, n);
swaps(&stuff->left, n);
swaps(&stuff->top, n);
swaps(&stuff->width, n);
swaps(&stuff->height, n);
swaps(&stuff->track_left, n);
swaps(&stuff->track_top, n);
swaps(&stuff->track_width, n);
swaps(&stuff->track_height, n);
swaps(&stuff->border_left, n);
swaps(&stuff->border_top, n);
swaps(&stuff->border_right, n);
swaps(&stuff->border_bottom, n);
swaps(&stuff->length);
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swaps(&stuff->left);
swaps(&stuff->top);
swaps(&stuff->width);
swaps(&stuff->height);
swaps(&stuff->track_left);
swaps(&stuff->track_top);
swaps(&stuff->track_width);
swaps(&stuff->track_height);
swaps(&stuff->border_left);
swaps(&stuff->border_top);
swaps(&stuff->border_right);
swaps(&stuff->border_bottom);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetOutputPrimary (ClientPtr client)
{
int n;
REQUEST(xRRSetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swapl(&stuff->output, n);
swaps(&stuff->length);
swapl(&stuff->window);
swapl(&stuff->output);
return ProcRandrVector[stuff->randrReqType](client);
}
static int
SProcRRGetOutputPrimary (ClientPtr client)
{
int n;
REQUEST(xRRGetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->length);
swapl(&stuff->window);
return ProcRandrVector[stuff->randrReqType](client);
}

88
randr/rrxinerama.c
View File

@@ -90,7 +90,6 @@ int
ProcRRXineramaQueryVersion(ClientPtr client)
{
xPanoramiXQueryVersionReply rep;
register int n;
REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
rep.type = X_Reply;
@@ -99,10 +98,10 @@ ProcRRXineramaQueryVersion(ClientPtr client)
rep.majorVersion = SERVER_RRXINERAMA_MAJOR_VERSION;
rep.minorVersion = SERVER_RRXINERAMA_MINOR_VERSION;
if(client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.majorVersion, n);
swaps(&rep.minorVersion, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *)&rep);
return Success;
@@ -114,7 +113,7 @@ ProcRRXineramaGetState(ClientPtr client)
REQUEST(xPanoramiXGetStateReq);
WindowPtr pWin;
xPanoramiXGetStateReply rep;
register int n, rc;
register int rc;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
Bool active = FALSE;
@@ -138,9 +137,9 @@ ProcRRXineramaGetState(ClientPtr client)
rep.state = active;
rep.window = stuff->window;
if(client->swapped) {
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
swapl (&rep.window, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *)&rep);
return Success;
@@ -180,7 +179,7 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
REQUEST(xPanoramiXGetScreenCountReq);
WindowPtr pWin;
xPanoramiXGetScreenCountReply rep;
register int n, rc;
register int rc;
REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -193,9 +192,9 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
rep.ScreenCount = RRXineramaScreenCount (pWin->drawable.pScreen);
rep.window = stuff->window;
if(client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.window, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *)&rep);
return Success;
@@ -208,7 +207,7 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
WindowPtr pWin, pRoot;
ScreenPtr pScreen;
xPanoramiXGetScreenSizeReply rep;
register int n, rc;
register int rc;
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -226,12 +225,12 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
rep.window = stuff->window;
rep.screen = stuff->screen;
if(client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.width, n);
swapl(&rep.height, n);
swapl(&rep.window, n);
swapl(&rep.screen, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.width);
swapl(&rep.height);
swapl(&rep.window);
swapl(&rep.screen);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep);
return Success;
@@ -250,10 +249,9 @@ ProcRRXineramaIsActive(ClientPtr client)
rep.sequenceNumber = client->sequence;
rep.state = RRXineramaScreenActive (screenInfo.screens[RR_XINERAMA_SCREEN]);
if(client->swapped) {
register int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.state, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
return Success;
@@ -287,11 +285,10 @@ RRXineramaWriteCrtc(ClientPtr client, RRCrtcPtr crtc)
scratch.height = height;
}
if(client->swapped) {
register int n;
swaps(&scratch.x_org, n);
swaps(&scratch.y_org, n);
swaps(&scratch.width, n);
swaps(&scratch.height, n);
swaps(&scratch.x_org);
swaps(&scratch.y_org);
swaps(&scratch.width);
swaps(&scratch.height);
}
WriteToClient(client, sz_XineramaScreenInfo, &scratch);
}
@@ -313,10 +310,9 @@ ProcRRXineramaQueryScreens(ClientPtr client)
rep.number = RRXineramaScreenCount (pScreen);
rep.length = bytes_to_int32(rep.number * sz_XineramaScreenInfo);
if(client->swapped) {
register int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.number, n);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep);
@@ -371,8 +367,7 @@ static int
SProcRRXineramaQueryVersion (ClientPtr client)
{
REQUEST(xPanoramiXQueryVersionReq);
register int n;
swaps(&stuff->length,n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
return ProcRRXineramaQueryVersion(client);
}
@@ -381,10 +376,9 @@ static int
SProcRRXineramaGetState(ClientPtr client)
{
REQUEST(xPanoramiXGetStateReq);
register int n;
swaps (&stuff->length, n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
swapl (&stuff->window, n);
swapl(&stuff->window);
return ProcRRXineramaGetState(client);
}
@@ -392,10 +386,9 @@ static int
SProcRRXineramaGetScreenCount(ClientPtr client)
{
REQUEST(xPanoramiXGetScreenCountReq);
register int n;
swaps (&stuff->length, n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
swapl (&stuff->window, n);
swapl(&stuff->window);
return ProcRRXineramaGetScreenCount(client);
}
@@ -403,11 +396,10 @@ static int
SProcRRXineramaGetScreenSize(ClientPtr client)
{
REQUEST(xPanoramiXGetScreenSizeReq);
register int n;
swaps (&stuff->length, n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
swapl (&stuff->window, n);
swapl (&stuff->screen, n);
swapl(&stuff->window);
swapl(&stuff->screen);
return ProcRRXineramaGetScreenSize(client);
}
@@ -415,8 +407,7 @@ static int
SProcRRXineramaIsActive(ClientPtr client)
{
REQUEST(xXineramaIsActiveReq);
register int n;
swaps (&stuff->length, n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
return ProcRRXineramaIsActive(client);
}
@@ -425,8 +416,7 @@ static int
SProcRRXineramaQueryScreens(ClientPtr client)
{
REQUEST(xXineramaQueryScreensReq);
register int n;
swaps (&stuff->length, n);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
return ProcRRXineramaQueryScreens(client);
}