andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

xkb: remove _XkbAlloc, _XkbCalloc, _XkbRealloc and _XkbFree

Browse Source 
We all agree that wrapping is fun, but seriously. One of these days someone
will get hurt.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Peter Hutterer 2009-05-05 21:00:31 +10:00
parent 0e31d3906d
commit 5cf7018381
11 changed files with 136 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/xkbsrv.h
View File

@ -301,15 +301,11 @@ extern _X_EXPORT pointer XkbLastRepeatEvent;
extern _X_EXPORT CARD32 xkbDebugFlags; extern _X_EXPORT CARD32 xkbDebugFlags;
#define _XkbAlloc(s) xalloc((s))
#define _XkbCalloc(n,s) Xcalloc((n)*(s))
#define _XkbRealloc(o,s) Xrealloc((o),(s))
#define _XkbTypedAlloc(t) ((t *)xalloc(sizeof(t))) #define _XkbTypedAlloc(t) ((t *)xalloc(sizeof(t)))
#define _XkbTypedCalloc(n,t) ((t *)Xcalloc((n)*sizeof(t))) #define _XkbTypedCalloc(n,t) ((t *)Xcalloc((n)*sizeof(t)))
#define _XkbTypedRealloc(o,n,t) \ #define _XkbTypedRealloc(o,n,t) \
((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t)) ((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t))
#define _XkbClearElems(a,f,l,t) bzero(&(a)[f],((l)-(f)+1)*sizeof(t)) #define _XkbClearElems(a,f,l,t) bzero(&(a)[f],((l)-(f)+1)*sizeof(t))
#define _XkbFree(p) Xfree(p)
#define _XkbLibError(c,l,d) /* Epoch fail */ #define _XkbLibError(c,l,d) /* Epoch fail */
#define _XkbErrCode2(a,b) ((XID)((((unsigned int)(a))<<24)|((b)&0xffffff))) #define _XkbErrCode2(a,b) ((XID)((((unsigned int)(a))<<24)|((b)&0xffffff)))

28
xkb/XKBAlloc.c
View File

@ -58,7 +58,7 @@ XkbSymInterpretRec *prev_interpret;
compat->sym_interpret= _XkbTypedRealloc(compat->sym_interpret, compat->sym_interpret= _XkbTypedRealloc(compat->sym_interpret,
nSI,XkbSymInterpretRec); nSI,XkbSymInterpretRec);
if (compat->sym_interpret==NULL) { if (compat->sym_interpret==NULL) {
_XkbFree(prev_interpret); xfree(prev_interpret);
compat->size_si= compat->num_si= 0; compat->size_si= compat->num_si= 0;
return BadAlloc; return BadAlloc;
} }
@ -74,7 +74,7 @@ XkbSymInterpretRec *prev_interpret;
if (nSI>0) { if (nSI>0) {
compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec); compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec);
if (!compat->sym_interpret) { if (!compat->sym_interpret) {
_XkbFree(compat); xfree(compat);
return BadAlloc; return BadAlloc;
} }
} }
@ -100,12 +100,12 @@ register XkbCompatMapPtr compat;
bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec)); bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
if (which&XkbSymInterpMask) { if (which&XkbSymInterpMask) {
if ((compat->sym_interpret)&&(compat->size_si>0)) if ((compat->sym_interpret)&&(compat->size_si>0))
_XkbFree(compat->sym_interpret); xfree(compat->sym_interpret);
compat->size_si= compat->num_si= 0; compat->size_si= compat->num_si= 0;
compat->sym_interpret= NULL; compat->sym_interpret= NULL;
} }
if (freeMap) { if (freeMap) {
_XkbFree(compat); xfree(compat);
xkb->compat= NULL; xkb->compat= NULL;
} }
return; return;
@ -161,7 +161,7 @@ XkbNamesPtr names;
_XkbClearElems(names->key_aliases,names->num_key_aliases, _XkbClearElems(names->key_aliases,names->num_key_aliases,
nTotalAliases-1,XkbKeyAliasRec); nTotalAliases-1,XkbKeyAliasRec);
} else { } else {
_XkbFree(prev_aliases); xfree(prev_aliases);
} }
} }
if (names->key_aliases==NULL) { if (names->key_aliases==NULL) {
@ -183,7 +183,7 @@ XkbNamesPtr names;
_XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1, _XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1,
Atom); Atom);
} else { } else {
_XkbFree(prev_radio_groups); xfree(prev_radio_groups);
} }
} }
if (names->radio_groups==NULL) if (names->radio_groups==NULL)
@ -211,29 +211,29 @@ XkbNamesPtr names;
type= map->types; type= map->types;
for (i=0;i<map->num_types;i++,type++) { for (i=0;i<map->num_types;i++,type++) {
if (type->level_names!=NULL) { if (type->level_names!=NULL) {
_XkbFree(type->level_names); xfree(type->level_names);
type->level_names= NULL; type->level_names= NULL;
} }
} }
} }
} }
if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) { if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
_XkbFree(names->keys); xfree(names->keys);
names->keys= NULL; names->keys= NULL;
names->num_keys= 0; names->num_keys= 0;
} }
if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){ if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
_XkbFree(names->key_aliases); xfree(names->key_aliases);
names->key_aliases=NULL; names->key_aliases=NULL;
names->num_key_aliases=0; names->num_key_aliases=0;
} }
if ((which&XkbRGNamesMask)&&(names->radio_groups)) { if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
_XkbFree(names->radio_groups); xfree(names->radio_groups);
names->radio_groups= NULL; names->radio_groups= NULL;
names->num_rg= 0; names->num_rg= 0;
} }
if (freeMap) { if (freeMap) {
_XkbFree(names); xfree(names);
xkb->names= NULL; xkb->names= NULL;
} }
return; return;
@ -261,7 +261,7 @@ static void
XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap) XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
{ {
if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) { if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
_XkbFree(xkb->ctrls); xfree(xkb->ctrls);
xkb->ctrls= NULL; xkb->ctrls= NULL;
} }
return; return;
@ -286,7 +286,7 @@ static void
XkbFreeIndicatorMaps(XkbDescPtr xkb) XkbFreeIndicatorMaps(XkbDescPtr xkb)
{ {
if ((xkb!=NULL)&&(xkb->indicators!=NULL)) { if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
_XkbFree(xkb->indicators); xfree(xkb->indicators);
xkb->indicators= NULL; xkb->indicators= NULL;
} }
return; return;
@ -330,6 +330,6 @@ XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)
if (which&XkbControlsMask) if (which&XkbControlsMask)
XkbFreeControls(xkb,XkbAllControlsMask,True); XkbFreeControls(xkb,XkbAllControlsMask,True);
if (freeAll) if (freeAll)
_XkbFree(xkb); xfree(xkb);
return; return;
} }

