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

xkb: simplify reply struct initialization 

Use static initializaton as much as possible and drop unnecessary
or duplicate zero assignments.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>
This commit is contained in:
Enrico Weigelt, metux IT consult 2024-07-15 15:42:18 +02:00
parent 0180cf39f3
commit 41ae87912b
1 changed files with 124 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
xkb/xkb.c
View File

@ -173,7 +173,6 @@ int
ProcXkbUseExtension(ClientPtr client) ProcXkbUseExtension(ClientPtr client)
{ {
REQUEST(xkbUseExtensionReq); REQUEST(xkbUseExtensionReq);
xkbUseExtensionReply rep;
int supported; int supported;
REQUEST_SIZE_MATCH(xkbUseExtensionReq); REQUEST_SIZE_MATCH(xkbUseExtensionReq);
@ -197,11 +196,11 @@ ProcXkbUseExtension(ClientPtr client)
stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION, stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION,
SERVER_XKB_MINOR_VERSION); SERVER_XKB_MINOR_VERSION);
} }
rep = (xkbUseExtensionReply) {
xkbUseExtensionReply rep = {
.type = X_Reply, .type = X_Reply,
.supported = supported, .supported = supported,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.serverMajor = SERVER_XKB_MAJOR_VERSION, .serverMajor = SERVER_XKB_MAJOR_VERSION,
.serverMinor = SERVER_XKB_MINOR_VERSION .serverMinor = SERVER_XKB_MINOR_VERSION
}; };
@ -583,7 +582,6 @@ ProcXkbGetState(ClientPtr client)
{ {
REQUEST(xkbGetStateReq); REQUEST(xkbGetStateReq);
DeviceIntPtr dev; DeviceIntPtr dev;
xkbGetStateReply rep;
XkbStateRec *xkb; XkbStateRec *xkb;
REQUEST_SIZE_MATCH(xkbGetStateReq); REQUEST_SIZE_MATCH(xkbGetStateReq);
@ -594,11 +592,11 @@ ProcXkbGetState(ClientPtr client)
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess); CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
xkb = &dev->key->xkbInfo->state; xkb = &dev->key->xkbInfo->state;
rep = (xkbGetStateReply) {
xkbGetStateReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.mods = XkbStateFieldFromRec(xkb) & 0xff, .mods = XkbStateFieldFromRec(xkb) & 0xff,
.baseMods = xkb->base_mods, .baseMods = xkb->base_mods,
.latchedMods = xkb->latched_mods, .latchedMods = xkb->latched_mods,
@ -693,7 +691,6 @@ ProcXkbLatchLockState(ClientPtr client)
int int
ProcXkbGetControls(ClientPtr client) ProcXkbGetControls(ClientPtr client)
{ {
xkbGetControlsReply rep;
XkbControlsPtr xkb; XkbControlsPtr xkb;
DeviceIntPtr dev; DeviceIntPtr dev;
@ -706,12 +703,13 @@ ProcXkbGetControls(ClientPtr client)
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess); CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
xkb = dev->key->xkbInfo->desc->ctrls; xkb = dev->key->xkbInfo->desc->ctrls;
rep = (xkbGetControlsReply) {
xkbGetControlsReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = ((DeviceIntPtr) dev)->id, .deviceID = ((DeviceIntPtr) dev)->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = bytes_to_int32(SIZEOF(xkbGetControlsReply) - .length = bytes_to_int32(sizeof(xkbGetControlsReply) -
SIZEOF(xGenericReply)), sizeof(xGenericReply)),
.mkDfltBtn = xkb->mk_dflt_btn, .mkDfltBtn = xkb->mk_dflt_btn,
.numGroups = xkb->num_groups, .numGroups = xkb->num_groups,
.groupsWrap = xkb->groups_wrap, .groupsWrap = xkb->groups_wrap,
@ -1463,7 +1461,6 @@ int
ProcXkbGetMap(ClientPtr client) ProcXkbGetMap(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbGetMapReply rep;
XkbDescRec *xkb; XkbDescRec *xkb;
int n, status; int n, status;
@ -1479,18 +1476,19 @@ ProcXkbGetMap(ClientPtr client)
CHK_MASK_LEGAL(0x03, stuff->partial, XkbAllMapComponentsMask); CHK_MASK_LEGAL(0x03, stuff->partial, XkbAllMapComponentsMask);
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
rep = (xkbGetMapReply) {
xkbGetMapReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2, .length = bytes_to_int32(sizeof(xkbGetMapReply) - sizeof(xGenericReply)),
.present = stuff->partial | stuff->full, .present = stuff->partial | stuff->full,
.minKeyCode = xkb->min_key_code, .minKeyCode = xkb->min_key_code,
.maxKeyCode = xkb->max_key_code .maxKeyCode = xkb->max_key_code,
.totalTypes = xkb->map->num_types,
}; };
if (stuff->full & XkbKeyTypesMask) { if (stuff->full & XkbKeyTypesMask) {
rep.firstType = 0;
rep.nTypes = xkb->map->num_types; rep.nTypes = xkb->map->num_types;
} }
else if (stuff->partial & XkbKeyTypesMask) { else if (stuff->partial & XkbKeyTypesMask) {
@ -1502,9 +1500,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstType = stuff->firstType; rep.firstType = stuff->firstType;
rep.nTypes = stuff->nTypes; rep.nTypes = stuff->nTypes;
} }
else
rep.nTypes = 0;
rep.totalTypes = xkb->map->num_types;
n = XkbNumKeys(xkb); n = XkbNumKeys(xkb);
if (stuff->full & XkbKeySymsMask) { if (stuff->full & XkbKeySymsMask) {
@ -1516,9 +1511,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstKeySym = stuff->firstKeySym; rep.firstKeySym = stuff->firstKeySym;
rep.nKeySyms = stuff->nKeySyms; rep.nKeySyms = stuff->nKeySyms;
} }
else
rep.nKeySyms = 0;
rep.totalSyms = 0;
if (stuff->full & XkbKeyActionsMask) { if (stuff->full & XkbKeyActionsMask) {
rep.firstKeyAct = xkb->min_key_code; rep.firstKeyAct = xkb->min_key_code;
@ -1529,9 +1521,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstKeyAct = stuff->firstKeyAct; rep.firstKeyAct = stuff->firstKeyAct;
rep.nKeyActs = stuff->nKeyActs; rep.nKeyActs = stuff->nKeyActs;
} }
else
rep.nKeyActs = 0;
rep.totalActs = 0;
if (stuff->full & XkbKeyBehaviorsMask) { if (stuff->full & XkbKeyBehaviorsMask) {
rep.firstKeyBehavior = xkb->min_key_code; rep.firstKeyBehavior = xkb->min_key_code;
@ -1542,9 +1531,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstKeyBehavior = stuff->firstKeyBehavior; rep.firstKeyBehavior = stuff->firstKeyBehavior;
rep.nKeyBehaviors = stuff->nKeyBehaviors; rep.nKeyBehaviors = stuff->nKeyBehaviors;
} }
else
rep.nKeyBehaviors = 0;
rep.totalKeyBehaviors = 0;
if (stuff->full & XkbVirtualModsMask) if (stuff->full & XkbVirtualModsMask)
rep.virtualMods = ~0; rep.virtualMods = ~0;
@ -1560,9 +1546,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstKeyExplicit = stuff->firstKeyExplicit; rep.firstKeyExplicit = stuff->firstKeyExplicit;
rep.nKeyExplicit = stuff->nKeyExplicit; rep.nKeyExplicit = stuff->nKeyExplicit;
} }
else
rep.nKeyExplicit = 0;
rep.totalKeyExplicit = 0;
if (stuff->full & XkbModifierMapMask) { if (stuff->full & XkbModifierMapMask) {
rep.firstModMapKey = xkb->min_key_code; rep.firstModMapKey = xkb->min_key_code;
@ -1573,9 +1556,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstModMapKey = stuff->firstModMapKey; rep.firstModMapKey = stuff->firstModMapKey;
rep.nModMapKeys = stuff->nModMapKeys; rep.nModMapKeys = stuff->nModMapKeys;
} }
else
rep.nModMapKeys = 0;
rep.totalModMapKeys = 0;
if (stuff->full & XkbVirtualModMapMask) { if (stuff->full & XkbVirtualModMapMask) {
rep.firstVModMapKey = xkb->min_key_code; rep.firstVModMapKey = xkb->min_key_code;
@ -1586,9 +1566,6 @@ ProcXkbGetMap(ClientPtr client)
rep.firstVModMapKey = stuff->firstVModMapKey; rep.firstVModMapKey = stuff->firstVModMapKey;
rep.nVModMapKeys = stuff->nVModMapKeys; rep.nVModMapKeys = stuff->nVModMapKeys;
} }
else
rep.nVModMapKeys = 0;
rep.totalVModMapKeys = 0;
if ((status = XkbComputeGetMapReplySize(xkb, &rep)) != Success) if ((status = XkbComputeGetMapReplySize(xkb, &rep)) != Success)
return status; return status;
@ -2156,14 +2133,11 @@ SetKeySyms(ClientPtr client,
s = XkbKeyNumGroups(xkb, i); s = XkbKeyNumGroups(xkb, i);
} }
if (s != xkb->ctrls->num_groups) { if (s != xkb->ctrls->num_groups) {
xkbControlsNotify cn; xkbControlsNotify cn = {
XkbControlsRec old; .requestMajor = XkbReqCode,
.requestMinor = X_kbSetMap,
cn.keycode = 0; };
cn.eventType = 0; XkbControlsRec old = *xkb->ctrls;
cn.requestMajor = XkbReqCode;
cn.requestMinor = X_kbSetMap;
old = *xkb->ctrls;
xkb->ctrls->num_groups = s; xkb->ctrls->num_groups = s;
if (XkbComputeControlsNotify(dev, &old, xkb->ctrls, &cn, FALSE)) if (XkbComputeControlsNotify(dev, &old, xkb->ctrls, &cn, FALSE))
XkbSendControlsNotify(dev, &cn); XkbSendControlsNotify(dev, &cn);
@ -2900,7 +2874,6 @@ XkbSendCompatMap(ClientPtr client,
int int
ProcXkbGetCompatMap(ClientPtr client) ProcXkbGetCompatMap(ClientPtr client)
{ {
xkbGetCompatMapReply rep;
DeviceIntPtr dev; DeviceIntPtr dev;
XkbDescPtr xkb; XkbDescPtr xkb;
XkbCompatMapPtr compat; XkbCompatMapPtr compat;
@ -2916,13 +2889,14 @@ ProcXkbGetCompatMap(ClientPtr client)
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
compat = xkb->compat; compat = xkb->compat;
rep = (xkbGetCompatMapReply) { xkbGetCompatMapReply rep = {
.type = X_Reply, .type = X_Reply,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.deviceID = dev->id, .deviceID = dev->id,
.firstSI = stuff->firstSI, .firstSI = stuff->firstSI,
.nSI = stuff->nSI .nSI = stuff->nSI,
.nTotalSI = compat->num_si,
.groups = stuff->groups,
}; };
if (stuff->getAllSI) { if (stuff->getAllSI) {
rep.firstSI = 0; rep.firstSI = 0;
@ -2933,8 +2907,6 @@ ProcXkbGetCompatMap(ClientPtr client)
client->errorValue = _XkbErrCode2(0x05, compat->num_si); client->errorValue = _XkbErrCode2(0x05, compat->num_si);
return BadValue; return BadValue;
} }
rep.nTotalSI = compat->num_si;
rep.groups = stuff->groups;
XkbComputeGetCompatMapReplySize(compat, &rep); XkbComputeGetCompatMapReplySize(compat, &rep);
return XkbSendCompatMap(client, compat, &rep); return XkbSendCompatMap(client, compat, &rep);
} }
@ -3080,12 +3052,11 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
} }
if (req->recomputeActions) { if (req->recomputeActions) {
XkbChangesRec change; XkbChangesRec change = { 0 };
unsigned check; unsigned check;
XkbEventCauseRec cause; XkbEventCauseRec cause;
XkbSetCauseXkbReq(&cause, X_kbSetCompatMap, client); XkbSetCauseXkbReq(&cause, X_kbSetCompatMap, client);
memset(&change, 0, sizeof(XkbChangesRec));
XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &change, XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &change,
&check, &cause); &check, &cause);
if (check) if (check)
@ -3161,7 +3132,6 @@ ProcXkbSetCompatMap(ClientPtr client)
int int
ProcXkbGetIndicatorState(ClientPtr client) ProcXkbGetIndicatorState(ClientPtr client)
{ {
xkbGetIndicatorStateReply rep;
XkbSrvLedInfoPtr sli; XkbSrvLedInfoPtr sli;
DeviceIntPtr dev; DeviceIntPtr dev;
@ -3178,11 +3148,10 @@ ProcXkbGetIndicatorState(ClientPtr client)
if (!sli) if (!sli)
return BadAlloc; return BadAlloc;
rep = (xkbGetIndicatorStateReply) { xkbGetIndicatorStateReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.state = sli->effectiveState .state = sli->effectiveState
}; };
@ -3277,7 +3246,6 @@ XkbSendIndicatorMap(ClientPtr client,
int int
ProcXkbGetIndicatorMap(ClientPtr client) ProcXkbGetIndicatorMap(ClientPtr client)
{ {
xkbGetIndicatorMapReply rep;
DeviceIntPtr dev; DeviceIntPtr dev;
XkbDescPtr xkb; XkbDescPtr xkb;
XkbIndicatorPtr leds; XkbIndicatorPtr leds;
@ -3293,11 +3261,10 @@ ProcXkbGetIndicatorMap(ClientPtr client)
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
leds = xkb->indicators; leds = xkb->indicators;
rep = (xkbGetIndicatorMapReply) { xkbGetIndicatorMapReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.which = stuff->which .which = stuff->which
}; };
XkbComputeGetIndicatorMapReplySize(leds, &rep); XkbComputeGetIndicatorMapReplySize(leds, &rep);
@ -3420,7 +3387,6 @@ int
ProcXkbGetNamedIndicator(ClientPtr client) ProcXkbGetNamedIndicator(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbGetNamedIndicatorReply rep;
register int i = 0; register int i = 0;
XkbSrvLedInfoPtr sli; XkbSrvLedInfoPtr sli;
XkbIndicatorMapPtr map = NULL; XkbIndicatorMapPtr map = NULL;
@ -3449,12 +3415,13 @@ ProcXkbGetNamedIndicator(ClientPtr client)
} }
} }
rep = (xkbGetNamedIndicatorReply) { xkbGetNamedIndicatorReply rep = {
.type = X_Reply, .type = X_Reply,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.deviceID = dev->id, .deviceID = dev->id,
.indicator = stuff->indicator .indicator = stuff->indicator,
.supported = TRUE,
.ndx = XkbNoIndicator,
}; };
if (map != NULL) { if (map != NULL) {
rep.found = TRUE; rep.found = TRUE;
@ -3469,22 +3436,6 @@ ProcXkbGetNamedIndicator(ClientPtr client)
rep.realMods = map->mods.real_mods; rep.realMods = map->mods.real_mods;
rep.virtualMods = map->mods.vmods; rep.virtualMods = map->mods.vmods;
rep.ctrls = map->ctrls; rep.ctrls = map->ctrls;
rep.supported = TRUE;
}
else {
rep.found = FALSE;
rep.on = FALSE;
rep.realIndicator = FALSE;
rep.ndx = XkbNoIndicator;
rep.flags = 0;
rep.whichGroups = 0;
rep.groups = 0;
rep.whichMods = 0;
rep.mods = 0;
rep.realMods = 0;
rep.virtualMods = 0;
rep.ctrls = 0;
rep.supported = TRUE;
} }
if (client->swapped) { if (client->swapped) {
swapl(&rep.length); swapl(&rep.length);
@ -3578,8 +3529,8 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
XkbIndicatorMapPtr map; XkbIndicatorMapPtr map;
DeviceIntPtr kbd; DeviceIntPtr kbd;
XkbEventCauseRec cause; XkbEventCauseRec cause;
xkbExtensionDeviceNotify ed; xkbExtensionDeviceNotify ed = { 0 };
XkbChangesRec changes; XkbChangesRec changes = { 0 };
int rc; int rc;
rc = _XkbCreateIndicatorMap(dev, stuff->indicator, stuff->ledClass, rc = _XkbCreateIndicatorMap(dev, stuff->indicator, stuff->ledClass,
@ -3617,8 +3568,6 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
statec |= ((sli->effectiveState ^ sli->explicitState) & (1 << led)); statec |= ((sli->effectiveState ^ sli->explicitState) & (1 << led));
} }
memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
memset((char *) &changes, 0, sizeof(XkbChangesRec));
XkbSetCauseXkbReq(&cause, X_kbSetNamedIndicator, client); XkbSetCauseXkbReq(&cause, X_kbSetNamedIndicator, client);
if (namec) if (namec)
XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause); XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
@ -4016,7 +3965,6 @@ ProcXkbGetNames(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
XkbDescPtr xkb; XkbDescPtr xkb;
xkbGetNamesReply rep;
REQUEST(xkbGetNamesReq); REQUEST(xkbGetNamesReq);
REQUEST_SIZE_MATCH(xkbGetNamesReq); REQUEST_SIZE_MATCH(xkbGetNamesReq);
@ -4028,11 +3976,11 @@ ProcXkbGetNames(ClientPtr client)
CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask); CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask);
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
rep = (xkbGetNamesReply) {
xkbGetNamesReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.which = stuff->which, .which = stuff->which,
.nTypes = xkb->map->num_types, .nTypes = xkb->map->num_types,
.firstKey = xkb->min_key_code, .firstKey = xkb->min_key_code,
@ -5090,7 +5038,6 @@ int
ProcXkbGetGeometry(ClientPtr client) ProcXkbGetGeometry(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbGetGeometryReply rep;
XkbGeometryPtr geom; XkbGeometryPtr geom;
Bool shouldFree; Bool shouldFree;
Status status; Status status;
@ -5105,11 +5052,11 @@ ProcXkbGetGeometry(ClientPtr client)
CHK_ATOM_OR_NONE(stuff->name); CHK_ATOM_OR_NONE(stuff->name);
geom = XkbLookupNamedGeometry(dev, stuff->name, &shouldFree); geom = XkbLookupNamedGeometry(dev, stuff->name, &shouldFree);
rep = (xkbGetGeometryReply) {
xkbGetGeometryReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0
}; };
status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name); status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name);
if (status != Success) if (status != Success)
@ -5612,22 +5559,23 @@ _XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
{ {
XkbDescPtr xkb; XkbDescPtr xkb;
Bool new_name; Bool new_name;
xkbNewKeyboardNotify nkn;
XkbGeometryPtr geom, old; XkbGeometryPtr geom, old;
XkbGeometrySizesRec sizes;
Status status; Status status;
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
old = xkb->geom; old = xkb->geom;
xkb->geom = NULL; xkb->geom = NULL;
sizes.which = XkbGeomAllMask; XkbGeometrySizesRec sizes = {
sizes.num_properties = stuff->nProperties; .which = XkbGeomAllMask,
sizes.num_colors = stuff->nColors; .num_properties = stuff->nProperties,
sizes.num_shapes = stuff->nShapes; .num_colors = stuff->nColors,
sizes.num_sections = stuff->nSections; .num_shapes = stuff->nShapes,
sizes.num_doodads = stuff->nDoodads; .num_sections = stuff->nSections,
sizes.num_key_aliases = stuff->nKeyAliases; .num_doodads = stuff->nDoodads,
.num_key_aliases = stuff->nKeyAliases,
};
if ((status = XkbAllocGeometry(xkb, &sizes)) != Success) { if ((status = XkbAllocGeometry(xkb, &sizes)) != Success) {
xkb->geom = old; xkb->geom = old;
return status; return status;
@ -5646,18 +5594,21 @@ _XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
if (old) if (old)
XkbFreeGeometry(old, XkbGeomAllMask, TRUE); XkbFreeGeometry(old, XkbGeomAllMask, TRUE);
if (new_name) { if (new_name) {
xkbNamesNotify nn; xkbNamesNotify nn = {
.changed = XkbGeometryNameMask,
memset(&nn, 0, sizeof(xkbNamesNotify)); };
nn.changed = XkbGeometryNameMask;
XkbSendNamesNotify(dev, &nn); XkbSendNamesNotify(dev, &nn);
} }
nkn.deviceID = nkn.oldDeviceID = dev->id;
nkn.minKeyCode = nkn.oldMinKeyCode = xkb->min_key_code; xkbNewKeyboardNotify nkn = {
nkn.maxKeyCode = nkn.oldMaxKeyCode = xkb->max_key_code; .deviceID = nkn.oldDeviceID = dev->id,
nkn.requestMajor = XkbReqCode; .minKeyCode = nkn.oldMinKeyCode = xkb->min_key_code,
nkn.requestMinor = X_kbSetGeometry; .maxKeyCode = nkn.oldMaxKeyCode = xkb->max_key_code,
nkn.changed = XkbNKN_GeometryMask; .requestMajor = XkbReqCode,
.requestMinor = X_kbSetGeometry,
.changed = XkbNKN_GeometryMask,
};
XkbSendNewKeyboardNotify(dev, &nkn); XkbSendNewKeyboardNotify(dev, &nkn);
return Success; return Success;
} }
@ -5703,7 +5654,6 @@ int
ProcXkbPerClientFlags(ClientPtr client) ProcXkbPerClientFlags(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbPerClientFlagsReply rep;
XkbInterestPtr interest; XkbInterestPtr interest;
Mask access_mode = DixGetAttrAccess | DixSetAttrAccess; Mask access_mode = DixGetAttrAccess | DixSetAttrAccess;
@ -5754,10 +5704,9 @@ ProcXkbPerClientFlags(ClientPtr client)
} }
} }
rep = (xkbPerClientFlagsReply) { xkbPerClientFlagsReply rep = {
.type = X_Reply, .type = X_Reply,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.supported = XkbPCF_AllFlagsMask, .supported = XkbPCF_AllFlagsMask,
.value = client->xkbClientFlags & XkbPCF_AllFlagsMask, .value = client->xkbClientFlags & XkbPCF_AllFlagsMask,
.autoCtrls = interest ? interest->autoCtrls : 0, .autoCtrls = interest ? interest->autoCtrls : 0,
@ -5850,7 +5799,6 @@ int
ProcXkbListComponents(ClientPtr client) ProcXkbListComponents(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbListComponentsReply rep;
unsigned len; unsigned len;
unsigned char *str; unsigned char *str;
uint8_t size; uint8_t size;
@ -5880,29 +5828,15 @@ ProcXkbListComponents(ClientPtr client)
} }
if ((XkbPaddedSize(len) / 4) != client->req_len) if ((XkbPaddedSize(len) / 4) != client->req_len)
return BadLength; return BadLength;
rep = (xkbListComponentsReply) {
xkbListComponentsReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.nKeymaps = 0,
.nKeycodes = 0,
.nTypes = 0,
.nCompatMaps = 0,
.nSymbols = 0,
.nGeometries = 0,
.extra = 0
}; };
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.length); swapl(&rep.length);
swaps(&rep.nKeymaps);
swaps(&rep.nKeycodes);
swaps(&rep.nTypes);
swaps(&rep.nCompatMaps);
swaps(&rep.nSymbols);
swaps(&rep.nGeometries);
swaps(&rep.extra);
} }
WriteToClient(client, SIZEOF(xkbListComponentsReply), &rep); WriteToClient(client, SIZEOF(xkbListComponentsReply), &rep);
return Success; return Success;
@ -5954,17 +5888,15 @@ ProcXkbGetKbdByName(ClientPtr client)
DeviceIntPtr dev; DeviceIntPtr dev;
DeviceIntPtr tmpd; DeviceIntPtr tmpd;
DeviceIntPtr master; DeviceIntPtr master;
xkbGetKbdByNameReply rep = { 0 };
xkbGetMapReply mrep = { 0 }; xkbGetMapReply mrep = { 0 };
xkbGetCompatMapReply crep = { 0 }; xkbGetCompatMapReply crep = { 0 };
xkbGetIndicatorMapReply irep = { 0 }; xkbGetIndicatorMapReply irep = { 0 };
xkbGetNamesReply nrep = { 0 }; xkbGetNamesReply nrep = { 0 };
xkbGetGeometryReply grep = { 0 }; xkbGetGeometryReply grep = { 0 };
XkbComponentNamesRec names = { 0 };
XkbDescPtr xkb, new; XkbDescPtr xkb, new;
XkbEventCauseRec cause; XkbEventCauseRec cause;
unsigned char *str; unsigned char *str;
char mapFile[PATH_MAX]; char mapFile[PATH_MAX] = { 0 };
unsigned len; unsigned len;
unsigned fwant, fneed, reported; unsigned fwant, fneed, reported;
int status; int status;
@ -5992,11 +5924,15 @@ ProcXkbGetKbdByName(ClientPtr client)
return BadMatch; return BadMatch;
} }
} }
names.keycodes = GetComponentSpec(client, stuff, &str, TRUE, &status);
names.types = GetComponentSpec(client, stuff, &str, TRUE, &status); XkbComponentNamesRec names = {
names.compat = GetComponentSpec(client, stuff, &str, TRUE, &status); .keycodes = GetComponentSpec(client, stuff, &str, TRUE, &status),
names.symbols = GetComponentSpec(client, stuff, &str, TRUE, &status); .types = GetComponentSpec(client, stuff, &str, TRUE, &status),
names.geometry = GetComponentSpec(client, stuff, &str, TRUE, &status); .compat = GetComponentSpec(client, stuff, &str, TRUE, &status),
.symbols = GetComponentSpec(client, stuff, &str, TRUE, &status),
.geometry = GetComponentSpec(client, stuff, &str, TRUE, &status),
};
if (status == Success) { if (status == Success) {
len = str - ((unsigned char *) stuff); len = str - ((unsigned char *) stuff);
if ((XkbPaddedSize(len) / 4) != client->req_len) if ((XkbPaddedSize(len) / 4) != client->req_len)
@ -6036,18 +5972,10 @@ ProcXkbGetKbdByName(ClientPtr client)
geom_changed = FALSE; geom_changed = FALSE;
} }
memset(mapFile, 0, PATH_MAX);
rep.type = X_Reply;
rep.deviceID = dev->id;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.minKeyCode = xkb->min_key_code;
rep.maxKeyCode = xkb->max_key_code;
rep.loaded = FALSE;
fwant = fwant =
XkbConvertGetByNameComponents(TRUE, stuff->want) | XkmVirtualModsMask; XkbConvertGetByNameComponents(TRUE, stuff->want) | XkmVirtualModsMask;
fneed = XkbConvertGetByNameComponents(TRUE, stuff->need); fneed = XkbConvertGetByNameComponents(TRUE, stuff->need);
rep.reported = XkbConvertGetByNameComponents(FALSE, fwant | fneed);
if (stuff->load) { if (stuff->load) {
fneed |= XkmKeymapRequired; fneed |= XkmKeymapRequired;
fwant |= XkmKeymapLegal; fwant |= XkmKeymapLegal;
@ -6057,11 +5985,17 @@ ProcXkbGetKbdByName(ClientPtr client)
fwant |= XkmIndicatorsIndex; fwant |= XkmIndicatorsIndex;
} }
/* We pass dev in here so we can get the old names out if needed. */ xkbGetKbdByNameReply rep = {
rep.found = XkbDDXLoadKeymapByNames(dev, &names, fwant, fneed, &new, .type = X_Reply,
mapFile, PATH_MAX); .deviceID = dev->id,
rep.newKeyboard = FALSE; .sequenceNumber = client->sequence,
rep.pad1 = rep.pad2 = rep.pad3 = rep.pad4 = 0; .minKeyCode = xkb->min_key_code,
.maxKeyCode = xkb->max_key_code,
.reported = XkbConvertGetByNameComponents(FALSE, fwant | fneed),
/* We pass dev in here so we can get the old names out if needed. */
.found = XkbDDXLoadKeymapByNames(dev, &names, fwant, fneed, &new,
mapFile, PATH_MAX),
};
stuff->want |= stuff->need; stuff->want |= stuff->need;
if (new == NULL) if (new == NULL)
@ -6071,9 +6005,7 @@ ProcXkbGetKbdByName(ClientPtr client)
rep.loaded = TRUE; rep.loaded = TRUE;
if (stuff->load || if (stuff->load ||
((rep.reported & XkbGBN_SymbolsMask) && (new->compat))) { ((rep.reported & XkbGBN_SymbolsMask) && (new->compat))) {
XkbChangesRec changes; XkbChangesRec changes = { 0 };
memset(&changes, 0, sizeof(changes));
XkbUpdateDescActions(new, XkbUpdateDescActions(new,
new->min_key_code, XkbNumKeys(new), &changes); new->min_key_code, XkbNumKeys(new), &changes);
} }
@ -6088,28 +6020,18 @@ ProcXkbGetKbdByName(ClientPtr client)
((SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2); ((SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2);
mrep.minKeyCode = new->min_key_code; mrep.minKeyCode = new->min_key_code;
mrep.maxKeyCode = new->max_key_code; mrep.maxKeyCode = new->max_key_code;
mrep.present = 0;
mrep.totalSyms = mrep.totalActs = mrep.totalSyms = mrep.totalActs =
mrep.totalKeyBehaviors = mrep.totalKeyExplicit = mrep.totalKeyBehaviors = mrep.totalKeyExplicit =
mrep.totalModMapKeys = mrep.totalVModMapKeys = 0; mrep.totalModMapKeys = mrep.totalVModMapKeys = 0;
if (rep.reported & (XkbGBN_TypesMask | XkbGBN_ClientSymbolsMask)) { if (rep.reported & (XkbGBN_TypesMask | XkbGBN_ClientSymbolsMask)) {
mrep.present |= XkbKeyTypesMask; mrep.present |= XkbKeyTypesMask;
mrep.firstType = 0;
mrep.nTypes = mrep.totalTypes = new->map->num_types; mrep.nTypes = mrep.totalTypes = new->map->num_types;
} }
else {
mrep.firstType = mrep.nTypes = 0;
mrep.totalTypes = 0;
}
if (rep.reported & XkbGBN_ClientSymbolsMask) { if (rep.reported & XkbGBN_ClientSymbolsMask) {
mrep.present |= (XkbKeySymsMask | XkbModifierMapMask); mrep.present |= (XkbKeySymsMask | XkbModifierMapMask);
mrep.firstKeySym = mrep.firstModMapKey = new->min_key_code; mrep.firstKeySym = mrep.firstModMapKey = new->min_key_code;
mrep.nKeySyms = mrep.nModMapKeys = XkbNumKeys(new); mrep.nKeySyms = mrep.nModMapKeys = XkbNumKeys(new);
} }
else {
mrep.firstKeySym = mrep.firstModMapKey = 0;
mrep.nKeySyms = mrep.nModMapKeys = 0;
}
if (rep.reported & XkbGBN_ServerSymbolsMask) { if (rep.reported & XkbGBN_ServerSymbolsMask) {
mrep.present |= XkbAllServerInfoMask; mrep.present |= XkbAllServerInfoMask;
mrep.virtualMods = ~0; mrep.virtualMods = ~0;
@ -6120,12 +6042,6 @@ ProcXkbGetKbdByName(ClientPtr client)
mrep.firstVModMapKey = new->min_key_code; mrep.firstVModMapKey = new->min_key_code;
mrep.nVModMapKeys = XkbNumKeys(new); mrep.nVModMapKeys = XkbNumKeys(new);
} }
else {
mrep.virtualMods = 0;
mrep.firstKeyAct = mrep.firstKeyBehavior =
mrep.firstKeyExplicit = 0;
mrep.nKeyActs = mrep.nKeyBehaviors = mrep.nKeyExplicit = 0;
}
XkbComputeGetMapReplySize(new, &mrep); XkbComputeGetMapReplySize(new, &mrep);
rep.length += SIZEOF(xGenericReply) / 4 + mrep.length; rep.length += SIZEOF(xGenericReply) / 4 + mrep.length;
} }
@ -6135,9 +6051,7 @@ ProcXkbGetKbdByName(ClientPtr client)
crep.type = X_Reply; crep.type = X_Reply;
crep.deviceID = dev->id; crep.deviceID = dev->id;
crep.sequenceNumber = client->sequence; crep.sequenceNumber = client->sequence;
crep.length = 0;
crep.groups = XkbAllGroupsMask; crep.groups = XkbAllGroupsMask;
crep.firstSI = 0;
crep.nSI = crep.nTotalSI = new->compat->num_si; crep.nSI = crep.nTotalSI = new->compat->num_si;
XkbComputeGetCompatMapReplySize(new->compat, &crep); XkbComputeGetCompatMapReplySize(new->compat, &crep);
rep.length += SIZEOF(xGenericReply) / 4 + crep.length; rep.length += SIZEOF(xGenericReply) / 4 + crep.length;
@ -6148,7 +6062,6 @@ ProcXkbGetKbdByName(ClientPtr client)
irep.type = X_Reply; irep.type = X_Reply;
irep.deviceID = dev->id; irep.deviceID = dev->id;
irep.sequenceNumber = client->sequence; irep.sequenceNumber = client->sequence;
irep.length = 0;
irep.which = XkbAllIndicatorsMask; irep.which = XkbAllIndicatorsMask;
XkbComputeGetIndicatorMapReplySize(new->indicators, &irep); XkbComputeGetIndicatorMapReplySize(new->indicators, &irep);
rep.length += SIZEOF(xGenericReply) / 4 + irep.length; rep.length += SIZEOF(xGenericReply) / 4 + irep.length;
@ -6159,30 +6072,17 @@ ProcXkbGetKbdByName(ClientPtr client)
nrep.type = X_Reply; nrep.type = X_Reply;
nrep.deviceID = dev->id; nrep.deviceID = dev->id;
nrep.sequenceNumber = client->sequence; nrep.sequenceNumber = client->sequence;
nrep.length = 0;
nrep.minKeyCode = new->min_key_code; nrep.minKeyCode = new->min_key_code;
nrep.maxKeyCode = new->max_key_code; nrep.maxKeyCode = new->max_key_code;
if (rep.reported & XkbGBN_OtherNamesMask) { if (rep.reported & XkbGBN_OtherNamesMask) {
nrep.which = XkbAllNamesMask; nrep.which = XkbAllNamesMask;
if (new->map != NULL) if (new->map != NULL)
nrep.nTypes = new->map->num_types; nrep.nTypes = new->map->num_types;
else
nrep.nTypes = 0;
nrep.nKTLevels = 0;
nrep.groupNames = XkbAllGroupsMask; nrep.groupNames = XkbAllGroupsMask;
nrep.virtualMods = XkbAllVirtualModsMask; nrep.virtualMods = XkbAllVirtualModsMask;
nrep.indicators = XkbAllIndicatorsMask; nrep.indicators = XkbAllIndicatorsMask;
nrep.nRadioGroups = new->names->num_rg; nrep.nRadioGroups = new->names->num_rg;
} }
else {
nrep.which = 0;
nrep.nTypes = 0;
nrep.nKTLevels = 0;
nrep.groupNames = 0;
nrep.virtualMods = 0;
nrep.indicators = 0;
nrep.nRadioGroups = 0;
}
if (rep.reported & XkbGBN_KeyNamesMask) { if (rep.reported & XkbGBN_KeyNamesMask) {
nrep.which |= XkbKeyNamesMask; nrep.which |= XkbKeyNamesMask;
nrep.firstKey = new->min_key_code; nrep.firstKey = new->min_key_code;
@ -6193,8 +6093,6 @@ ProcXkbGetKbdByName(ClientPtr client)
} }
else { else {
nrep.which &= ~(XkbKeyNamesMask | XkbKeyAliasesMask); nrep.which &= ~(XkbKeyNamesMask | XkbKeyAliasesMask);
nrep.firstKey = nrep.nKeys = 0;
nrep.nKeyAliases = 0;
} }
XkbComputeGetNamesReplySize(new, &nrep); XkbComputeGetNamesReplySize(new, &nrep);
rep.length += SIZEOF(xGenericReply) / 4 + nrep.length; rep.length += SIZEOF(xGenericReply) / 4 + nrep.length;
@ -6205,13 +6103,7 @@ ProcXkbGetKbdByName(ClientPtr client)
grep.type = X_Reply; grep.type = X_Reply;
grep.deviceID = dev->id; grep.deviceID = dev->id;
grep.sequenceNumber = client->sequence; grep.sequenceNumber = client->sequence;
grep.length = 0;
grep.found = TRUE; grep.found = TRUE;
grep.pad = 0;
grep.widthMM = grep.heightMM = 0;
grep.nProperties = grep.nColors = grep.nShapes = 0;
grep.nSections = grep.nDoodads = 0;
grep.baseColorNdx = grep.labelColorNdx = 0;
XkbComputeGetGeometryReplySize(new->geom, &grep, None); XkbComputeGetGeometryReplySize(new->geom, &grep, None);
rep.length += SIZEOF(xGenericReply) / 4 + grep.length; rep.length += SIZEOF(xGenericReply) / 4 + grep.length;
} }
@ -6237,7 +6129,6 @@ ProcXkbGetKbdByName(ClientPtr client)
XkbSendGeometry(client, new->geom, &grep); XkbSendGeometry(client, new->geom, &grep);
if (rep.loaded) { if (rep.loaded) {
XkbDescPtr old_xkb; XkbDescPtr old_xkb;
xkbNewKeyboardNotify nkn;
old_xkb = xkb; old_xkb = xkb;
xkb = new; xkb = new;
@ -6246,14 +6137,16 @@ ProcXkbGetKbdByName(ClientPtr client)
XkbCopyControls(xkb, old_xkb); XkbCopyControls(xkb, old_xkb);
nkn.deviceID = nkn.oldDeviceID = dev->id; xkbNewKeyboardNotify nkn = {
nkn.minKeyCode = new->min_key_code; .deviceID = nkn.oldDeviceID = dev->id,
nkn.maxKeyCode = new->max_key_code; .minKeyCode = new->min_key_code,
nkn.oldMinKeyCode = xkb->min_key_code; .maxKeyCode = new->max_key_code,
nkn.oldMaxKeyCode = xkb->max_key_code; .oldMinKeyCode = xkb->min_key_code,
nkn.requestMajor = XkbReqCode; .oldMaxKeyCode = xkb->max_key_code,
nkn.requestMinor = X_kbGetKbdByName; .requestMajor = XkbReqCode,
nkn.changed = XkbNKN_KeycodesMask; .requestMinor = X_kbGetKbdByName,
.changed = XkbNKN_KeycodesMask,
};
if (geom_changed) if (geom_changed)
nkn.changed |= XkbNKN_GeometryMask; nkn.changed |= XkbNKN_GeometryMask;
XkbSendNewKeyboardNotify(dev, &nkn); XkbSendNewKeyboardNotify(dev, &nkn);
@ -6299,12 +6192,12 @@ static int
ComputeDeviceLedInfoSize(DeviceIntPtr dev, ComputeDeviceLedInfoSize(DeviceIntPtr dev,
unsigned int what, XkbSrvLedInfoPtr sli) unsigned int what, XkbSrvLedInfoPtr sli)
{ {
int nNames, nMaps; int nNames = 0, nMaps = 0;
register unsigned n, bit; register unsigned n, bit;
if (sli == NULL) if (sli == NULL)
return 0; return 0;
nNames = nMaps = 0;
if ((what & XkbXI_IndicatorNamesMask) == 0) if ((what & XkbXI_IndicatorNamesMask) == 0)
sli->namesPresent = 0; sli->namesPresent = 0;
if ((what & XkbXI_IndicatorMapsMask) == 0) if ((what & XkbXI_IndicatorMapsMask) == 0)
@ -6330,7 +6223,7 @@ CheckDeviceLedFBs(DeviceIntPtr dev,
{ {
int nFBs = 0; int nFBs = 0;
int length = 0; int length = 0;
Bool classOk; Bool classOk = FALSE;
if (class == XkbDfltXIClass) { if (class == XkbDfltXIClass) {
if (dev->kbdfeed) if (dev->kbdfeed)
@ -6342,7 +6235,7 @@ CheckDeviceLedFBs(DeviceIntPtr dev,
return XkbKeyboardErrorCode; return XkbKeyboardErrorCode;
} }
} }
classOk = FALSE;
if ((dev->kbdfeed) && if ((dev->kbdfeed) &&
((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) { ((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) {
KbdFeedbackPtr kf; KbdFeedbackPtr kf;
@ -6394,16 +6287,16 @@ CheckDeviceLedFBs(DeviceIntPtr dev,
static int static int
SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client) SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
{ {
xkbDeviceLedsWireDesc wire; int length = 0;
int length; xkbDeviceLedsWireDesc wire = {
.ledClass = sli->class,
.ledID = sli->id,
.namesPresent = sli->namesPresent,
.mapsPresent = sli->mapsPresent,
.physIndicators = sli->physIndicators,
.state = sli->effectiveState,
};
length = 0;
wire.ledClass = sli->class;
wire.ledID = sli->id;
wire.namesPresent = sli->namesPresent;
wire.mapsPresent = sli->mapsPresent;
wire.physIndicators = sli->physIndicators;
wire.state = sli->effectiveState;
if (client->swapped) { if (client->swapped) {
swaps(&wire.ledClass); swaps(&wire.ledClass);
swaps(&wire.ledID); swaps(&wire.ledID);
@ -6433,24 +6326,25 @@ SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
} }
if (sli->mapsPresent) { if (sli->mapsPresent) {
for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) { for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
xkbIndicatorMapWireDesc iwire;
if (sli->mapsPresent & bit) { if (sli->mapsPresent & bit) {
iwire.flags = sli->maps[i].flags; xkbIndicatorMapWireDesc iwire = {
iwire.whichGroups = sli->maps[i].which_groups; .flags = sli->maps[i].flags,
iwire.groups = sli->maps[i].groups; .whichGroups = sli->maps[i].which_groups,
iwire.whichMods = sli->maps[i].which_mods; .groups = sli->maps[i].groups,
iwire.mods = sli->maps[i].mods.mask; .whichMods = sli->maps[i].which_mods,
iwire.realMods = sli->maps[i].mods.real_mods; .mods = sli->maps[i].mods.mask,
iwire.virtualMods = sli->maps[i].mods.vmods; .realMods = sli->maps[i].mods.real_mods,
iwire.ctrls = sli->maps[i].ctrls; .virtualMods = sli->maps[i].mods.vmods,
.ctrls = sli->maps[i].ctrls,
};
if (client->swapped) { if (client->swapped) {
swaps(&iwire.virtualMods); swaps(&iwire.virtualMods);
swapl(&iwire.ctrls); swapl(&iwire.ctrls);
} }
WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc), WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc),
&iwire); &iwire);
length += SIZEOF(xkbIndicatorMapWireDesc); length += sizeof(xkbIndicatorMapWireDesc);
} }
} }
} }
@ -6506,7 +6400,6 @@ int
ProcXkbGetDeviceInfo(ClientPtr client) ProcXkbGetDeviceInfo(ClientPtr client)
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
xkbGetDeviceInfoReply rep;
int status, nDeviceLedFBs; int status, nDeviceLedFBs;
unsigned length, nameLen; unsigned length, nameLen;
CARD16 ledClass, ledID; CARD16 ledClass, ledID;
@ -6529,19 +6422,14 @@ ProcXkbGetDeviceInfo(ClientPtr client)
wanted &= ~XkbXI_IndicatorsMask; wanted &= ~XkbXI_IndicatorsMask;
nameLen = XkbSizeCountedString(dev->name); nameLen = XkbSizeCountedString(dev->name);
rep = (xkbGetDeviceInfoReply) {
xkbGetDeviceInfoReply rep = {
.type = X_Reply, .type = X_Reply,
.deviceID = dev->id, .deviceID = dev->id,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = nameLen / 4, .length = bytes_to_int32(nameLen),
.present = wanted, .present = wanted,
.supported = XkbXI_AllDeviceFeaturesMask, .supported = XkbXI_AllDeviceFeaturesMask,
.unsupported = 0,
.nDeviceLedFBs = 0,
.firstBtnWanted = 0,
.nBtnsWanted = 0,
.firstBtnRtrn = 0,
.nBtnsRtrn = 0,
.totalBtns = dev->button ? dev->button->numButtons : 0, .totalBtns = dev->button ? dev->button->numButtons : 0,
.hasOwnState = (dev->key && dev->key->xkbInfo), .hasOwnState = (dev->key && dev->key->xkbInfo),
.dfltKbdFB = dev->kbdfeed ? dev->kbdfeed->ctrl.id : XkbXINone, .dfltKbdFB = dev->kbdfeed ? dev->kbdfeed->ctrl.id : XkbXINone,
@ -6870,9 +6758,8 @@ _XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
xkbSetDeviceInfoReq * stuff) xkbSetDeviceInfoReq * stuff)
{ {
char *wire; char *wire;
xkbExtensionDeviceNotify ed; xkbExtensionDeviceNotify ed = { 0 };
memset((char *) &ed, 0, SIZEOF(xkbExtensionDeviceNotify));
ed.deviceID = dev->id; ed.deviceID = dev->id;
wire = (char *) &stuff[1]; wire = (char *) &stuff[1];
if (stuff->change & XkbXI_ButtonActionsMask) { if (stuff->change & XkbXI_ButtonActionsMask) {
@ -6993,7 +6880,6 @@ int
ProcXkbSetDebuggingFlags(ClientPtr client) ProcXkbSetDebuggingFlags(ClientPtr client)
{ {
CARD32 newFlags, newCtrls, extraLength; CARD32 newFlags, newCtrls, extraLength;
xkbSetDebuggingFlagsReply rep;
int rc; int rc;
REQUEST(xkbSetDebuggingFlagsReq); REQUEST(xkbSetDebuggingFlagsReq);
@ -7035,10 +6921,9 @@ ProcXkbSetDebuggingFlags(ClientPtr client)
xkbDebugFlags = newFlags; xkbDebugFlags = newFlags;
xkbDebugCtrls = newCtrls; xkbDebugCtrls = newCtrls;
rep = (xkbSetDebuggingFlagsReply) { xkbSetDebuggingFlagsReply rep = {
.type = X_Reply, .type = X_Reply,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0,
.currentFlags = newFlags, .currentFlags = newFlags,
.currentCtrls = newCtrls, .currentCtrls = newCtrls,
.supportedFlags = ~0, .supportedFlags = ~0,