StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove unneeded freeing mechanisms 

Signed-off-by: Ran Benita <ran234@gmail.com>
master
Ran Benita 2012-03-02 15:56:03 +02:00
parent c7bf368780
commit a64e970809
8 changed files with 131 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/alloc.c
View File

@ -87,7 +87,7 @@ XkbcAllocCompatMap(struct xkb_desc * xkb, unsigned which, unsigned nSI)
static void
XkbcFreeCompatMap(struct xkb_desc * xkb, unsigned which, Bool freeMap)
XkbcFreeCompatMap(struct xkb_desc * xkb)
{
struct xkb_compat_map * compat;
@ -95,23 +95,10 @@ XkbcFreeCompatMap(struct xkb_desc * xkb, unsigned which, Bool freeMap)
return;
compat = xkb->compat;
if (freeMap)
which = XkbAllCompatMask;
if (which & XkbGroupCompatMask)
memset(&compat->groups[0], 0,
XkbNumKbdGroups * sizeof(struct xkb_mods));
if (which & XkbSymInterpMask) {
free(compat->sym_interpret);
compat->size_si = compat->num_si = 0;
compat->sym_interpret = NULL;
}
if (freeMap) {
free(compat);
xkb->compat = NULL;
}
}
int
@ -202,19 +189,16 @@ XkbcAllocNames(struct xkb_desc * xkb, unsigned which, int nTotalRG, int nTotalAl
}
static void
XkbcFreeNames(struct xkb_desc * xkb, unsigned which, Bool freeMap)
XkbcFreeNames(struct xkb_desc * xkb)
{
struct xkb_names * names;
struct xkb_client_map * map;
if (!xkb || !xkb->names)
return;
names = xkb->names;
if (freeMap)
which = XkbAllNamesMask;
if (which & XkbKTLevelNamesMask) {
struct xkb_client_map * map = xkb->map;
map = xkb->map;
if (map && map->types) {
int i;
@ -225,30 +209,12 @@ XkbcFreeNames(struct xkb_desc * xkb, unsigned which, Bool freeMap)
type->level_names = NULL;
}
}
}
if (which & XkbKeyNamesMask) {
free(names->keys);
names->keys = NULL;
names->num_keys = 0;
}
if (which & XkbKeyAliasesMask) {
free(names->key_aliases);
names->key_aliases = NULL;
names->num_key_aliases = 0;
}
if (which & XkbRGNamesMask) {
free(names->radio_groups);
names->radio_groups = NULL;
names->num_rg = 0;
}
if (freeMap) {
free(names);
xkb->names = NULL;
}
}
int
@ -274,9 +240,9 @@ XkbcAllocControls(struct xkb_desc * xkb, unsigned which)
}
static void
XkbcFreeControls(struct xkb_desc * xkb, unsigned which, Bool freeMap)
XkbcFreeControls(struct xkb_desc * xkb)
{
if (freeMap && xkb && xkb->ctrls) {
if (xkb && xkb->ctrls) {
free(xkb->ctrls->per_key_repeat);
free(xkb->ctrls);
xkb->ctrls = NULL;
@ -319,28 +285,17 @@ XkbcAllocKeyboard(void)
}
void
XkbcFreeKeyboard(struct xkb_desc * xkb, unsigned which, Bool freeAll)
XkbcFreeKeyboard(struct xkb_desc * xkb)
{
if (!xkb)
return;
if (freeAll)
which = XkbAllComponentsMask;
if (which & XkbClientMapMask)
XkbcFreeClientMap(xkb, XkbAllClientInfoMask, True);
if (which & XkbServerMapMask)
XkbcFreeServerMap(xkb, XkbAllServerInfoMask, True);
if (which & XkbCompatMapMask)
XkbcFreeCompatMap(xkb, XkbAllCompatMask, True);
if (which & XkbIndicatorMapMask)
XkbcFreeClientMap(xkb);
XkbcFreeServerMap(xkb);
XkbcFreeCompatMap(xkb);
XkbcFreeIndicatorMaps(xkb);
if (which & XkbNamesMask)
XkbcFreeNames(xkb, XkbAllNamesMask, True);
if ((which & XkbGeometryMask) && xkb->geom)
XkbcFreeGeometry(xkb->geom, XkbGeomAllMask, True);
if (which & XkbControlsMask)
XkbcFreeControls(xkb, XkbAllControlsMask, True);
if (freeAll)
XkbcFreeNames(xkb);
XkbcFreeGeometry(xkb);
XkbcFreeControls(xkb);
free(xkb);
}

238
src/galloc.c
View File

@ -31,87 +31,37 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "XKBcommonint.h"
#include <X11/extensions/XKB.h>
static void
_XkbFreeGeomLeafElems(Bool freeAll, int first, int count,
unsigned short *num_inout, unsigned short *sz_inout,
char **elems, unsigned int elem_sz)
{
if (freeAll || !(*elems)) {
*num_inout = *sz_inout = 0;
free(*elems);
*elems = NULL;
return;
}
if ((first >= (*num_inout)) || (first < 0) || (count < 1))
return;
if (first + count >= (*num_inout))
/* truncating the array is easy */
(*num_inout) = first;
else {
char *ptr = *elems;
int extra = ((*num_inout) - first + count) * elem_sz;
if (extra > 0)
memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz],
extra);
(*num_inout) -= count;
}
}
typedef void (*ContentsClearFunc)(char *priv);
typedef void (*ContentsClearFunc)(void *priv);
static void
_XkbFreeGeomNonLeafElems(Bool freeAll, int first, int count,
unsigned short *num_inout, unsigned short *sz_inout,
char **elems, unsigned int elem_sz,
_XkbFreeGeomNonLeafElems(unsigned short *num_inout, unsigned short *sz_inout,
void *elems, size_t elem_sz,
ContentsClearFunc freeFunc)
{
int i;
char *ptr;
char *start, *ptr;
if (freeAll) {
first = 0;
count = *num_inout;
}
else if ((first >= (*num_inout)) || (first < 0) || (count < 1))
return;
else if (first + count > (*num_inout))
count = (*num_inout) - first;
if (!(*elems))
if (!elems)
return;
if (freeFunc) {
ptr = *elems;
ptr += first * elem_sz;
for (i = 0; i < count; i++) {
(*freeFunc)(ptr);
start = *(char **)elems;
if (!start)
return;
ptr = start;
for (i = 0; i < *num_inout; i++) {
freeFunc(ptr);
ptr += elem_sz;
}
}
if (freeAll) {
*num_inout = *sz_inout = 0;
free(*elems);
*elems = NULL;
}
else if (first + count >= (*num_inout))
*num_inout = first;
else {
i = ((*num_inout) - first + count) * elem_sz;
ptr = *elems;
memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz], i);
(*num_inout) -= count;
}
free(start);
}
static void
_XkbClearProperty(char *prop_in)
_XkbClearProperty(void *prop_in)
{
struct xkb_property * prop = (struct xkb_property *)prop_in;
struct xkb_property * prop = prop_in;
free(prop->name);
prop->name = NULL;
@ -120,118 +70,80 @@ _XkbClearProperty(char *prop_in)
}
static void
XkbcFreeGeomProperties(struct xkb_geometry * geom, int first, int count, Bool freeAll)
XkbcFreeGeomProperties(struct xkb_geometry * geom)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_properties, &geom->sz_properties,
(char **)&geom->properties,
sizeof(struct xkb_property),
_XkbFreeGeomNonLeafElems(&geom->num_properties, &geom->sz_properties,
&geom->properties, sizeof(struct xkb_property),
_XkbClearProperty);
}
static void
XkbcFreeGeomKeyAliases(struct xkb_geometry * geom, int first, int count, Bool freeAll)
_XkbClearColor(void *color_in)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&geom->num_key_aliases, &geom->sz_key_aliases,
(char **)&geom->key_aliases,
sizeof(struct xkb_key_alias));
}
static void
_XkbClearColor(char *color_in)
{
struct xkb_color * color = (struct xkb_color *)color_in;
struct xkb_color * color = color_in;
free(color->spec);
}
static void
XkbcFreeGeomColors(struct xkb_geometry * geom, int first, int count, Bool freeAll)
XkbcFreeGeomColors(struct xkb_geometry * geom)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_colors, &geom->sz_colors,
(char **)&geom->colors, sizeof(struct xkb_color),
_XkbFreeGeomNonLeafElems(&geom->num_colors, &geom->sz_colors,
&geom->colors, sizeof(struct xkb_color),
_XkbClearColor);
}
static void
XkbcFreeGeomPoints(struct xkb_outline * outline, int first, int count, Bool freeAll)
_XkbClearOutline(void *outline_in)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&outline->num_points, &outline->sz_points,
(char **)&outline->points, sizeof(struct xkb_point));
struct xkb_outline * outline = outline_in;
free(outline->points);
}
static void
_XkbClearOutline(char *outline_in)
XkbcFreeGeomOutlines(struct xkb_shape * shape)
{
struct xkb_outline * outline = (struct xkb_outline *)outline_in;
if (outline->points)
XkbcFreeGeomPoints(outline, 0, outline->num_points, True);
}
static void
XkbcFreeGeomOutlines(struct xkb_shape * shape, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&shape->num_outlines, &shape->sz_outlines,
(char **)&shape->outlines, sizeof(struct xkb_outline),
_XkbFreeGeomNonLeafElems(&shape->num_outlines, &shape->sz_outlines,
&shape->outlines, sizeof(struct xkb_outline),
_XkbClearOutline);
}
static void
_XkbClearShape(char *shape_in)
_XkbClearShape(void *shape_in)
{
struct xkb_shape * shape = (struct xkb_shape *)shape_in;
struct xkb_shape * shape = shape_in;
if (shape->outlines)
XkbcFreeGeomOutlines(shape, 0, shape->num_outlines, True);
XkbcFreeGeomOutlines(shape);
}
static void
XkbcFreeGeomShapes(struct xkb_geometry * geom, int first, int count, Bool freeAll)
XkbcFreeGeomShapes(struct xkb_geometry * geom)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_shapes, &geom->sz_shapes,
(char **)&geom->shapes, sizeof(struct xkb_shape),
_XkbFreeGeomNonLeafElems(&geom->num_shapes, &geom->sz_shapes,
&geom->shapes, sizeof(struct xkb_shape),
_XkbClearShape);
}
static void
XkbcFreeGeomKeys(struct xkb_row * row, int first, int count, Bool freeAll)
_XkbClearRow(void *row_in)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&row->num_keys, &row->sz_keys,
(char **)&row->keys, sizeof(struct xkb_key));
struct xkb_row * row = row_in;
free(row->keys);
}
static void
_XkbClearRow(char *row_in)
XkbcFreeGeomRows(struct xkb_section * section)
{
struct xkb_row * row = (struct xkb_row *)row_in;
if (row->keys)
XkbcFreeGeomKeys(row, 0, row->num_keys, True);
}
static void
XkbcFreeGeomRows(struct xkb_section * section, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&section->num_rows, &section->sz_rows,
(char **)&section->rows, sizeof(struct xkb_row),
_XkbFreeGeomNonLeafElems(&section->num_rows, &section->sz_rows,
&section->rows, sizeof(struct xkb_row),
_XkbClearRow);
}
static void
_XkbClearDoodad(char *doodad_in)
_XkbClearDoodad(union xkb_doodad *doodad)
{
union xkb_doodad * doodad = (union xkb_doodad *)doodad_in;
switch (doodad->any.type) {
case XkbTextDoodad:
free(doodad->text.text);
@ -248,72 +160,52 @@ _XkbClearDoodad(char *doodad_in)
}
static void
XkbcFreeGeomDoodads(union xkb_doodad * doodads, int nDoodads, Bool freeAll)
XkbcFreeGeomDoodads(union xkb_doodad * doodads, int nDoodads)
{
int i;
union xkb_doodad * doodad;
for (i = 0, doodad = doodads; i < nDoodads && doodad; i++, doodad++)
_XkbClearDoodad((char *)doodad);
if (freeAll)
_XkbClearDoodad(doodad);
free(doodads);
}
static void
_XkbClearSection(char *section_in)
_XkbClearSection(void *section_in)
{
struct xkb_section * section = (struct xkb_section *)section_in;
struct xkb_section * section = section_in;
if (section->rows)
XkbcFreeGeomRows(section, 0, section->num_rows, True);
XkbcFreeGeomDoodads(section->doodads, section->num_doodads, True);
XkbcFreeGeomRows(section);
XkbcFreeGeomDoodads(section->doodads, section->num_doodads);
section->doodads = NULL;
}
static void
XkbcFreeGeomSections(struct xkb_geometry * geom, int first, int count, Bool freeAll)
XkbcFreeGeomSections(struct xkb_geometry * geom)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_sections, &geom->sz_sections,
(char **)&geom->sections, sizeof(struct xkb_section),
_XkbFreeGeomNonLeafElems(&geom->num_sections, &geom->sz_sections,
&geom->sections, sizeof(struct xkb_section),
_XkbClearSection);
}
void
XkbcFreeGeometry(struct xkb_geometry * geom, unsigned which, Bool freeMap)
XkbcFreeGeometry(struct xkb_desc * xkb)
{
if (!geom)
struct xkb_geometry *geom;
if (!xkb || !xkb->geom)
return;
if (freeMap)
which = XkbGeomAllMask;
geom = xkb->geom;
if ((which & XkbGeomPropertiesMask) && geom->properties)
XkbcFreeGeomProperties(geom, 0, geom->num_properties, True);
if ((which & XkbGeomColorsMask) && geom->colors)
XkbcFreeGeomColors(geom, 0, geom->num_colors, True);
if ((which & XkbGeomShapesMask) && geom->shapes)
XkbcFreeGeomShapes(geom, 0, geom->num_shapes, True);
if ((which & XkbGeomSectionsMask) && geom->sections)
XkbcFreeGeomSections(geom, 0, geom->num_sections, True);
if ((which & XkbGeomDoodadsMask) && geom->doodads) {
XkbcFreeGeomDoodads(geom->doodads, geom->num_doodads, True);
geom->doodads = NULL;
geom->num_doodads = geom->sz_doodads = 0;
}
if ((which & XkbGeomKeyAliasesMask) && geom->key_aliases)
XkbcFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, True);
if (freeMap) {
XkbcFreeGeomProperties(geom);
XkbcFreeGeomColors(geom);
XkbcFreeGeomShapes(geom);
XkbcFreeGeomSections(geom);
XkbcFreeGeomDoodads(geom->doodads, geom->num_doodads);
free(geom->key_aliases);
free(geom->label_font);
geom->label_font = NULL;
free(geom);
}
}
static int
@ -447,7 +339,7 @@ XkbcAllocGeometry(struct xkb_desc * xkb, struct xkb_geometry_sizes * sizes)
return Success;
bail:
XkbcFreeGeometry(geom, XkbGeomAllMask, True);
XkbcFreeGeometry(xkb);
xkb->geom = NULL;
return rtrn;
}