40
xkb/XKBGAlloc.c
View File

@ -51,7 +51,7 @@ _XkbFreeGeomLeafElems( Bool freeAll,
if ((freeAll)||(*elems==NULL)) { if ((freeAll)||(*elems==NULL)) {
*num_inout= *sz_inout= 0; *num_inout= *sz_inout= 0;
if (*elems!=NULL) { if (*elems!=NULL) {
_XkbFree(*elems); xfree(*elems);
*elems= NULL; *elems= NULL;
} }
return; return;
@ -115,7 +115,7 @@ register char *ptr;
if (freeAll) { if (freeAll) {
(*num_inout)= (*sz_inout)= 0; (*num_inout)= (*sz_inout)= 0;
if (*elems) { if (*elems) {
_XkbFree(*elems); xfree(*elems);
*elems= NULL; *elems= NULL;
} }
} }
@ -138,11 +138,11 @@ _XkbClearProperty(char *prop_in)
XkbPropertyPtr prop= (XkbPropertyPtr)prop_in; XkbPropertyPtr prop= (XkbPropertyPtr)prop_in;
if (prop->name) { if (prop->name) {
_XkbFree(prop->name); xfree(prop->name);
prop->name= NULL; prop->name= NULL;
} }
if (prop->value) { if (prop->value) {
_XkbFree(prop->value); xfree(prop->value);
prop->value= NULL; prop->value= NULL;
} }
return; return;
@ -184,7 +184,7 @@ _XkbClearColor(char *color_in)
XkbColorPtr color= (XkbColorPtr)color_in; XkbColorPtr color= (XkbColorPtr)color_in;
if (color->spec) if (color->spec)
_XkbFree(color->spec); xfree(color->spec);
return; return;
} }
@ -381,11 +381,11 @@ XkbDoodadPtr doodad= (XkbDoodadPtr)doodad_in;
case XkbTextDoodad: case XkbTextDoodad:
{ {
if (doodad->text.text!=NULL) { if (doodad->text.text!=NULL) {
_XkbFree(doodad->text.text); xfree(doodad->text.text);
doodad->text.text= NULL; doodad->text.text= NULL;
} }
if (doodad->text.font!=NULL) { if (doodad->text.font!=NULL) {
_XkbFree(doodad->text.font); xfree(doodad->text.font);
doodad->text.font= NULL; doodad->text.font= NULL;
} }
} }
@ -393,7 +393,7 @@ XkbDoodadPtr doodad= (XkbDoodadPtr)doodad_in;
case XkbLogoDoodad: case XkbLogoDoodad:
{ {
if (doodad->logo.logo_name!=NULL) { if (doodad->logo.logo_name!=NULL) {
_XkbFree(doodad->logo.logo_name); xfree(doodad->logo.logo_name);
doodad->logo.logo_name= NULL; doodad->logo.logo_name= NULL;
} }
} }
@ -413,7 +413,7 @@ register XkbDoodadPtr doodad;
_XkbClearDoodad((char *)doodad); _XkbClearDoodad((char *)doodad);
} }
if (freeAll) if (freeAll)
_XkbFree(doodads); xfree(doodads);
} }
return; return;
} }
@ -442,10 +442,10 @@ XkbFreeGeometry(XkbGeometryPtr geom,unsigned which,Bool freeMap)
XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,True); XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,True);
if (freeMap) { if (freeMap) {
if (geom->label_font!=NULL) { if (geom->label_font!=NULL) {
_XkbFree(geom->label_font); xfree(geom->label_font);
geom->label_font= NULL; geom->label_font= NULL;
} }
_XkbFree(geom); xfree(geom);
} }
return; return;
} }
@ -469,8 +469,8 @@ _XkbGeomAlloc( void ** old,
*total= (*num)+num_new; *total= (*num)+num_new;
if ((*old)!=NULL) if ((*old)!=NULL)
(*old)= _XkbRealloc((*old),(*total)*sz_elem); (*old)= xrealloc((*old),(*total)*sz_elem);
else (*old)= _XkbCalloc((*total),sz_elem); else (*old)= xcalloc((*total),sz_elem);
if ((*old)==NULL) { if ((*old)==NULL) {
*total= *num= 0; *total= *num= 0;
return BadAlloc; return BadAlloc;
@ -664,8 +664,8 @@ register XkbPropertyPtr prop;
for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) { for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
if ((prop->name)&&(strcmp(name,prop->name)==0)) { if ((prop->name)&&(strcmp(name,prop->name)==0)) {
if (prop->value) if (prop->value)
_XkbFree(prop->value); xfree(prop->value);
prop->value= (char *)_XkbAlloc(strlen(value)+1); prop->value= xalloc(strlen(value)+1);
if (prop->value) if (prop->value)
strcpy(prop->value,value); strcpy(prop->value,value);
return prop; return prop;
@ -676,13 +676,13 @@ register XkbPropertyPtr prop;
return NULL; return NULL;
} }
prop= &geom->properties[geom->num_properties]; prop= &geom->properties[geom->num_properties];
prop->name= (char *)_XkbAlloc(strlen(name)+1); prop->name= xalloc(strlen(name)+1);
if (!name) if (!name)
return NULL; return NULL;
strcpy(prop->name,name); strcpy(prop->name,name);
prop->value= (char *)_XkbAlloc(strlen(value)+1); prop->value= xalloc(strlen(value)+1);
if (!value) { if (!value) {
_XkbFree(prop->name); xfree(prop->name);
prop->name= NULL; prop->name= NULL;
return NULL; return NULL;
} }
@ -738,7 +738,7 @@ register XkbColorPtr color;
} }
color= &geom->colors[geom->num_colors]; color= &geom->colors[geom->num_colors];
color->pixel= pixel; color->pixel= pixel;
color->spec= (char *)_XkbAlloc(strlen(spec)+1); color->spec= xalloc(strlen(spec)+1);
if (!color->spec) if (!color->spec)
return NULL; return NULL;
strcpy(color->spec,spec); strcpy(color->spec,spec);
@ -852,7 +852,7 @@ XkbSectionPtr section;
return NULL; return NULL;
if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) { if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) {
if (section->rows) { if (section->rows) {
_XkbFree(section->rows); xfree(section->rows);
section->rows= NULL; section->rows= NULL;
section->sz_rows= section->num_rows= 0; section->sz_rows= section->num_rows= 0;
} }

68
xkb/XKBMAlloc.c
View File

@ -79,7 +79,7 @@ XkbClientMapPtr map;
map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec); map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);
if (map->types==NULL) { if (map->types==NULL) {
_XkbFree(prev_types); xfree(prev_types);
map->num_types= map->size_types= 0; map->num_types= map->size_types= 0;
return BadAlloc; return BadAlloc;
} }
@ -172,7 +172,7 @@ XkbServerMapPtr map;
need= map->num_acts+nNewActions; need= map->num_acts+nNewActions;
map->acts= _XkbTypedRealloc(map->acts,need,XkbAction); map->acts= _XkbTypedRealloc(map->acts,need,XkbAction);
if (map->acts==NULL) { if (map->acts==NULL) {
_XkbFree(prev_acts); xfree(prev_acts);
map->num_acts= map->size_acts= 0; map->num_acts= map->size_acts= 0;
return BadAlloc; return BadAlloc;
} }
@ -222,15 +222,15 @@ XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)
if ((!from)||(!into)) if ((!from)||(!into))
return BadMatch; return BadMatch;
if (into->map) { if (into->map) {
_XkbFree(into->map); xfree(into->map);
into->map= NULL; into->map= NULL;
} }
if (into->preserve) { if (into->preserve) {
_XkbFree(into->preserve); xfree(into->preserve);
into->preserve= NULL; into->preserve= NULL;
} }
if (into->level_names) { if (into->level_names) {
_XkbFree(into->level_names); xfree(into->level_names);
into->level_names= NULL; into->level_names= NULL;
} }
*into= *from; *into= *from;
@ -299,10 +299,10 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
type= &xkb->map->types[type_ndx]; type= &xkb->map->types[type_ndx];
if (map_count==0) { if (map_count==0) {
if (type->map!=NULL) if (type->map!=NULL)
_XkbFree(type->map); xfree(type->map);
type->map= NULL; type->map= NULL;
if (type->preserve!=NULL) if (type->preserve!=NULL)
_XkbFree(type->preserve); xfree(type->preserve);
type->preserve= NULL; type->preserve= NULL;
type->map_count= 0; type->map_count= 0;
} }
@ -313,7 +313,7 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
type->map=_XkbTypedRealloc(type->map,map_count,XkbKTMapEntryRec); type->map=_XkbTypedRealloc(type->map,map_count,XkbKTMapEntryRec);
if (!type->map) { if (!type->map) {
if (prev_map) if (prev_map)
_XkbFree(prev_map); xfree(prev_map);
return BadAlloc; return BadAlloc;
} }
if (want_preserve) { if (want_preserve) {
@ -325,12 +325,12 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
} }
if (!type->preserve) { if (!type->preserve) {
if (prev_preserve) if (prev_preserve)
_XkbFree(prev_preserve); xfree(prev_preserve);
return BadAlloc; return BadAlloc;
} }
} }
else if (type->preserve!=NULL) { else if (type->preserve!=NULL) {
_XkbFree(type->preserve); xfree(type->preserve);
type->preserve= NULL; type->preserve= NULL;
} }
type->map_count= map_count; type->map_count= map_count;
@ -342,7 +342,7 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
type->level_names=_XkbTypedRealloc(type->level_names,new_num_lvls,Atom); type->level_names=_XkbTypedRealloc(type->level_names,new_num_lvls,Atom);
if (!type->level_names) { if (!type->level_names) {
if (prev_level_names) if (prev_level_names)
_XkbFree(prev_level_names); xfree(prev_level_names);
return BadAlloc; return BadAlloc;
} }
} }
@ -422,7 +422,7 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
} }
} }
type->num_levels= new_num_lvls; type->num_levels= new_num_lvls;
_XkbFree(xkb->map->syms); xfree(xkb->map->syms);
xkb->map->syms= newSyms; xkb->map->syms= newSyms;
xkb->map->num_syms= nSyms; xkb->map->num_syms= nSyms;
return Success; return Success;
@ -518,7 +518,7 @@ KeySym *newSyms;
xkb->map->key_sym_map[i].offset = nSyms; xkb->map->key_sym_map[i].offset = nSyms;
nSyms+= nKeySyms; nSyms+= nKeySyms;
} }
_XkbFree(xkb->map->syms); xfree(xkb->map->syms);
xkb->map->syms = newSyms; xkb->map->syms = newSyms;
xkb->map->num_syms = nSyms; xkb->map->num_syms = nSyms;
return &xkb->map->syms[xkb->map->key_sym_map[key].offset]; return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
@ -640,7 +640,7 @@ int tmp;
xkb->map->key_sym_map= _XkbTypedRealloc(xkb->map->key_sym_map, xkb->map->key_sym_map= _XkbTypedRealloc(xkb->map->key_sym_map,
(maxKC+1),XkbSymMapRec); (maxKC+1),XkbSymMapRec);
if (!xkb->map->key_sym_map) { if (!xkb->map->key_sym_map) {
_XkbFree(prev_key_sym_map); xfree(prev_key_sym_map);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->map->key_sym_map[xkb->max_key_code], bzero((char *)&xkb->map->key_sym_map[xkb->max_key_code],
@ -658,7 +658,7 @@ int tmp;
xkb->map->modmap= _XkbTypedRealloc(xkb->map->modmap, xkb->map->modmap= _XkbTypedRealloc(xkb->map->modmap,
(maxKC+1),unsigned char); (maxKC+1),unsigned char);
if (!xkb->map->modmap) { if (!xkb->map->modmap) {
_XkbFree(prev_modmap); xfree(prev_modmap);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->map->modmap[xkb->max_key_code],tmp); bzero((char *)&xkb->map->modmap[xkb->max_key_code],tmp);
@ -677,7 +677,7 @@ int tmp;
xkb->server->behaviors=_XkbTypedRealloc(xkb->server->behaviors, xkb->server->behaviors=_XkbTypedRealloc(xkb->server->behaviors,
(maxKC+1),XkbBehavior); (maxKC+1),XkbBehavior);
if (!xkb->server->behaviors) { if (!xkb->server->behaviors) {
_XkbFree(prev_behaviors); xfree(prev_behaviors);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->server->behaviors[xkb->max_key_code], bzero((char *)&xkb->server->behaviors[xkb->max_key_code],
@ -695,7 +695,7 @@ int tmp;
xkb->server->key_acts= _XkbTypedRealloc(xkb->server->key_acts, xkb->server->key_acts= _XkbTypedRealloc(xkb->server->key_acts,
(maxKC+1),unsigned short); (maxKC+1),unsigned short);
if (!xkb->server->key_acts) { if (!xkb->server->key_acts) {
_XkbFree(prev_key_acts); xfree(prev_key_acts);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->server->key_acts[xkb->max_key_code], bzero((char *)&xkb->server->key_acts[xkb->max_key_code],
@ -713,7 +713,7 @@ int tmp;
xkb->server->vmodmap= _XkbTypedRealloc(xkb->server->vmodmap, xkb->server->vmodmap= _XkbTypedRealloc(xkb->server->vmodmap,
(maxKC+1),unsigned short); (maxKC+1),unsigned short);
if (!xkb->server->vmodmap) { if (!xkb->server->vmodmap) {
_XkbFree(prev_vmodmap); xfree(prev_vmodmap);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->server->vmodmap[xkb->max_key_code], bzero((char *)&xkb->server->vmodmap[xkb->max_key_code],
@ -732,7 +732,7 @@ int tmp;
xkb->names->keys= _XkbTypedRealloc(xkb->names->keys, xkb->names->keys= _XkbTypedRealloc(xkb->names->keys,
(maxKC+1),XkbKeyNameRec); (maxKC+1),XkbKeyNameRec);
if (!xkb->names->keys) { if (!xkb->names->keys) {
_XkbFree(prev_keys); xfree(prev_keys);
return BadAlloc; return BadAlloc;
} }
bzero((char *)&xkb->names->keys[xkb->max_key_code], bzero((char *)&xkb->names->keys[xkb->max_key_code],
@ -793,7 +793,7 @@ XkbAction *newActs;
xkb->server->key_acts[i]= nActs; xkb->server->key_acts[i]= nActs;
nActs+= nKeyActs; nActs+= nKeyActs;
} }
_XkbFree(xkb->server->acts); xfree(xkb->server->acts);
xkb->server->acts = newActs; xkb->server->acts = newActs;
xkb->server->num_acts= nActs; xkb->server->num_acts= nActs;
return &xkb->server->acts[xkb->server->key_acts[key]]; return &xkb->server->acts[xkb->server->key_acts[key]];
@ -816,42 +816,42 @@ XkbClientMapPtr map;
XkbKeyTypePtr type; XkbKeyTypePtr type;
for (i=0,type=map->types;i<map->num_types;i++,type++) { for (i=0,type=map->types;i<map->num_types;i++,type++) {
if (type->map!=NULL) { if (type->map!=NULL) {
_XkbFree(type->map); xfree(type->map);
type->map= NULL; type->map= NULL;
} }
if (type->preserve!=NULL) { if (type->preserve!=NULL) {
_XkbFree(type->preserve); xfree(type->preserve);
type->preserve= NULL; type->preserve= NULL;
} }
type->map_count= 0; type->map_count= 0;
if (type->level_names!=NULL) { if (type->level_names!=NULL) {
_XkbFree(type->level_names); xfree(type->level_names);
type->level_names= NULL; type->level_names= NULL;
} }
} }
} }
_XkbFree(map->types); xfree(map->types);
map->num_types= map->size_types= 0; map->num_types= map->size_types= 0;
map->types= NULL; map->types= NULL;
} }
} }
if (what&XkbKeySymsMask) { if (what&XkbKeySymsMask) {
if (map->key_sym_map!=NULL) { if (map->key_sym_map!=NULL) {
_XkbFree(map->key_sym_map); xfree(map->key_sym_map);
map->key_sym_map= NULL; map->key_sym_map= NULL;
} }
if (map->syms!=NULL) { if (map->syms!=NULL) {
_XkbFree(map->syms); xfree(map->syms);
map->size_syms= map->num_syms= 0; map->size_syms= map->num_syms= 0;
map->syms= NULL; map->syms= NULL;
} }
} }
if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) { if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {
_XkbFree(map->modmap); xfree(map->modmap);
map->modmap= NULL; map->modmap= NULL;
} }
if (freeMap) { if (freeMap) {
_XkbFree(xkb->map); xfree(xkb->map);
xkb->map= NULL; xkb->map= NULL;
} }
return; return;
@ -868,31 +868,31 @@ XkbServerMapPtr map;
what= XkbAllServerInfoMask; what= XkbAllServerInfoMask;
map= xkb->server; map= xkb->server;
if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) { if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {
_XkbFree(map->explicit); xfree(map->explicit);
map->explicit= NULL; map->explicit= NULL;
} }
if (what&XkbKeyActionsMask) { if (what&XkbKeyActionsMask) {
if (map->key_acts!=NULL) { if (map->key_acts!=NULL) {
_XkbFree(map->key_acts); xfree(map->key_acts);
map->key_acts= NULL; map->key_acts= NULL;
} }
if (map->acts!=NULL) { if (map->acts!=NULL) {
_XkbFree(map->acts); xfree(map->acts);
map->num_acts= map->size_acts= 0; map->num_acts= map->size_acts= 0;
map->acts= NULL; map->acts= NULL;
} }
} }
if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) { if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {
_XkbFree(map->behaviors); xfree(map->behaviors);
map->behaviors= NULL; map->behaviors= NULL;
} }
if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) { if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {
_XkbFree(map->vmodmap); xfree(map->vmodmap);
map->vmodmap= NULL; map->vmodmap= NULL;
} }
if (freeMap) { if (freeMap) {
_XkbFree(xkb->server); xfree(xkb->server);
xkb->server= NULL; xkb->server= NULL;
} }
return; return;

2
xkb/XKBMisc.c
View File

@ -507,7 +507,7 @@ unsigned changed,tmp;
mc->changed|= changed; mc->changed|= changed;
} }
if (interps!=ibuf) if (interps!=ibuf)
_XkbFree(interps); xfree(interps);
return True; return True;
} }

