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

Use C99 designated initializers in xkb Replies 

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-07-09 19:12:43 -07:00
parent 26efa09d0c
commit a406bd0759
1 changed files with 164 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
xkb/xkb.c
View File

@ -181,13 +181,14 @@ ProcXkbUseExtension(ClientPtr client)
stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION, stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION,
SERVER_XKB_MINOR_VERSION); SERVER_XKB_MINOR_VERSION);
} }
memset(&rep, 0, sizeof(xkbUseExtensionReply)); rep = (xkbUseExtensionReply) {
rep.type = X_Reply; .type = X_Reply,
rep.supported = supported; .supported = supported,
rep.length = 0; .sequenceNumber = client->sequence,
rep.sequenceNumber = client->sequence; .length = 0,
rep.serverMajor = SERVER_XKB_MAJOR_VERSION; .serverMajor = SERVER_XKB_MAJOR_VERSION,
rep.serverMinor = SERVER_XKB_MINOR_VERSION; .serverMinor = SERVER_XKB_MINOR_VERSION
};
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.serverMajor); swaps(&rep.serverMajor);
@ -577,21 +578,22 @@ 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;
memset(&rep, 0, sizeof(xkbGetStateReply)); rep = (xkbGetStateReply) {
rep.type = X_Reply; .type = X_Reply,
rep.sequenceNumber = client->sequence; .deviceID = dev->id,
rep.length = 0; .sequenceNumber = client->sequence,
rep.deviceID = dev->id; .length = 0,
rep.mods = XkbStateFieldFromRec(xkb) & 0xff; .mods = XkbStateFieldFromRec(xkb) & 0xff,
rep.baseMods = xkb->base_mods; .baseMods = xkb->base_mods,
rep.lockedMods = xkb->locked_mods; .latchedMods = xkb->latched_mods,
rep.latchedMods = xkb->latched_mods; .lockedMods = xkb->locked_mods,
rep.group = xkb->group; .group = xkb->group,
rep.baseGroup = xkb->base_group; .lockedGroup = xkb->locked_group,
rep.latchedGroup = xkb->latched_group; .baseGroup = xkb->base_group,
rep.lockedGroup = xkb->locked_group; .latchedGroup = xkb->latched_group,
rep.compatState = xkb->compat_state; .compatState = xkb->compat_state,
rep.ptrBtnState = xkb->ptr_buttons; .ptrBtnState = xkb->ptr_buttons
};
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.ptrBtnState); swaps(&rep.ptrBtnState);
@ -688,36 +690,38 @@ 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.type = X_Reply; rep = (xkbGetControlsReply) {
rep.length = bytes_to_int32(SIZEOF(xkbGetControlsReply) - .type = X_Reply,
SIZEOF(xGenericReply)); .deviceID = ((DeviceIntPtr) dev)->id,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.deviceID = ((DeviceIntPtr) dev)->id; .length = bytes_to_int32(SIZEOF(xkbGetControlsReply) -
rep.numGroups = xkb->num_groups; SIZEOF(xGenericReply)),
rep.groupsWrap = xkb->groups_wrap; .mkDfltBtn = xkb->mk_dflt_btn,
rep.internalMods = xkb->internal.mask; .numGroups = xkb->num_groups,
rep.ignoreLockMods = xkb->ignore_lock.mask; .groupsWrap = xkb->groups_wrap,
rep.internalRealMods = xkb->internal.real_mods; .internalMods = xkb->internal.mask,
rep.ignoreLockRealMods = xkb->ignore_lock.real_mods; .ignoreLockMods = xkb->ignore_lock.mask,
rep.internalVMods = xkb->internal.vmods; .internalRealMods = xkb->internal.real_mods,
rep.ignoreLockVMods = xkb->ignore_lock.vmods; .ignoreLockRealMods = xkb->ignore_lock.real_mods,
rep.enabledCtrls = xkb->enabled_ctrls; .internalVMods = xkb->internal.vmods,
rep.repeatDelay = xkb->repeat_delay; .ignoreLockVMods = xkb->ignore_lock.vmods,
rep.repeatInterval = xkb->repeat_interval; .repeatDelay = xkb->repeat_delay,
rep.slowKeysDelay = xkb->slow_keys_delay; .repeatInterval = xkb->repeat_interval,
rep.debounceDelay = xkb->debounce_delay; .slowKeysDelay = xkb->slow_keys_delay,
rep.mkDelay = xkb->mk_delay; .debounceDelay = xkb->debounce_delay,
rep.mkInterval = xkb->mk_interval; .mkDelay = xkb->mk_delay,
rep.mkTimeToMax = xkb->mk_time_to_max; .mkInterval = xkb->mk_interval,
rep.mkMaxSpeed = xkb->mk_max_speed; .mkTimeToMax = xkb->mk_time_to_max,
rep.mkCurve = xkb->mk_curve; .mkMaxSpeed = xkb->mk_max_speed,
rep.mkDfltBtn = xkb->mk_dflt_btn; .mkCurve = xkb->mk_curve,
rep.axTimeout = xkb->ax_timeout; .axOptions = xkb->ax_options,
rep.axtCtrlsMask = xkb->axt_ctrls_mask; .axTimeout = xkb->ax_timeout,
rep.axtCtrlsValues = xkb->axt_ctrls_values; .axtOptsMask = xkb->axt_opts_mask,
rep.axtOptsMask = xkb->axt_opts_mask; .axtOptsValues = xkb->axt_opts_values,
rep.axtOptsValues = xkb->axt_opts_values; .axtCtrlsMask = xkb->axt_ctrls_mask,
rep.axOptions = xkb->ax_options; .axtCtrlsValues = xkb->axt_ctrls_values,
.enabledCtrls = xkb->enabled_ctrls,
};
memcpy(rep.perKeyRepeat, xkb->per_key_repeat, XkbPerKeyBitArraySize); memcpy(rep.perKeyRepeat, xkb->per_key_repeat, XkbPerKeyBitArraySize);
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
@ -1459,14 +1463,16 @@ 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;
memset(&rep, 0, sizeof(xkbGetMapReply)); rep = (xkbGetMapReply) {
rep.type = X_Reply; .type = X_Reply,
rep.sequenceNumber = client->sequence; .deviceID = dev->id,
rep.length = (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2; .sequenceNumber = client->sequence,
rep.deviceID = dev->id; .length = (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2,
rep.present = stuff->partial | stuff->full; .present = stuff->partial | stuff->full,
rep.minKeyCode = xkb->min_key_code; .minKeyCode = xkb->min_key_code,
rep.maxKeyCode = xkb->max_key_code; .maxKeyCode = xkb->max_key_code
};
if (stuff->full & XkbKeyTypesMask) { if (stuff->full & XkbKeyTypesMask) {
rep.firstType = 0; rep.firstType = 0;
rep.nTypes = xkb->map->num_types; rep.nTypes = xkb->map->num_types;
@ -2771,12 +2777,14 @@ ProcXkbGetCompatMap(ClientPtr client)
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
compat = xkb->compat; compat = xkb->compat;
rep.type = X_Reply; rep = (xkbGetCompatMapReply) {
rep.deviceID = dev->id; .type = X_Reply,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.length = 0; .length = 0,
rep.firstSI = stuff->firstSI; .deviceID = dev->id,
rep.nSI = stuff->nSI; .firstSI = stuff->firstSI,
.nSI = stuff->nSI
};
if (stuff->getAllSI) { if (stuff->getAllSI) {
rep.firstSI = 0; rep.firstSI = 0;
rep.nSI = compat->num_si; rep.nSI = compat->num_si;
@ -3034,11 +3042,13 @@ ProcXkbGetIndicatorState(ClientPtr client)
if (!sli) if (!sli)
return BadAlloc; return BadAlloc;
rep.type = X_Reply; rep = (xkbGetIndicatorStateReply) {
rep.sequenceNumber = client->sequence; .type = X_Reply,
rep.length = 0; .deviceID = dev->id,
rep.deviceID = dev->id; .sequenceNumber = client->sequence,
rep.state = sli->effectiveState; .length = 0,
.state = sli->effectiveState
};
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
@ -3145,11 +3155,13 @@ ProcXkbGetIndicatorMap(ClientPtr client)
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
leds = xkb->indicators; leds = xkb->indicators;
rep.type = X_Reply; rep = (xkbGetIndicatorMapReply) {
rep.sequenceNumber = client->sequence; .type = X_Reply,
rep.length = 0; .deviceID = dev->id,
rep.deviceID = dev->id; .sequenceNumber = client->sequence,
rep.which = stuff->which; .length = 0,
.which = stuff->which
};
XkbComputeGetIndicatorMapReplySize(leds, &rep); XkbComputeGetIndicatorMapReplySize(leds, &rep);
return XkbSendIndicatorMap(client, leds, &rep); return XkbSendIndicatorMap(client, leds, &rep);
} }
@ -3300,11 +3312,13 @@ ProcXkbGetNamedIndicator(ClientPtr client)
} }
} }
rep.type = X_Reply; rep = (xkbGetNamedIndicatorReply) {
rep.length = 0; .type = X_Reply,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.deviceID = dev->id; .length = 0,
rep.indicator = stuff->indicator; .deviceID = dev->id,
.indicator = stuff->indicator
};
if (map != NULL) { if (map != NULL) {
rep.found = TRUE; rep.found = TRUE;
rep.on = ((sli->effectiveState & (1 << i)) != 0); rep.on = ((sli->effectiveState & (1 << i)) != 0);
@ -3880,22 +3894,18 @@ 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;
memset(&rep, 0, sizeof(xkbGetNamesReply)); rep = (xkbGetNamesReply) {
rep.type = X_Reply; .type = X_Reply,
rep.sequenceNumber = client->sequence; .deviceID = dev->id,
rep.length = 0; .sequenceNumber = client->sequence,
rep.deviceID = dev->id; .length = 0,
rep.which = stuff->which; .which = stuff->which,
rep.nTypes = xkb->map->num_types; .nTypes = xkb->map->num_types,
rep.firstKey = xkb->min_key_code; .firstKey = xkb->min_key_code,
rep.nKeys = XkbNumKeys(xkb); .nKeys = XkbNumKeys(xkb),
if (xkb->names != NULL) { .nKeyAliases = xkb->names ? xkb->names->num_key_aliases : 0,
rep.nKeyAliases = xkb->names->num_key_aliases; .nRadioGroups = xkb->names ? xkb->names->num_rg : 0
rep.nRadioGroups = xkb->names->num_rg; };
}
else {
rep.nKeyAliases = rep.nRadioGroups = 0;
}
XkbComputeGetNamesReplySize(xkb, &rep); XkbComputeGetNamesReplySize(xkb, &rep);
return XkbSendNames(client, xkb, &rep); return XkbSendNames(client, xkb, &rep);
} }
@ -4933,10 +4943,12 @@ 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.type = X_Reply; rep = (xkbGetGeometryReply) {
rep.deviceID = dev->id; .type = X_Reply,
rep.sequenceNumber = client->sequence; .deviceID = dev->id,
rep.length = 0; .sequenceNumber = client->sequence,
.length = 0
};
status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name); status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name);
if (status != Success) if (status != Success)
return status; return status;
@ -5483,10 +5495,6 @@ ProcXkbPerClientFlags(ClientPtr client)
CHK_MASK_MATCH(0x02, stuff->change, stuff->value); CHK_MASK_MATCH(0x02, stuff->change, stuff->value);
interest = XkbFindClientResource((DevicePtr) dev, client); interest = XkbFindClientResource((DevicePtr) dev, client);
memset(&rep, 0, sizeof(xkbPerClientFlagsReply));
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
if (stuff->change) { if (stuff->change) {
client->xkbClientFlags &= ~stuff->change; client->xkbClientFlags &= ~stuff->change;
client->xkbClientFlags |= stuff->value; client->xkbClientFlags |= stuff->value;
@ -5522,15 +5530,16 @@ ProcXkbPerClientFlags(ClientPtr client)
interest->autoCtrlValues |= stuff->autoCtrlValues & affect; interest->autoCtrlValues |= stuff->autoCtrlValues & affect;
} }
} }
rep.supported = XkbPCF_AllFlagsMask;
rep.value = client->xkbClientFlags & XkbPCF_AllFlagsMask; rep = (xkbPerClientFlagsReply) {
if (interest) { .type = X_Reply,
rep.autoCtrls = interest->autoCtrls; .sequenceNumber = client->sequence,
rep.autoCtrlValues = interest->autoCtrlValues; .length = 0,
} .supported = XkbPCF_AllFlagsMask,
else { .value = client->xkbClientFlags & XkbPCF_AllFlagsMask,
rep.autoCtrls = rep.autoCtrlValues = 0; .autoCtrls = interest ? interest->autoCtrls : 0,
} .autoCtrlValues = interest ? interest->autoCtrlValues : 0,
};
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.supported); swapl(&rep.supported);
@ -5642,18 +5651,19 @@ ProcXkbListComponents(ClientPtr client)
list.pool = NULL; list.pool = NULL;
return status; return status;
} }
memset(&rep, 0, sizeof(xkbListComponentsReply)); rep = (xkbListComponentsReply) {
rep.type = X_Reply; .type = X_Reply,
rep.deviceID = dev->id; .deviceID = dev->id,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.length = XkbPaddedSize(list.nPool) / 4; .length = XkbPaddedSize(list.nPool) / 4,
rep.nKeymaps = 0; .nKeymaps = 0,
rep.nKeycodes = list.nFound[_XkbListKeycodes]; .nKeycodes = list.nFound[_XkbListKeycodes],
rep.nTypes = list.nFound[_XkbListTypes]; .nTypes = list.nFound[_XkbListTypes],
rep.nCompatMaps = list.nFound[_XkbListCompat]; .nCompatMaps = list.nFound[_XkbListCompat],
rep.nSymbols = list.nFound[_XkbListSymbols]; .nSymbols = list.nFound[_XkbListSymbols],
rep.nGeometries = list.nFound[_XkbListGeometry]; .nGeometries = list.nFound[_XkbListGeometry],
rep.extra = 0; .extra = 0
};
if (list.nTotal > list.maxRtrn) if (list.nTotal > list.maxRtrn)
rep.extra = (list.nTotal - list.maxRtrn); rep.extra = (list.nTotal - list.maxRtrn);
if (client->swapped) { if (client->swapped) {
@ -6254,37 +6264,29 @@ ProcXkbGetDeviceInfo(ClientPtr client)
wanted &= ~XkbXI_IndicatorsMask; wanted &= ~XkbXI_IndicatorsMask;
nameLen = XkbSizeCountedString(dev->name); nameLen = XkbSizeCountedString(dev->name);
memset((char *) &rep, 0, SIZEOF(xkbGetDeviceInfoReply)); rep = (xkbGetDeviceInfoReply) {
rep.type = X_Reply; .type = X_Reply,
rep.deviceID = dev->id; .deviceID = dev->id,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.length = nameLen / 4; .length = nameLen / 4,
rep.present = wanted; .present = wanted,
rep.supported = XkbXI_AllDeviceFeaturesMask; .supported = XkbXI_AllDeviceFeaturesMask,
rep.unsupported = 0; .unsupported = 0,
rep.firstBtnWanted = rep.nBtnsWanted = 0; .nDeviceLedFBs = 0,
rep.firstBtnRtrn = rep.nBtnsRtrn = 0; .firstBtnWanted = 0,
if (dev->button) .nBtnsWanted = 0,
rep.totalBtns = dev->button->numButtons; .firstBtnRtrn = 0,
else .nBtnsRtrn = 0,
rep.totalBtns = 0; .totalBtns = dev->button ? dev->button->numButtons : 0,
rep.devType = dev->xinput_type; .hasOwnState = (dev->key && dev->key->xkbInfo),
rep.hasOwnState = (dev->key && dev->key->xkbInfo); .dfltKbdFB = dev->kbdfeed ? dev->kbdfeed->ctrl.id : XkbXINone,
rep.nDeviceLedFBs = 0; .dfltLedFB = dev->leds ? dev->leds->ctrl.id : XkbXINone,
if (dev->kbdfeed) .devType = dev->xinput_type
rep.dfltKbdFB = dev->kbdfeed->ctrl.id; };
else
rep.dfltKbdFB = XkbXINone;
if (dev->leds)
rep.dfltLedFB = dev->leds->ctrl.id;
else
rep.dfltLedFB = XkbXINone;
ledClass = stuff->ledClass; ledClass = stuff->ledClass;
ledID = stuff->ledID; ledID = stuff->ledID;
rep.firstBtnWanted = rep.nBtnsWanted = 0;
rep.firstBtnRtrn = rep.nBtnsRtrn = 0;
if (wanted & XkbXI_ButtonActionsMask) { if (wanted & XkbXI_ButtonActionsMask) {
if (stuff->allBtns) { if (stuff->allBtns) {
stuff->firstBtn = 0; stuff->firstBtn = 0;
@ -6746,13 +6748,15 @@ ProcXkbSetDebuggingFlags(ClientPtr client)
xkbDebugFlags = newFlags; xkbDebugFlags = newFlags;
xkbDebugCtrls = newCtrls; xkbDebugCtrls = newCtrls;
rep.type = X_Reply; rep = (xkbSetDebuggingFlagsReply) {
rep.length = 0; .type = X_Reply,
rep.sequenceNumber = client->sequence; .sequenceNumber = client->sequence,
rep.currentFlags = newFlags; .length = 0,
rep.currentCtrls = newCtrls; .currentFlags = newFlags,
rep.supportedFlags = ~0; .currentCtrls = newCtrls,
rep.supportedCtrls = ~0; .supportedFlags = ~0,
.supportedCtrls = ~0
};
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.currentFlags); swapl(&rep.currentFlags);