54
src/malloc.c
View File

@ -380,91 +380,45 @@ XkbcResizeKeyActions(struct xkb_desc * xkb, xkb_keycode_t key, int needed)
}
void
XkbcFreeClientMap(struct xkb_desc * xkb, unsigned what, Bool freeMap)
XkbcFreeClientMap(struct xkb_desc * xkb)
{
int i;
struct xkb_client_map * map;
struct xkb_key_type * type;
if (!xkb || !xkb->map)
return;
if (freeMap)
what = XkbAllClientInfoMask;
map = xkb->map;
if (what & XkbKeyTypesMask) {
int i;
struct xkb_key_type * type;
for (i = 0, type = map->types; i < map->num_types && type; i++, type++) {
free(type->map);
type->map = NULL;
free(type->preserve);
type->preserve = NULL;
type->map_count = 0;
free(type->level_names);
type->level_names = NULL;
}
free(map->types);
map->num_types = map->size_types = 0;
map->types = NULL;
}
if (what & XkbKeySymsMask) {
free(map->key_sym_map);
map->key_sym_map = NULL;
free(map->syms);
map->size_syms = map->num_syms = 0;
map->syms = NULL;
}
if (what & XkbModifierMapMask) {
free(map->modmap);
map->modmap = NULL;
}
if (freeMap) {
free(xkb->map);
xkb->map = NULL;
}
}
void
XkbcFreeServerMap(struct xkb_desc * xkb, unsigned what, Bool freeMap)
XkbcFreeServerMap(struct xkb_desc * xkb)
{
struct xkb_server_map * map;
if (!xkb || !xkb->server)
return;
if (freeMap)
what = XkbAllServerInfoMask;
map = xkb->server;
if (what & XkbExplicitComponentsMask) {
free(map->explicit);
map->explicit = NULL;
}
if (what & XkbKeyActionsMask) {
free(map->key_acts);
map->key_acts = NULL;
free(map->acts);
map->num_acts = map->size_acts = 0;
map->acts = NULL;
}
if (what & XkbKeyBehaviorsMask) {
free(map->behaviors);
map->behaviors = NULL;
}
if (what & XkbVirtualModMapMask) {
free(map->vmodmap);
map->vmodmap = NULL;
}
if (freeMap) {
free(xkb->server);
xkb->server = NULL;
}
}