44
xkb/maprules.c
View File

@ -78,7 +78,7 @@ static void
FreeInputLine(InputLine *line) FreeInputLine(InputLine *line)
{ {
if (line->line!=line->buf) if (line->line!=line->buf)
_XkbFree(line->line); xfree(line->line);
line->line_num= 1; line->line_num= 1;
line->num_line= 0; line->num_line= 0;
line->sz_line= DFLT_LINE_SIZE; line->sz_line= DFLT_LINE_SIZE;
@ -91,11 +91,11 @@ InputLineAddChar(InputLine *line,int ch)
{ {
if (line->num_line>=line->sz_line) { if (line->num_line>=line->sz_line) {
if (line->line==line->buf) { if (line->line==line->buf) {
line->line= (char *)_XkbAlloc(line->sz_line*2); line->line= xalloc(line->sz_line*2);
memcpy(line->line,line->buf,line->sz_line); memcpy(line->line,line->buf,line->sz_line);
} }
else { else {
line->line=(char *)_XkbRealloc((char *)line->line,line->sz_line*2); line->line= xrealloc((char *)line->line,line->sz_line*2);
} }
line->sz_line*= 2; line->sz_line*= 2;
} }
@ -553,9 +553,9 @@ MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
static void static void
FreeMultiDefs(XkbRF_MultiDefsPtr defs) FreeMultiDefs(XkbRF_MultiDefsPtr defs)
{ {
if (defs->options) _XkbFree(defs->options); if (defs->options) xfree(defs->options);
if (defs->layout[1]) _XkbFree(defs->layout[1]); if (defs->layout[1]) xfree(defs->layout[1]);
if (defs->variant[1]) _XkbFree(defs->variant[1]); if (defs->variant[1]) xfree(defs->variant[1]);
} }
static void static void
@ -769,7 +769,7 @@ int len, ndx;
} }
str= index(&str[0],'%'); str= index(&str[0],'%');
} }
name= (char *)_XkbAlloc(len+1); name= xalloc(len+1);
str= orig; str= orig;
outstr= name; outstr= name;
while (*str!='\0') { while (*str!='\0') {
@ -819,7 +819,7 @@ int len, ndx;
} }
*outstr++= '\0'; *outstr++= '\0';
if (orig!=name) if (orig!=name)
_XkbFree(orig); xfree(orig);
return name; return name;
} }
@ -988,32 +988,32 @@ XkbRF_GroupPtr group;
return; return;
if (rules->rules) { if (rules->rules) {
for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) { for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) {
if (rule->model) _XkbFree(rule->model); if (rule->model) xfree(rule->model);
if (rule->layout) _XkbFree(rule->layout); if (rule->layout) xfree(rule->layout);
if (rule->variant) _XkbFree(rule->variant); if (rule->variant) xfree(rule->variant);
if (rule->option) _XkbFree(rule->option); if (rule->option) xfree(rule->option);
if (rule->keycodes) _XkbFree(rule->keycodes); if (rule->keycodes) xfree(rule->keycodes);
if (rule->symbols) _XkbFree(rule->symbols); if (rule->symbols) xfree(rule->symbols);
if (rule->types) _XkbFree(rule->types); if (rule->types) xfree(rule->types);
if (rule->compat) _XkbFree(rule->compat); if (rule->compat) xfree(rule->compat);
if (rule->geometry) _XkbFree(rule->geometry); if (rule->geometry) xfree(rule->geometry);
bzero((char *)rule,sizeof(XkbRF_RuleRec)); bzero((char *)rule,sizeof(XkbRF_RuleRec));
} }
_XkbFree(rules->rules); xfree(rules->rules);
rules->num_rules= rules->sz_rules= 0; rules->num_rules= rules->sz_rules= 0;
rules->rules= NULL; rules->rules= NULL;
} }
if (rules->groups) { if (rules->groups) {
for (i=0, group=rules->groups;i<rules->num_groups;i++,group++) { for (i=0, group=rules->groups;i<rules->num_groups;i++,group++) {
if (group->name) _XkbFree(group->name); if (group->name) xfree(group->name);
if (group->words) _XkbFree(group->words); if (group->words) xfree(group->words);
} }
_XkbFree(rules->groups); xfree(rules->groups);
rules->num_groups= 0; rules->num_groups= 0;
rules->groups= NULL; rules->groups= NULL;
} }
if (freeRules) if (freeRules)
_XkbFree(rules); xfree(rules);
return; return;
} }

