Lines Matching defs:wire
1023 xkbKeyTypeWireDesc *wire;
1029 wire = (xkbKeyTypeWireDesc *) buf;
1030 wire->mask = type->mods.mask;
1031 wire->realMods = type->mods.real_mods;
1032 wire->virtualMods = type->mods.vmods;
1033 wire->numLevels = type->num_levels;
1034 wire->nMapEntries = type->map_count;
1035 wire->preserve = (type->preserve != NULL);
1037 swaps(&wire->virtualMods);
1040 buf = (char *) &wire[1];
1041 if (wire->nMapEntries > 0) {
1248 xkbBehaviorWireDesc *wire;
1251 wire = (xkbBehaviorWireDesc *) buf;
1255 wire->key = i + rep->firstKeyBehavior;
1256 wire->type = pBhvr->type;
1257 wire->data = pBhvr->data;
1258 wire++;
1261 buf = (char *) wire;
1374 xkbVModMapWireDesc *wire;
1377 wire = (xkbVModMapWireDesc *) buf;
1381 wire->key = i + rep->firstVModMapKey;
1382 wire->vmods = *pMap;
1383 wire++;
1386 return (char *) wire;
1608 register xkbKeyTypeWireDesc *wire = *wireRtrn;
1647 if (!_XkbCheckRequestBounds(client, req, wire, wire + 1)) {
1652 swaps(&wire->virtualMods);
1655 width = wire->numLevels;
1671 if (wire->nMapEntries > 0) {
1675 mapWire = (xkbKTSetMapEntryWireDesc *) &wire[1];
1677 &mapWire[wire->nMapEntries])) {
1678 *nMapsRtrn = _XkbErrCode3(0x0c, i, wire->nMapEntries);
1681 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
1682 if (wire->preserve &&
1684 &preWire[wire->nMapEntries])) {
1685 *nMapsRtrn = _XkbErrCode3(0x0d, i, wire->nMapEntries);
1688 for (n = 0; n < wire->nMapEntries; n++) {
1692 if (mapWire[n].realMods & (~wire->realMods)) {
1694 wire->realMods);
1697 if (mapWire[n].virtualMods & (~wire->virtualMods)) {
1701 if (mapWire[n].level >= wire->numLevels) {
1702 *nMapsRtrn = _XkbErrCode4(0x08, n, wire->numLevels,
1706 if (wire->preserve) {
1722 if (wire->preserve)
1723 map = (CARD8 *) &preWire[wire->nMapEntries];
1725 map = (CARD8 *) &mapWire[wire->nMapEntries];
1728 map = (CARD8 *) &wire[1];
1729 mapWidthRtrn[i + req->firstType] = wire->numLevels;
1730 wire = (xkbKeyTypeWireDesc *) map;
1736 *wireRtrn = wire;
1750 xkbSymMapWireDesc *wire = *wireRtrn;
1761 if (!_XkbCheckRequestBounds(client, req, wire, wire + 1)) {
1766 swaps(&wire->nSyms);
1768 nG = XkbNumGroups(wire->groupInfo);
1777 if (wire->ktIndex[g] >= (unsigned) nTypes) {
1779 wire->ktIndex[g]);
1782 if (mapWidths[wire->ktIndex[g]] > w)
1783 w = mapWidths[wire->ktIndex[g]];
1785 if (wire->width != w) {
1787 _XkbErrCode3(0x16, i + req->firstKeySym, wire->width);
1792 if (w != wire->nSyms) {
1794 _XkbErrCode4(0x16, i + req->firstKeySym, wire->nSyms, w);
1798 else if (wire->nSyms != 0) {
1799 *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms);
1802 pSyms = (KeySym *) &wire[1];
1803 if (wire->nSyms != 0) {
1804 if (!_XkbCheckRequestBounds(client, req, pSyms, &pSyms[wire->nSyms])) {
1805 *errorRtrn = _XkbErrCode3(0x19, i + req->firstKeySym, wire->nSyms);
1809 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
1827 *wireRtrn = wire;
1840 CARD8 *wire = *wireRtrn;
1848 /* Check we received enough data to read the next byte on the wire */
1849 if (!_XkbCheckRequestBounds(client, req, wire, wire + 1)) {
1853 if (wire[0] != 0) {
1854 if (wire[0] == symsPerKey[i + req->firstKeyAct])
1855 nActs += wire[0];
1857 *nActsRtrn = _XkbErrCode3(0x23, i + req->firstKeyAct, wire[0]);
1861 wire++;
1864 wire += 4 - (req->nKeyActs % 4);
1865 *wireRtrn = (CARD8 *) (((XkbAnyAction *) wire) + nActs);
1867 !_XkbCheckRequestBounds(client, req, wire, *wireRtrn)) {
1881 register xkbBehaviorWireDesc *wire = *wireRtrn;
1902 for (i = 0; i < req->totalKeyBehaviors; i++, wire++) {
1904 if (!_XkbCheckRequestBounds(client, req, wire, wire + 1)) {
1908 if ((wire->key < first) || (wire->key > last)) {
1909 *errorRtrn = _XkbErrCode4(0x33, first, last, wire->key);
1912 if ((wire->type & XkbKB_Permanent) &&
1913 ((server->behaviors[wire->key].type != wire->type) ||
1914 (server->behaviors[wire->key].data != wire->data))) {
1915 *errorRtrn = _XkbErrCode3(0x33, wire->key, wire->type);
1918 if ((wire->type == XkbKB_RadioGroup) &&
1919 ((wire->data & (~XkbKB_RGAllowNone)) > XkbMaxRadioGroups)) {
1920 *errorRtrn = _XkbErrCode4(0x34, wire->key, wire->data,
1924 if ((wire->type == XkbKB_Overlay1) || (wire->type == XkbKB_Overlay2)) {
1925 CHK_KEY_RANGE2(0x35, wire->key, 1, xkb, *errorRtrn, 0);
1928 *wireRtrn = wire;
1937 register CARD8 *wire = *wireRtrn;
1947 if (!_XkbCheckRequestBounds(client, req, wire, wire + XkbPaddedSize(nMods))) {
1951 *wireRtrn = (wire + XkbPaddedSize(nMods));
1960 register CARD8 *wire = *wireRtrn;
1981 start = wire;
1982 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
1984 if (!_XkbCheckRequestBounds(client, req, wire, wire + 2)) {
1988 if ((wire[0] < first) || (wire[0] > last)) {
1989 *errorRtrn = _XkbErrCode4(0x53, first, last, wire[0]);
1992 if (wire[1] & (~XkbAllExplicitMask)) {
1993 *errorRtrn = _XkbErrCode3(0x52, ~XkbAllExplicitMask, wire[1]);
1997 wire += XkbPaddedSize(wire - start) - (wire - start);
1998 *wireRtrn = wire;
2006 register CARD8 *wire = *wireRtrn;
2026 start = wire;
2027 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
2028 if (!_XkbCheckRequestBounds(client, req, wire, wire + 2)) {
2032 if ((wire[0] < first) || (wire[0] > last)) {
2033 *errRtrn = _XkbErrCode4(0x63, first, last, wire[0]);
2037 wire += XkbPaddedSize(wire - start) - (wire - start);
2038 *wireRtrn = wire;
2048 register xkbVModMapWireDesc *wire = *wireRtrn;
2067 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
2069 if (!_XkbCheckRequestBounds(client, req, wire, wire + 1)) {
2073 if ((wire->key < first) || (wire->key > last)) {
2074 *errRtrn = _XkbErrCode4(0x73, first, last, wire->key);
2078 *wireRtrn = wire;
2085 xkbKeyTypeWireDesc * wire, XkbChangesPtr changes)
2104 if (XkbResizeKeyType(xkb, i + req->firstType, wire->nMapEntries,
2105 wire->preserve, wire->numLevels) != Success) {
2109 map = (CARD8 *) &wire[1];
2111 pOld->mods.real_mods = wire->realMods;
2112 pOld->mods.vmods = wire->virtualMods;
2113 pOld->num_levels = wire->numLevels;
2114 pOld->map_count = wire->nMapEntries;
2119 if (wire->nMapEntries) {
2125 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
2126 for (n = 0; n < wire->nMapEntries; n++) {
2137 if (wire->preserve) {
2144 if (wire->preserve)
2145 map = (CARD8 *) &preWire[wire->nMapEntries];
2147 map = (CARD8 *) &mapWire[wire->nMapEntries];
2150 map = (CARD8 *) &wire[1];
2151 wire = (xkbKeyTypeWireDesc *) map;
2167 return (char *) wire;
2174 xkbSymMapWireDesc * wire, XkbChangesPtr changes, DeviceIntPtr dev)
2184 pSyms = (KeySym *) &wire[1];
2185 if (wire->nSyms > 0) {
2186 newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
2187 for (s = 0; s < wire->nSyms; s++) {
2191 for (s = 0; s < wire->nSyms; s++) {
2198 XkbNumGroups(wire->groupInfo) * wire->width);
2199 oldMap->kt_index[0] = wire->ktIndex[0];
2200 oldMap->kt_index[1] = wire->ktIndex[1];
2201 oldMap->kt_index[2] = wire->ktIndex[2];
2202 oldMap->kt_index[3] = wire->ktIndex[3];
2203 oldMap->group_info = wire->groupInfo;
2204 oldMap->width = wire->width;
2205 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
2239 return (char *) wire;
2244 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2247 CARD8 *nActs = wire;
2250 wire += XkbPaddedSize(req->nKeyActs);
2256 memcpy((char *) newActs, (char *) wire,
2258 wire += nActs[i] * SIZEOF(xkbActionWireDesc);
2275 return (char *) wire;
2281 xkbBehaviorWireDesc * wire, XkbChangesPtr changes)
2294 if ((server->behaviors[wire->key].type & XkbKB_Permanent) == 0) {
2295 server->behaviors[wire->key].type = wire->type;
2296 server->behaviors[wire->key].data = wire->data;
2297 if ((wire->type == XkbKB_RadioGroup) &&
2298 (((int) wire->data) > maxRG))
2299 maxRG = wire->data + 1;
2301 wire++;
2333 return (char *) wire;
2337 SetVirtualMods(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2344 return (char *) wire;
2347 if (srv->vmods[i] != wire[nMods]) {
2350 srv->vmods[i] = wire[nMods];
2355 return (char *) (wire + XkbPaddedSize(nMods));
2359 SetKeyExplicit(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2366 start = wire;
2370 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
2371 xkb->explicit[wire[0]] = wire[1];
2387 wire += XkbPaddedSize(wire - start) - (wire - start);
2388 return (char *) wire;
2393 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2399 start = wire;
2403 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
2404 xkb->modmap[wire[0]] = wire[1];
2420 wire += XkbPaddedSize(wire - start) - (wire
2421 return (char *) wire;
2427 xkbVModMapWireDesc * wire, XkbChangesPtr changes)
2435 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
2436 srv->vmodmap[wire->key] = wire->vmods;
2452 return (char *) wire;
2916 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
2920 wire++) {
2921 wire->sym = sym->sym;
2922 wire->mods = sym->mods;
2923 wire->match = sym->match;
2924 wire->virtualMod = sym->virtual_mod;
2925 wire->flags = sym->flags;
2926 memcpy((char *) &wire->act, (char *) &sym->act,
2929 swapl(&wire->sym);
2933 grp = (xkbModsWireDesc *) wire;
2945 wire = (xkbSymInterpretWireDesc *) grp;
3032 xkbSymInterpretWireDesc *wire;
3038 wire = (xkbSymInterpretWireDesc *) data;
3039 wire += req->nSI;
3040 data = (char *) wire;
3061 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
3081 for (i = 0; i < req->nSI; i++, wire++) {
3083 swapl(&wire->sym);
3085 if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
3086 (wire->mods & 0xff) == 0xff &&
3087 wire->act.type == XkbSA_XFree86Private) {
3093 sym->sym = wire->sym;
3094 sym->mods = wire->mods;
3095 sym->match = wire->match;
3096 sym->flags = wire->flags;
3097 sym->virtual_mod = wire->virtualMod;
3098 memcpy((char *) &sym->act, (char *) &wire->act,
3109 data = (char *) wire;
3116 xkbModsWireDesc *wire = (xkbModsWireDesc *) data;
3121 swaps(&wire->virtualMods);
3123 compat->groups[i].mask = wire->realMods;
3124 compat->groups[i].real_mods = wire->realMods;
3125 compat->groups[i].vmods = wire->virtualMods;
3126 if (wire->virtualMods != 0) {
3129 tmp = XkbMaskForVMask(xkb, wire->virtualMods);
3133 wire = (xkbModsWireDesc *) data;
3304 xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *) to;
3310 wire->flags = indicators->maps[i].flags;
3311 wire->whichGroups = indicators->maps[i].which_groups;
3312 wire->groups = indicators->maps[i].groups;
3313 wire->whichMods = indicators->maps[i].which_mods;
3314 wire->mods = indicators->maps[i].mods.mask;
3315 wire->realMods = indicators->maps[i].mods.real_mods;
3316 wire->virtualMods = indicators->maps[i].mods.vmods;
3317 wire->ctrls = indicators->maps[i].ctrls;
3319 swaps(&wire->virtualMods);
3320 swapl(&wire->ctrls);
3322 wire++;
3325 to = (CARD8 *) wire;
3804 _XkbWriteAtoms(char *wire, Atom *atoms, int maxAtoms, int swap)
3809 atm = (Atom *) wire;
4129 _XkbCheckAtoms(CARD32 *wire, int nAtoms, int swapped, Atom *pError)
4133 for (i = 0; i < nAtoms; i++, wire++) {
4135 swapl(wire);
4137 if ((((Atom) *wire) != None) && (!ValidAtom((Atom) *wire))) {
4138 *pError = ((Atom) *wire);
4142 return wire;
4146 _XkbCheckMaskedAtoms(CARD32 *wire, int nAtoms, CARD32 present, int swapped,
4155 swapl(wire);
4157 if ((((Atom) *wire) != None) && (!ValidAtom(((Atom) *wire)))) {
4158 *pError = (Atom) *wire;
4161 wire++;
4163 return wire;
4167 _XkbCopyMaskedAtoms(Atom *wire, Atom *dest, int nAtoms, CARD32 present)
4174 dest[i] = *wire++;
4176 return wire;
4658 * Write the zero-terminated string str into wire as a pascal string with a
4661 * @param wire The destination array, usually the wire struct
4669 XkbWriteCountedString(char *wire, const char *str, Bool swap)
4674 return wire;
4677 pLen = (CARD16 *) wire;
4683 strncpy(&wire[sizeof(len)], str, paddedLen);
4684 wire += sizeof(len) + paddedLen;
4685 return wire;
4703 XkbWriteGeomProperties(char *wire, XkbGeometryPtr geom, Bool swap)
4709 wire = XkbWriteCountedString(wire, prop->name, swap);
4710 wire = XkbWriteCountedString(wire, prop->value, swap);
4712 return wire;
4722 XkbWriteGeomKeyAliases(char *wire, XkbGeometryPtr geom, Bool swap)
4728 memcpy(wire, (char *) geom->key_aliases, sz);
4729 wire += sz;
4731 return wire;
4747 XkbWriteGeomColors(char *wire, XkbGeometryPtr geom, Bool swap)
4753 wire = XkbWriteCountedString(wire, color->spec, swap);
4755 return wire;
4778 XkbWriteGeomShapes(char *wire, XkbGeometryPtr geom, Bool swap)
4789 shapeWire = (xkbShapeWireDesc *) wire;
4804 wire = (char *) &shapeWire[1];
4810 olWire = (xkbOutlineWireDesc *) wire;
4814 wire = (char *) &olWire[1];
4815 ptWire = (xkbPointWireDesc *) wire;
4824 wire = (char *) &ptWire[ol->num_points];
4827 return wire;
4849 XkbWriteGeomDoodads(char *wire, int num_doodads, XkbDoodadPtr doodad, Bool swap)
4855 doodadWire = (xkbDoodadWireDesc *) wire;
4856 wire = (char *) &doodadWire[1];
4888 wire = XkbWriteCountedString(wire, doodad->text.text, swap);
4889 wire = XkbWriteCountedString(wire, doodad->text.font, swap);
4900 wire = XkbWriteCountedString(wire, doodad->logo.logo_name, swap);
4909 return wire;
4913 XkbWriteGeomOverlay(char *wire, XkbOverlayPtr ol, Bool swap)
4919 olWire = (xkbOverlayWireDesc *) wire;
4927 wire = (char *) &olWire[1];
4933 rowWire = (xkbOverlayRowWireDesc *) wire;
4937 wire = (char *) &rowWire[1];
4941 keyWire = (xkbOverlayKeyWireDesc *) wire;
4944 wire = (char *) &keyWire[1];
4947 return wire;
4991 XkbWriteGeomSections(char *wire, XkbGeometryPtr geom, Bool swap)
4999 sectionWire = (xkbSectionWireDesc *) wire;
5019 wire = (char *) §ionWire[1];
5026 rowWire = (xkbRowWireDesc *) wire;
5036 wire = (char *) &rowWire[1];
5042 keyWire = (xkbKeyWireDesc *) wire;
5053 wire = (char *) &keyWire[row->num_keys];
5058 wire = XkbWriteGeomDoodads(wire,
5066 wire = XkbWriteGeomOverlay(wire, §ion->overlays[o], swap);
5070 return wire;
5209 char *wire, *next;
5212 wire = *wire_inout;
5215 bytes_to_int32(wire + 2 - (char *) client->requestBuffer))
5218 len = *(CARD16 *) wire;
5222 next = wire + XkbPaddedSize(len + 2);
5230 memcpy(*str, &wire[2], len);
5240 char *wire;
5252 wire = (char *) &dWire[1];
5298 status = _GetCountedString(&wire, client, &doodad->text.text);
5301 status = _GetCountedString(&wire, client, &doodad->text.font);
5340 status = _GetCountedString(&wire, client, &doodad->logo.logo_name);
5348 *wire_inout = wire;
5357 char *wire;
5362 wire = *wire_inout;
5363 olWire = (xkbOverlayWireDesc *) wire;
5406 wire = (char *) olWire;
5407 *wire_inout = wire;
5417 char *wire;
5421 wire = *wire_inout;
5424 sWire = (xkbSectionWireDesc *) wire;
5497 wire = (char *) rWire;
5502 status = _CheckSetDoodad(&wire, req, geom, section, client);
5511 status = _CheckSetOverlay(&wire, req, geom, section, client);
5516 sWire = (xkbSectionWireDesc *) wire;
5518 wire = (char *) sWire;
5519 *wire_inout = wire;
5528 char *wire;
5530 wire = *wire_inout;
5540 shapeWire = (xkbShapeWireDesc *) wire;
5598 wire = (char *) shapeWire;
5605 *wire_inout = wire;
5614 char *wire;
5616 wire = (char *) &req[1];
5617 status = _GetCountedString(&wire, client, &geom->label_font);
5624 status = _GetCountedString(&wire, client, &name);
5627 status = _GetCountedString(&wire, client, &val);
5664 status = _GetCountedString(&wire, client, &name);
5680 if ((status = _CheckSetShapes(geom, req, &wire, client)) != Success)
5683 if ((status = _CheckSetSections(geom, req, &wire, client)) != Success)
5687 status = _CheckSetDoodad(&wire, req, geom, NULL, client);
5693 if (!_XkbCheckRequestBounds(client, req, wire, wire + 2 * XkbKeyNameLength))
5696 if (XkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
5698 wire += 2 * XkbKeyNameLength;
5895 unsigned char *wire, *str, *tmp, *legal;
5902 wire = *pWire;
5903 len = (*(unsigned char *) wire++);
5909 if (legal[(*wire) / 8] & (1 << ((*wire) % 8)))
5910 *tmp++ = *wire++;
5912 wire++;
5928 *pWire = wire;
6441 xkbDeviceLedsWireDesc wire;
6445 wire.ledClass = sli->class;
6446 wire.ledID = sli->id;
6447 wire.namesPresent = sli->namesPresent;
6448 wire.mapsPresent = sli->mapsPresent;
6449 wire.physIndicators = sli->physIndicators;
6450 wire.state = sli->effectiveState;
6452 swaps(&wire.ledClass);
6453 swaps(&wire.ledID);
6454 swapl(&wire.namesPresent);
6455 swapl(&wire.mapsPresent);
6456 swapl(&wire.physIndicators);
6457 wire.state);
6459 WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), &wire);
6692 CheckSetDeviceIndicators(char *wire,
6701 ledWire = (xkbDeviceLedsWireDesc *) wire;
6778 SetDeviceIndicators(char *wire,
6798 ledWire = (xkbDeviceLedsWireDesc *) wire;
6879 char *wire;
6881 wire = (char *) &stuff[1];
6884 if (!_XkbCheckRequestBounds(client, stuff, wire, (char *) wire + sz))
6897 wire += sz;
6902 wire = CheckSetDeviceIndicators(wire, dev, stuff->nDeviceLedFBs,
6907 if (((wire - ((char *) stuff)) / 4) != stuff->length)
6917 char *wire;
6922 wire = (char *) &stuff[1];
6939 memcpy((char *) &acts[stuff->firstBtn], (char *) wire, sz);
6940 wire += sz;
6958 wire = SetDeviceIndicators(wire, dev, stuff->change,
Indexes created Fri Jul 03 00:25:33 UTC 2026