10
src/maprules.c
View File

@ -979,7 +979,7 @@ XkbRF_ClearVarDescriptions(XkbRF_DescribeVarsPtr var)
}
void
XkbcRF_Free(XkbRF_RulesPtr rules,Bool freeRules)
XkbcRF_Free(XkbRF_RulesPtr rules)
{
int i;
XkbRF_RulePtr rule;
@ -996,8 +996,6 @@ XkbcRF_Free(XkbRF_RulesPtr rules,Bool freeRules)
XkbRF_ClearVarDescriptions(&rules->extra[i]);
}
free(rules->extra);
rules->num_extra= rules->sz_extra= 0;
rules->extra= NULL;
}
for (i=0, rule = rules->rules; i < rules->num_rules && rules; i++, rule++) {
free(rule->model);
@ -1010,20 +1008,14 @@ XkbcRF_Free(XkbRF_RulesPtr rules,Bool freeRules)
free(rule->compat);
free(rule->geometry);
free(rule->keymap);
memset(rule, 0, sizeof(XkbRF_RuleRec));
}
free(rules->rules);
rules->num_rules= rules->sz_rules= 0;
rules->rules= NULL;
for (i=0, group = rules->groups; i < rules->num_groups && group; i++, group++) {
free(group->name);
free(group->words);
}
free(rules->groups);
rules->num_groups= 0;
rules->groups= NULL;
if (freeRules)
free(rules);
}