40
xkb/xkb.c
View File

@ -1363,7 +1363,7 @@ unsigned i,len;
char *desc,*start; char *desc,*start;
len= (rep->length*4)-(SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply)); len= (rep->length*4)-(SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply));
start= desc= (char *)xcalloc(1, len); start= desc= xcalloc(1, len);
if (!start) if (!start)
return BadAlloc; return BadAlloc;
if ( rep->nTypes>0 ) if ( rep->nTypes>0 )
@ -2184,8 +2184,8 @@ unsigned first,last;
if (maxRG>(int)xkbi->nRadioGroups) { if (maxRG>(int)xkbi->nRadioGroups) {
int sz = maxRG*sizeof(XkbRadioGroupRec); int sz = maxRG*sizeof(XkbRadioGroupRec);
if (xkbi->radioGroups) if (xkbi->radioGroups)
xkbi->radioGroups=(XkbRadioGroupPtr)_XkbRealloc(xkbi->radioGroups,sz); xkbi->radioGroups= xrealloc(xkbi->radioGroups,sz);
else xkbi->radioGroups= (XkbRadioGroupPtr)_XkbCalloc(1, sz); else xkbi->radioGroups= xcalloc(1, sz);
if (xkbi->radioGroups) { if (xkbi->radioGroups) {
if (xkbi->nRadioGroups) if (xkbi->nRadioGroups)
bzero(&xkbi->radioGroups[xkbi->nRadioGroups], bzero(&xkbi->radioGroups[xkbi->nRadioGroups],
@ -2627,7 +2627,7 @@ int size;
size= rep->length*4; size= rep->length*4;
if (size>0) { if (size>0) {
data = (char *)xalloc(size); data = xalloc(size);
if (data) { if (data) {
register unsigned i,bit; register unsigned i,bit;
xkbModsWireDesc * grp; xkbModsWireDesc * grp;
@ -2994,7 +2994,7 @@ register unsigned bit;
length = rep->length*4; length = rep->length*4;
if (length>0) { if (length>0) {
CARD8 *to; CARD8 *to;
to= map= (CARD8 *)xalloc(length); to= map= xalloc(length);
if (map) { if (map) {
xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *)to; xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *)to;
for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) { for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
@ -3630,7 +3630,7 @@ register int n;
swapl(&rep->indicators,n); swapl(&rep->indicators,n);
} }
start = desc = (char *)xalloc(length); start = desc = xalloc(length);
if ( !start ) if ( !start )
return BadAlloc; return BadAlloc;
if (xkb->names) { if (xkb->names) {
@ -4116,7 +4116,7 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
tmp+= stuff->nKeyAliases*2; tmp+= stuff->nKeyAliases*2;
} }
else if (names->key_aliases!=NULL) { else if (names->key_aliases!=NULL) {
_XkbFree(names->key_aliases); xfree(names->key_aliases);
names->key_aliases= NULL; names->key_aliases= NULL;
names->num_key_aliases= 0; names->num_key_aliases= 0;
} }
@ -4135,7 +4135,7 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
tmp+= stuff->nRadioGroups; tmp+= stuff->nRadioGroups;
} }
else if (names->radio_groups) { else if (names->radio_groups) {
_XkbFree(names->radio_groups); xfree(names->radio_groups);
names->radio_groups= NULL; names->radio_groups= NULL;
names->num_rg= 0; names->num_rg= 0;
} }
@ -4735,7 +4735,7 @@ XkbSendGeometry( ClientPtr client,
if (geom!=NULL) { if (geom!=NULL) {
len= rep->length*4; len= rep->length*4;
start= desc= (char *)xalloc(len); start= desc= xalloc(len);
if (!start) if (!start)
return BadAlloc; return BadAlloc;
desc= XkbWriteCountedString(desc,geom->label_font,client->swapped); desc= XkbWriteCountedString(desc,geom->label_font,client->swapped);
@ -4829,7 +4829,7 @@ CARD16 len,*plen;
swaps(plen,n); swaps(plen,n);
} }
len= *plen; len= *plen;
str= (char *)_XkbAlloc(len+1); str= xalloc(len+1);
if (str) { if (str) {
memcpy(str,&wire[2],len); memcpy(str,&wire[2],len);
str[len]= '\0'; str[len]= '\0';
@ -5444,7 +5444,7 @@ unsigned char *wire,*str,*tmp,*legal;
wire= *pWire; wire= *pWire;
len= (*(unsigned char *)wire++); len= (*(unsigned char *)wire++);
if (len>0) { if (len>0) {
str= (unsigned char *)_XkbCalloc(1, len+1); str= xcalloc(1, len+1);
if (str) { if (str) {
tmp= str; tmp= str;
for (i=0;i<len;i++) { for (i=0;i<len;i++) {
@ -5455,7 +5455,7 @@ unsigned char *wire,*str,*tmp,*legal;
if (tmp!=str) if (tmp!=str)
*tmp++= '\0'; *tmp++= '\0';
else { else {
_XkbFree(str); xfree(str);
str= NULL; str= NULL;
} }
} }
@ -5506,7 +5506,7 @@ ProcXkbListComponents(ClientPtr client)
return BadLength; return BadLength;
if ((status=XkbDDXList(dev,&list,client))!=Success) { if ((status=XkbDDXList(dev,&list,client))!=Success) {
if (list.pool) { if (list.pool) {
_XkbFree(list.pool); xfree(list.pool);
list.pool= NULL; list.pool= NULL;
} }
return status; return status;
@ -5540,7 +5540,7 @@ ProcXkbListComponents(ClientPtr client)
WriteToClient(client,SIZEOF(xkbListComponentsReply),(char *)&rep); WriteToClient(client,SIZEOF(xkbListComponentsReply),(char *)&rep);
if (list.nPool && list.pool) { if (list.nPool && list.pool) {
WriteToClient(client,XkbPaddedSize(list.nPool), (char *)list.pool); WriteToClient(client,XkbPaddedSize(list.nPool), (char *)list.pool);
_XkbFree(list.pool); xfree(list.pool);
list.pool= NULL; list.pool= NULL;
} }
return client->noClientException; return client->noClientException;
@ -5869,11 +5869,11 @@ ProcXkbGetKbdByName(ClientPtr client)
XkbFreeKeyboard(new,XkbAllComponentsMask,True); XkbFreeKeyboard(new,XkbAllComponentsMask,True);
new= NULL; new= NULL;
} }
if (names.keycodes) { _XkbFree(names.keycodes); names.keycodes= NULL; } if (names.keycodes) { xfree(names.keycodes); names.keycodes= NULL; }
if (names.types) { _XkbFree(names.types); names.types= NULL; } if (names.types) { xfree(names.types); names.types= NULL; }
if (names.compat) { _XkbFree(names.compat); names.compat= NULL; } if (names.compat) { xfree(names.compat); names.compat= NULL; }
if (names.symbols) { _XkbFree(names.symbols); names.symbols= NULL; } if (names.symbols) { xfree(names.symbols); names.symbols= NULL; }
if (names.geometry) { _XkbFree(names.geometry); names.geometry= NULL; } if (names.geometry) { xfree(names.geometry); names.geometry= NULL; }
return client->noClientException; return client->noClientException;
} }
@ -6188,7 +6188,7 @@ char * str;
} }
WriteToClient(client,SIZEOF(xkbGetDeviceInfoReply), (char *)&rep); WriteToClient(client,SIZEOF(xkbGetDeviceInfoReply), (char *)&rep);
str= (char*) xalloc(nameLen); str= xalloc(nameLen);
if (!str) if (!str)
return BadAlloc; return BadAlloc;
XkbWriteCountedString(str,dev->name,client->swapped); XkbWriteCountedString(str,dev->name,client->swapped);

4
xkb/xkbEvents.c
View File

@ -1136,7 +1136,7 @@ ClientPtr client = NULL;
autoCtrls= interest->autoCtrls; autoCtrls= interest->autoCtrls;
autoValues= interest->autoCtrlValues; autoValues= interest->autoCtrlValues;
client= interest->client; client= interest->client;
_XkbFree(interest); xfree(interest);
found= True; found= True;
} }
while ((!found)&&(interest->next)) { while ((!found)&&(interest->next)) {
@ -1146,7 +1146,7 @@ ClientPtr client = NULL;
autoCtrls= victim->autoCtrls; autoCtrls= victim->autoCtrls;
autoValues= victim->autoCtrlValues; autoValues= victim->autoCtrlValues;
client= victim->client; client= victim->client;
_XkbFree(victim); xfree(victim);
found= True; found= True;
} }
interest = interest->next; interest = interest->next;

34
xkb/xkbInit.c
View File

@ -222,19 +222,19 @@ static void
XkbSetRulesUsed(XkbRMLVOSet *rmlvo) XkbSetRulesUsed(XkbRMLVOSet *rmlvo)
{ {
if (XkbRulesUsed) if (XkbRulesUsed)
_XkbFree(XkbRulesUsed); xfree(XkbRulesUsed);
XkbRulesUsed= (rmlvo->rules?_XkbDupString(rmlvo->rules):NULL); XkbRulesUsed= (rmlvo->rules?_XkbDupString(rmlvo->rules):NULL);
if (XkbModelUsed) if (XkbModelUsed)
_XkbFree(XkbModelUsed); xfree(XkbModelUsed);
XkbModelUsed= (rmlvo->model?_XkbDupString(rmlvo->model):NULL); XkbModelUsed= (rmlvo->model?_XkbDupString(rmlvo->model):NULL);
if (XkbLayoutUsed) if (XkbLayoutUsed)
_XkbFree(XkbLayoutUsed); xfree(XkbLayoutUsed);
XkbLayoutUsed= (rmlvo->layout?_XkbDupString(rmlvo->layout):NULL); XkbLayoutUsed= (rmlvo->layout?_XkbDupString(rmlvo->layout):NULL);
if (XkbVariantUsed) if (XkbVariantUsed)
_XkbFree(XkbVariantUsed); xfree(XkbVariantUsed);
XkbVariantUsed= (rmlvo->variant?_XkbDupString(rmlvo->variant):NULL); XkbVariantUsed= (rmlvo->variant?_XkbDupString(rmlvo->variant):NULL);
if (XkbOptionsUsed) if (XkbOptionsUsed)
_XkbFree(XkbOptionsUsed); xfree(XkbOptionsUsed);
XkbOptionsUsed= (rmlvo->options?_XkbDupString(rmlvo->options):NULL); XkbOptionsUsed= (rmlvo->options?_XkbDupString(rmlvo->options):NULL);
if (XkbWantRulesProp) if (XkbWantRulesProp)
QueueWorkProc(XkbWriteRulesProp,NULL,NULL); QueueWorkProc(XkbWriteRulesProp,NULL,NULL);
@ -246,27 +246,27 @@ XkbSetRulesDflts(XkbRMLVOSet *rmlvo)
{ {
if (rmlvo->rules) { if (rmlvo->rules) {
if (XkbRulesDflt) if (XkbRulesDflt)
_XkbFree(XkbRulesDflt); xfree(XkbRulesDflt);
XkbRulesDflt= _XkbDupString(rmlvo->rules); XkbRulesDflt= _XkbDupString(rmlvo->rules);
} }
if (rmlvo->model) { if (rmlvo->model) {
if (XkbModelDflt) if (XkbModelDflt)
_XkbFree(XkbModelDflt); xfree(XkbModelDflt);
XkbModelDflt= _XkbDupString(rmlvo->model); XkbModelDflt= _XkbDupString(rmlvo->model);
} }
if (rmlvo->layout) { if (rmlvo->layout) {
if (XkbLayoutDflt) if (XkbLayoutDflt)
_XkbFree(XkbLayoutDflt); xfree(XkbLayoutDflt);
XkbLayoutDflt= _XkbDupString(rmlvo->layout); XkbLayoutDflt= _XkbDupString(rmlvo->layout);
} }
if (rmlvo->variant) { if (rmlvo->variant) {
if (XkbVariantDflt) if (XkbVariantDflt)
_XkbFree(XkbVariantDflt); xfree(XkbVariantDflt);
XkbVariantDflt= _XkbDupString(rmlvo->variant); XkbVariantDflt= _XkbDupString(rmlvo->variant);
} }
if (rmlvo->options) { if (rmlvo->options) {
if (XkbOptionsDflt) if (XkbOptionsDflt)
_XkbFree(XkbOptionsDflt); xfree(XkbOptionsDflt);
XkbOptionsDflt= _XkbDupString(rmlvo->options); XkbOptionsDflt= _XkbDupString(rmlvo->options);
} }
return; return;
@ -275,15 +275,15 @@ XkbSetRulesDflts(XkbRMLVOSet *rmlvo)
void void
XkbDeleteRulesDflts(void) XkbDeleteRulesDflts(void)
{ {
_XkbFree(XkbRulesDflt); xfree(XkbRulesDflt);
XkbRulesDflt = NULL; XkbRulesDflt = NULL;
_XkbFree(XkbModelDflt); xfree(XkbModelDflt);
XkbModelDflt = NULL; XkbModelDflt = NULL;
_XkbFree(XkbLayoutDflt); xfree(XkbLayoutDflt);
XkbLayoutDflt = NULL; XkbLayoutDflt = NULL;
_XkbFree(XkbVariantDflt); xfree(XkbVariantDflt);
XkbVariantDflt = NULL; XkbVariantDflt = NULL;
_XkbFree(XkbOptionsDflt); xfree(XkbOptionsDflt);
XkbOptionsDflt = NULL; XkbOptionsDflt = NULL;
XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, True); XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, True);
@ -643,7 +643,7 @@ void
XkbFreeInfo(XkbSrvInfoPtr xkbi) XkbFreeInfo(XkbSrvInfoPtr xkbi)
{ {
if (xkbi->radioGroups) { if (xkbi->radioGroups) {
_XkbFree(xkbi->radioGroups); xfree(xkbi->radioGroups);
xkbi->radioGroups= NULL; xkbi->radioGroups= NULL;
} }
if (xkbi->mouseKeyTimer) { if (xkbi->mouseKeyTimer) {
@ -675,7 +675,7 @@ XkbFreeInfo(XkbSrvInfoPtr xkbi)
XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True); XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
xkbi->desc= NULL; xkbi->desc= NULL;
} }
_XkbFree(xkbi); xfree(xkbi);
return; return;
} }

6
xkb/xkbLEDs.c
View File

@ -605,12 +605,12 @@ void
XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli) XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli)
{ {
if ((sli->flags&XkbSLI_IsDefault)==0) { if ((sli->flags&XkbSLI_IsDefault)==0) {
if (sli->maps) _XkbFree(sli->maps); if (sli->maps) xfree(sli->maps);
if (sli->names) _XkbFree(sli->names); if (sli->names) xfree(sli->names);
} }
sli->maps= NULL; sli->maps= NULL;
sli->names= NULL; sli->names= NULL;
_XkbFree(sli); xfree(sli);
return; return;
} }

6
xkb/xkmread.c
View File

@ -57,7 +57,7 @@ char *new;
if (str==NULL) if (str==NULL)
return NULL; return NULL;
new= (char *)_XkbCalloc(strlen(str)+1,sizeof(char)); new= xcalloc(strlen(str)+1,sizeof(char));
if (new) if (new)
strcpy(new,str); strcpy(new,str);
return new; return new;
@ -73,10 +73,10 @@ int newCount= *newCountRtrn;
if (oldPtr==NULL) { if (oldPtr==NULL) {
if (newCount==0) if (newCount==0)
return NULL; return NULL;
oldPtr= _XkbCalloc(newCount,elemSize); oldPtr= xcalloc(newCount,elemSize);
} }
else if (oldCount<newCount) { else if (oldCount<newCount) {
oldPtr= _XkbRealloc(oldPtr,newCount*elemSize); oldPtr= xrealloc(oldPtr,newCount*elemSize);
if (oldPtr!=NULL) { if (oldPtr!=NULL) {
char *tmp= (char *)oldPtr; char *tmp= (char *)oldPtr;
bzero(&tmp[oldCount*elemSize],(newCount-oldCount)*elemSize); bzero(&tmp[oldCount*elemSize],(newCount-oldCount)*elemSize);