Status
XkbResizeDeviceButtonActions(XkbDeviceInfoPtr devi, unsigned newTotal)
{
XkbAction *prev_btn_acts;
if ((!devi) || (newTotal > 255))
return BadValue;
if ((devi->btn_acts != NULL) && (newTotal == devi->num_btns))
return Success;
if (newTotal == 0) {
if (devi->btn_acts != NULL) {
_XkbFree(devi->btn_acts);
devi->btn_acts = NULL;
}
devi->num_btns = 0;
return Success;
}
prev_btn_acts = devi->btn_acts;
devi->btn_acts = _XkbTypedRealloc(devi->btn_acts, newTotal, XkbAction);
if (devi->btn_acts == NULL) {
_XkbFree(prev_btn_acts);
devi->num_btns = 0;
return BadAlloc;
}
if (newTotal > devi->num_btns) {
XkbAction *act;
act = &devi->btn_acts[devi->num_btns];
bzero((char *) act, (newTotal - devi->num_btns) * sizeof(XkbAction));
}
devi->num_btns = newTotal;
return Success;
}
XkbConfigUnboundModPtr
XkbCFAddModByName( XkbConfigRtrnPtr rtrn,
int what,
char * name,
Bool merge,
XkbConfigUnboundModPtr last)
{
if (rtrn->num_unbound_mods>=rtrn->sz_unbound_mods) {
rtrn->sz_unbound_mods+= 5;
rtrn->unbound_mods= _XkbTypedRealloc(rtrn->unbound_mods,
rtrn->sz_unbound_mods,
XkbConfigUnboundModRec);
if (rtrn->unbound_mods==NULL) {
rtrn->error= XkbCF_BadAlloc;
return False;
}
}
if (last==NULL) {
last= &rtrn->unbound_mods[rtrn->num_unbound_mods++];
last->what= what;
last->mods= 0;
last->vmods= 0;
last->merge= merge;
last->name= NULL;
}
if (_XkbStrCaseCmp(name,"shift")==0)
last->mods|= ShiftMask;
else if (_XkbStrCaseCmp(name,"lock")==0)
last->mods|= LockMask;
else if ((_XkbStrCaseCmp(name,"control")==0)||
(_XkbStrCaseCmp(name,"ctrl")==0))
last->mods|= ControlMask;
else if (_XkbStrCaseCmp(name,"mod1")==0)
last->mods|= Mod1Mask;
else if (_XkbStrCaseCmp(name,"mod2")==0)
last->mods|= Mod2Mask;
else if (_XkbStrCaseCmp(name,"mod3")==0)
last->mods|= Mod3Mask;
else if (_XkbStrCaseCmp(name,"mod4")==0)
last->mods|= Mod4Mask;
else if (_XkbStrCaseCmp(name,"mod5")==0)
last->mods|= Mod5Mask;
else {
if (last->name!=NULL) {
last= &rtrn->unbound_mods[rtrn->num_unbound_mods++];
last->what= what;
last->mods= 0;
last->vmods= 0;
last->merge= merge;
last->name= NULL;
}
last->name= _XkbDupString(name);
}
return last;
}
/*ARGSUSED*/
Status
XkbAllocCompatMap(XkbDescPtr xkb, unsigned which, unsigned nSI)
{
XkbCompatMapPtr compat;
XkbSymInterpretRec *prev_interpret;
if (!xkb)
return BadMatch;
if (xkb->compat) {
if (xkb->compat->size_si >= nSI)
return Success;
compat = xkb->compat;
compat->size_si = nSI;
if (compat->sym_interpret == NULL)
compat->num_si = 0;
prev_interpret = compat->sym_interpret;
compat->sym_interpret = _XkbTypedRealloc(compat->sym_interpret,
nSI, XkbSymInterpretRec);
if (compat->sym_interpret == NULL) {
_XkbFree(prev_interpret);
compat->size_si = compat->num_si = 0;
return BadAlloc;
}
if (compat->num_si != 0) {
_XkbClearElems(compat->sym_interpret, compat->num_si,
compat->size_si - 1, XkbSymInterpretRec);
}
return Success;
}
compat = _XkbTypedCalloc(1, XkbCompatMapRec);
if (compat == NULL)
return BadAlloc;
if (nSI > 0) {
compat->sym_interpret = _XkbTypedCalloc(nSI, XkbSymInterpretRec);
if (!compat->sym_interpret) {
_XkbFree(compat);
return BadAlloc;
}
}
compat->size_si = nSI;
compat->num_si = 0;
bzero((char *) &compat->groups[0], XkbNumKbdGroups * sizeof(XkbModsRec));
xkb->compat = compat;
return Success;
}
static XkbRF_GroupPtr
XkbcRF_AddGroup(XkbRF_RulesPtr rules)
{
if (rules->sz_groups<1) {
rules->sz_groups= 16;
rules->num_groups= 0;
rules->groups= _XkbTypedCalloc(rules->sz_groups,XkbRF_GroupRec);
}
else if (rules->num_groups >= rules->sz_groups) {
rules->sz_groups *= 2;
rules->groups= _XkbTypedRealloc(rules->groups,rules->sz_groups,
XkbRF_GroupRec);
}
if (!rules->groups) {
rules->sz_groups= rules->num_groups= 0;
return NULL;
}
bzero((char *)&rules->groups[rules->num_groups],sizeof(XkbRF_GroupRec));
return &rules->groups[rules->num_groups++];
}
XkbRF_VarDescPtr
XkbRF_AddVarDesc(XkbRF_DescribeVarsPtr vars)
{
if (vars->sz_desc<1) {
vars->sz_desc= 16;
vars->num_desc= 0;
vars->desc= _XkbTypedCalloc(vars->sz_desc,XkbRF_VarDescRec);
}
else if (vars->num_desc>=vars->sz_desc) {
vars->sz_desc*= 2;
vars->desc= _XkbTypedRealloc(vars->desc,vars->sz_desc,XkbRF_VarDescRec);
}
if (!vars->desc) {
vars->sz_desc= vars->num_desc= 0;
PR_DEBUG("Allocation failure in XkbRF_AddVarDesc\n");
return NULL;
}
vars->desc[vars->num_desc].name= NULL;
vars->desc[vars->num_desc].desc= NULL;
return &vars->desc[vars->num_desc++];
}
XkbDeviceLedInfoPtr
XkbAddDeviceLedInfo(XkbDeviceInfoPtr devi, unsigned ledClass, unsigned ledId)
{
XkbDeviceLedInfoPtr devli;
register int i;
if ((!devi) || (!XkbSingleXIClass(ledClass)) || (!XkbSingleXIId(ledId)))
return NULL;
for (i = 0, devli = devi->leds; i < devi->num_leds; i++, devli++) {
if ((devli->led_class == ledClass) && (devli->led_id == ledId))
return devli;
}
if (devi->num_leds >= devi->sz_leds) {
XkbDeviceLedInfoRec *prev_leds = devi->leds;
if (devi->sz_leds > 0)
devi->sz_leds *= 2;
else
devi->sz_leds = 1;
devi->leds = _XkbTypedRealloc(devi->leds, devi->sz_leds,
XkbDeviceLedInfoRec);
if (!devi->leds) {
_XkbFree(prev_leds);
devi->sz_leds = devi->num_leds = 0;
return NULL;
}
i = devi->num_leds;
for (devli = &devi->leds[i]; i < devi->sz_leds; i++, devli++) {
bzero(devli, sizeof(XkbDeviceLedInfoRec));
devli->led_class = XkbXINone;
devli->led_id = XkbXINone;
}
}
devli = &devi->leds[devi->num_leds++];
bzero(devli, sizeof(XkbDeviceLedInfoRec));
devli->led_class = ledClass;
devli->led_id = ledId;
return devli;
}
static XkbRF_RulePtr
XkbcRF_AddRule(XkbRF_RulesPtr rules)
{
if (rules->sz_rules<1) {
rules->sz_rules= 16;
rules->num_rules= 0;
rules->rules= _XkbTypedCalloc(rules->sz_rules,XkbRF_RuleRec);
}
else if (rules->num_rules>=rules->sz_rules) {
rules->sz_rules*= 2;
rules->rules= _XkbTypedRealloc(rules->rules,rules->sz_rules,
XkbRF_RuleRec);
}
if (!rules->rules) {
rules->sz_rules= rules->num_rules= 0;
#ifdef DEBUG
fprintf(stderr,"Allocation failure in XkbcRF_AddRule\n");
#endif
return NULL;
}
bzero((char *)&rules->rules[rules->num_rules],sizeof(XkbRF_RuleRec));
return &rules->rules[rules->num_rules++];
}
Status
XkbAllocNames(XkbDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases)
{
XkbNamesPtr names;
if (xkb == NULL)
return BadMatch;
if (xkb->names == NULL) {
xkb->names = _XkbTypedCalloc(1, XkbNamesRec);
if (xkb->names == NULL)
return BadAlloc;
}
names = xkb->names;
if ((which & XkbKTLevelNamesMask) && (xkb->map != NULL) &&
(xkb->map->types != NULL)) {
register int i;
XkbKeyTypePtr type = xkb->map->types;
for (i = 0; i < xkb->map->num_types; i++, type++) {
if (type->level_names == NULL) {
type->level_names = _XkbTypedCalloc(type->num_levels, Atom);
if (type->level_names == NULL)
return BadAlloc;
}
}
}
if ((which & XkbKeyNamesMask) && (names->keys == NULL)) {
if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
(!XkbIsLegalKeycode(xkb->max_key_code)) ||
(xkb->max_key_code < xkb->min_key_code))
return BadValue;
names->keys = _XkbTypedCalloc((xkb->max_key_code + 1), XkbKeyNameRec);
if (names->keys == NULL)
return BadAlloc;
}
if ((which & XkbKeyAliasesMask) && (nTotalAliases > 0)) {
if (names->key_aliases == NULL) {
names->key_aliases = _XkbTypedCalloc(nTotalAliases, XkbKeyAliasRec);
}
else if (nTotalAliases > names->num_key_aliases) {
XkbKeyAliasRec *prev_aliases = names->key_aliases;
names->key_aliases = _XkbTypedRealloc(names->key_aliases,
nTotalAliases,
XkbKeyAliasRec);
if (names->key_aliases != NULL) {
_XkbClearElems(names->key_aliases, names->num_key_aliases,
nTotalAliases - 1, XkbKeyAliasRec);
}
else {
_XkbFree(prev_aliases);
}
}
if (names->key_aliases == NULL) {
names->num_key_aliases = 0;
return BadAlloc;
}
names->num_key_aliases = nTotalAliases;
}
if ((which & XkbRGNamesMask) && (nTotalRG > 0)) {
if (names->radio_groups == NULL) {
names->radio_groups = _XkbTypedCalloc(nTotalRG, Atom);
}
else if (nTotalRG > names->num_rg) {
Atom *prev_radio_groups = names->radio_groups;
names->radio_groups =
_XkbTypedRealloc(names->radio_groups, nTotalRG, Atom);
if (names->radio_groups != NULL) {
_XkbClearElems(names->radio_groups, names->num_rg, nTotalRG - 1,
Atom);
}
else {
_XkbFree(prev_radio_groups);
}
}
if (names->radio_groups == NULL)
return BadAlloc;
names->num_rg = nTotalRG;
}
return Success;
}
Status
XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
{
register int i;
XkbClientMapPtr map;
if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))
return BadValue;
if ((which&XkbKeySymsMask)&&
((!XkbIsLegalKeycode(xkb->min_key_code))||
(!XkbIsLegalKeycode(xkb->max_key_code))||
(xkb->max_key_code<xkb->min_key_code))) {
#ifdef DEBUG
fprintf(stderr,"bad keycode (%d,%d) in XkbAllocClientMap\n",
xkb->min_key_code,xkb->max_key_code);
#endif
return BadValue;
}
if (xkb->map==NULL) {
map= _XkbTypedCalloc(1,XkbClientMapRec);
if (map==NULL)
return BadAlloc;
xkb->map= map;
}
else map= xkb->map;
if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {
if (map->types==NULL) {
map->types= _XkbTypedCalloc(nTotalTypes,XkbKeyTypeRec);
if (map->types==NULL)
return BadAlloc;
map->num_types= 0;
map->size_types= nTotalTypes;
}
else if (map->size_types<nTotalTypes) {
XkbKeyTypeRec *prev_types = map->types;
map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);
if (map->types==NULL) {
_XkbFree(prev_types);
map->num_types= map->size_types= 0;
return BadAlloc;
}
map->size_types= nTotalTypes;
bzero(&map->types[map->num_types],
((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));
}
}
if (which&XkbKeySymsMask) {
int nKeys= XkbNumKeys(xkb);
if (map->syms==NULL) {
map->size_syms= (nKeys*15)/10;
map->syms= _XkbTypedCalloc(map->size_syms,KeySym);
if (!map->syms) {
map->size_syms= 0;
return BadAlloc;
}
map->num_syms= 1;
map->syms[0]= NoSymbol;
}
if (map->key_sym_map==NULL) {
i= xkb->max_key_code+1;
map->key_sym_map= _XkbTypedCalloc(i,XkbSymMapRec);
if (map->key_sym_map==NULL)
return BadAlloc;
}
}
if (which&XkbModifierMapMask) {
if ((!XkbIsLegalKeycode(xkb->min_key_code))||
(!XkbIsLegalKeycode(xkb->max_key_code))||
(xkb->max_key_code<xkb->min_key_code))
return BadMatch;
if (map->modmap==NULL) {
i= xkb->max_key_code+1;
map->modmap= _XkbTypedCalloc(i,unsigned char);
if (map->modmap==NULL)
return BadAlloc;
}
}