6
src/xkballoc.h
View File

@ -48,7 +48,7 @@ extern struct xkb_desc *
XkbcAllocKeyboard(void);
extern void
XkbcFreeKeyboard(struct xkb_desc * xkb, unsigned which, Bool freeAll);
XkbcFreeKeyboard(struct xkb_desc * xkb);
/***====================================================================***/
@ -68,9 +68,9 @@ extern union xkb_action *
XkbcResizeKeyActions(struct xkb_desc * xkb, xkb_keycode_t key, int needed);
extern void
XkbcFreeClientMap(struct xkb_desc * xkb, unsigned what, Bool freeMap);
XkbcFreeClientMap(struct xkb_desc * xkb);
extern void
XkbcFreeServerMap(struct xkb_desc * xkb, unsigned what, Bool freeMap);
XkbcFreeServerMap(struct xkb_desc * xkb);
#endif /* _XKBALLOC_H_ */

8
src/xkbcomp/xkbcomp.c
View File

@ -83,7 +83,7 @@ XkbComponentsFromRules(const char *rules, const XkbRF_VarDefsPtr defs)
if (!cached_name || strcmp(rules, cached_name) != 0) {
if (loaded)
XkbcRF_Free(loaded, True);
XkbcRF_Free(loaded);
loaded = NULL;
free(cached_name);
cached_name = NULL;
@ -240,7 +240,7 @@ xkb_compile_keymap_from_components(const struct xkb_component_names * ktcsg)
return xkb;
unwind_xkb:
XkbcFreeKeyboard(xkb, XkbAllComponentsMask, True);
XkbcFreeKeyboard(xkb);
unwind_file:
/* XXX: here's where we would free the XkbFile */
fail:
@ -280,7 +280,7 @@ compile_keymap(XkbFile *file, const char *mapName)
return xkb;
unwind_xkb:
XkbcFreeKeyboard(xkb, XkbAllComponentsMask, True);
XkbcFreeKeyboard(xkb);
unwind_file:
/* XXX: here's where we would free the XkbFile */
@ -328,5 +328,5 @@ xkb_compile_keymap_from_file(FILE *inputFile, const char *mapName)
void
xkb_free_keymap(struct xkb_desc *xkb)
{
XkbcFreeKeyboard(xkb, 0, True);
XkbcFreeKeyboard(xkb);
}

2
src/xkbgeom.h
View File

@ -32,7 +32,7 @@ authorization from the authors.
#include "xkbcommon/xkbcommon.h"
extern void
XkbcFreeGeometry(struct xkb_geometry * geom, unsigned which, Bool freeMap);
XkbcFreeGeometry(struct xkb_desc * xkb);
extern int
XkbcAllocGeomKeyAliases(struct xkb_geometry * geom, int nKeyAliases);

2
src/xkbrules.h
View File

@ -156,6 +156,6 @@ extern Bool
XkbcRF_LoadRules(FILE *file, XkbRF_RulesPtr rules);
extern void
XkbcRF_Free(XkbRF_RulesPtr rules, Bool freeRules);
XkbcRF_Free(XkbRF_RulesPtr rules);
#endif /* _XKBRULES_H_ */