#define _XkbTypedCalloc(n,t) ((t *)calloc((n),sizeof(t)))
#define _XkbTypedRealloc(o,n,t) \
((o)?(t *)realloc((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) memset(&(a)[f], 0, ((l) - (f) + 1) * sizeof(t))
#define _XkbDupString(s) ((s) ? strdup(s) : NULL)
#define _XkbStrCaseCmp strcasecmp
}
compat->size_si = nSI;
compat->num_si = 0;
- bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(struct xkb_mods));
+ memset(&compat->groups[0], 0, XkbNumKbdGroups * sizeof(struct xkb_mods));
xkb->compat = compat;
return Success;
which = XkbAllCompatMask;
if (which & XkbGroupCompatMask)
- bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(struct xkb_mods));
+ memset(&compat->groups[0], 0,
+ XkbNumKbdGroups * sizeof(struct xkb_mods));
if (which & XkbSymInterpMask) {
free(compat->sym_interpret);
if (*num > 0) {
char *tmp = *old;
- bzero(&tmp[sz_elem * (*num)], num_new * sz_elem);
+ memset(&tmp[sz_elem * (*num)], 0, num_new * sz_elem);
}
return Success;
return NULL;
}
outline= &shape->outlines[shape->num_outlines];
- bzero(outline,sizeof(struct xkb_outline));
+ memset(outline, 0, sizeof(struct xkb_outline));
if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success))
return NULL;
shape->num_outlines++;
(_XkbAllocShapes(geom,1)!=Success))
return NULL;
shape= &geom->shapes[geom->num_shapes];
- bzero(shape,sizeof(struct xkb_shape));
+ memset(shape, 0, sizeof(struct xkb_shape));
if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success))
return NULL;
shape->name= name;
if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success))
return NULL;
key= &row->keys[row->num_keys++];
- bzero(key,sizeof(struct xkb_key));
+ memset(key, 0, sizeof(struct xkb_key));
return key;
}
(_XkbAllocRows(section,1)!=Success))
return NULL;
row= §ion->rows[section->num_rows];
- bzero(row,sizeof(struct xkb_row));
+ memset(row, 0, sizeof(struct xkb_row));
if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
return NULL;
section->num_rows++;
return NULL;
doodad= &geom->doodads[geom->num_doodads++];
}
- bzero(doodad,sizeof(union xkb_doodad));
+ memset(doodad, 0, sizeof(union xkb_doodad));
doodad->any.name= name;
return doodad;
}
(_XkbAllocOverlayRows(overlay,1)!=Success))
return NULL;
row= &overlay->rows[overlay->num_rows];
- bzero(row,sizeof(struct xkb_overlay_row));
+ memset(row, 0, sizeof(struct xkb_overlay_row));
if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
return NULL;
row->row_under= row_under;
return False;
bounds = &row->bounds;
- bzero(bounds, sizeof(struct xkb_bounds));
+ memset(bounds, 0, sizeof(struct xkb_bounds));
for (key = row->keys, pos = k = 0; k < row->num_keys; k++, key++) {
sbounds = &XkbKeyShape(geom, key)->bounds;
return False;
bounds = §ion->bounds;
- bzero(bounds, sizeof(struct xkb_bounds));
+ memset(bounds, 0, sizeof(struct xkb_bounds));
for (i = 0, row = section->rows; i < section->num_rows; i++, row++) {
if (!XkbcComputeRowBounds(geom, section, row))
}
map->size_types = nTotalTypes;
- bzero(&map->types[map->num_types],
- (map->size_types - map->num_types) * sizeof(struct xkb_key_type));
+ memset(&map->types[map->num_types], 0,
+ (map->size_types - map->num_types) * sizeof(struct xkb_key_type));
}
}
}
map->size_acts = need;
- bzero(&map->acts[map->num_acts],
- (map->size_acts - map->num_acts) * sizeof(union xkb_action));
+ memset(&map->acts[map->num_acts], 0,
+ (map->size_acts - map->num_acts) * sizeof(union xkb_action));
}
if (!map->key_acts) {
XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(uint32_t));
if ((needed - nOldSyms) > 0)
- bzero(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],
- (needed - nOldSyms) * sizeof(uint32_t));
+ memset(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],
+ 0, (needed - nOldSyms) * sizeof(uint32_t));
xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
xkb->map->num_syms += needed;
memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
nCopy * sizeof(uint32_t));
if (nKeySyms > nCopy)
- bzero(&newSyms[nSyms+nCopy], (nKeySyms - nCopy) * sizeof(uint32_t));
+ memset(&newSyms[nSyms + nCopy], 0,
+ (nKeySyms - nCopy) * sizeof(uint32_t));
xkb->map->key_sym_map[i].offset = nSyms;
nSyms += nKeySyms;
memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),
nCopy * sizeof(union xkb_action));
if (nCopy < nKeyActs)
- bzero(&newActs[nActs + nCopy],
- (nKeyActs - nCopy) * sizeof(union xkb_action));
+ memset(&newActs[nActs + nCopy], 0,
+ (nKeyActs - nCopy) * sizeof(union xkb_action));
xkb->server->key_acts[i] = nActs;
nActs += nKeyActs;
l_ndx_present = v_ndx_present = present= 0;
str= &line->line[1];
len = remap->number;
- bzero((char *)remap,sizeof(RemapSpec));
+ memset(remap, 0, sizeof(RemapSpec));
remap->number = len;
while ((tok=_XStrtok(str," ",strtok_buf))!=NULL) {
#ifdef DEBUG
PR_DEBUG("Illegal line of data ignored\n");
return False;
}
- bzero((char *)&tmp,sizeof(FileSpec));
+ memset(&tmp, 0, sizeof(FileSpec));
str= line->line;
for (nread= 0;(tok=_XStrtok(str," ",strtok_buf))!=NULL;nread++) {
str= NULL;
static Bool
MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
{
- bzero((char *)mdefs,sizeof(XkbRF_MultiDefsRec));
+ memset(mdefs, 0, sizeof(XkbRF_MultiDefsRec));
mdefs->model = defs->model;
mdefs->options = _XkbDupString(defs->options);
if (mdefs->options) squeeze_spaces(mdefs->options);
MakeMultiDefs(&mdefs, defs);
- bzero((char *)names,sizeof(struct xkb_component_names));
+ memset(names, 0, sizeof(struct xkb_component_names));
XkbRF_ClearPartialMatches(rules);
XkbRF_CheckApplyRules(rules, &mdefs, names, XkbRF_Normal);
XkbRF_ApplyPartialMatches(rules, names);
#endif
return NULL;
}
- bzero((char *)&rules->rules[rules->num_rules],sizeof(XkbRF_RuleRec));
+ memset(&rules->rules[rules->num_rules], 0, sizeof(XkbRF_RuleRec));
return &rules->rules[rules->num_rules++];
}
return NULL;
}
- bzero((char *)&rules->groups[rules->num_groups],sizeof(XkbRF_GroupRec));
+ memset(&rules->groups[rules->num_groups], 0, sizeof(XkbRF_GroupRec));
return &rules->groups[rules->num_groups++];
}
if (!(rules && file))
return False;
- bzero((char *)&remap,sizeof(RemapSpec));
- bzero((char *)&tgroup,sizeof(XkbRF_GroupRec));
+ memset(&remap, 0, sizeof(RemapSpec));
+ memset(&tgroup, 0, sizeof(XkbRF_GroupRec));
InitInputLine(&line);
while (GetInputLine(file,&line,True)) {
if (CheckLine(&line,&remap,&trule,&tgroup)) {
if (tgroup.number) {
if ((group= XkbcRF_AddGroup(rules))!=NULL) {
*group= tgroup;
- bzero((char *)&tgroup,sizeof(XkbRF_GroupRec));
+ memset(&tgroup, 0, sizeof(XkbRF_GroupRec));
}
} else {
if ((rule= XkbcRF_AddRule(rules))!=NULL) {
*rule= trule;
- bzero((char *)&trule,sizeof(XkbRF_RuleRec));
+ memset(&trule, 0, sizeof(XkbRF_RuleRec));
}
}
}
free(rule->compat);
free(rule->geometry);
free(rule->keymap);
- bzero((char *)rule,sizeof(XkbRF_RuleRec));
+ memset(rule, 0, sizeof(XkbRF_RuleRec));
}
free(rules->rules);
rules->num_rules= rules->sz_rules= 0;
type->mods.mask = type->mods.real_mods;
if (map_rtrn) {
- bzero(map_rtrn, type->mods.mask + 1);
+ memset(map_rtrn, 0, type->mods.mask + 1);
if (entry && entry->active)
for (i = 0; i < type->map_count; i++)
map_rtrn[type->map[i].mods.mask] = type->map[i].level;
{
if (!actionsInitialized)
{
- bzero((char *) &constTrue, sizeof(constTrue));
- bzero((char *) &constFalse, sizeof(constFalse));
+ memset(&constTrue, 0, sizeof(constTrue));
+ memset(&constFalse, 0, sizeof(constFalse));
constTrue.common.stmtType = StmtExpr;
constTrue.common.next = NULL;
constTrue.op = ExprIdent;
InitAliasInfo(AliasInfo * info,
unsigned merge, unsigned file_id, char *alias, char *real)
{
- bzero(info, sizeof(AliasInfo));
+ memset(info, 0, sizeof(AliasInfo));
info->def.merge = merge;
info->def.fileID = file_id;
strncpy(info->alias, alias, XkbKeyNameLength);
*merge = NULL;
return True;
}
- bzero((char *) &def, sizeof(KeyAliasDef));
+ memset(&def, 0, sizeof(KeyAliasDef));
for (tmp = *merge; tmp != NULL; tmp = (AliasInfo *) tmp->def.next)
{
if (how_merge == MergeDefault)
if (!xkb->geom)
{
struct xkb_geometry_sizes sizes;
- bzero((char *) &sizes, sizeof(struct xkb_geometry_sizes));
+ memset(&sizes, 0, sizeof(struct xkb_geometry_sizes));
sizes.which = XkbGeomKeyAliasesMask;
sizes.num_key_aliases = nOld + nNew;
status = XkbcAllocGeometry(xkb, &sizes);
info->ledDflt.defs.fileID = info->fileID;
info->ledDflt.defs.defined = 0;
info->ledDflt.defs.merge = MergeOverride;
- bzero((char *) &info->groupCompat[0],
- XkbNumKbdGroups * sizeof(GroupCompatInfo));
+ memset(&info->groupCompat[0], 0,
+ XkbNumKbdGroups * sizeof(GroupCompatInfo));
info->leds = NULL;
InitVModInfo(&info->vmods, xkb);
}
ClearIndicatorMapInfo(&info->ledDflt);
info->nInterps = 0;
info->interps = (SymInterpInfo *) ClearCommonInfo(&info->interps->defs);
- bzero((char *) &info->groupCompat[0],
- XkbNumKbdGroups * sizeof(GroupCompatInfo));
+ memset(&info->groupCompat[0], 0,
+ XkbNumKbdGroups * sizeof(GroupCompatInfo));
info->leds = (LEDInfo *) ClearCommonInfo(&info->leds->defs);
/* 3/30/94 (ef) -- XXX! Should free action info here */
ClearVModInfo(&info->vmods, xkb);
si = uTypedAlloc(SymInterpInfo);
if (si)
{
- bzero((char *) si, sizeof(SymInterpInfo));
+ memset(si, 0, sizeof(SymInterpInfo));
info->interps =
(SymInterpInfo *) AddCommonInfo(&info->interps->defs,
(CommonInfo *) si);
{
haveSelf = True;
included = *info;
- bzero(info, sizeof(CompatInfo));
+ memset(info, 0, sizeof(CompatInfo));
}
else if (ProcessIncludeFile(stmt, XkmCompatMapIndex, &rtrn, &newMerge))
{
}
else
{
- bzero(key, sizeof(KeyInfo));
+ memset(key, 0, sizeof(KeyInfo));
strcpy(key->name, "default");
key->defs.defined = _GK_Default;
key->defs.fileID = info->fileID;
}
else
{
- bzero(row, sizeof(RowInfo));
+ memset(row, 0, sizeof(RowInfo));
row->defs.defined = _GR_Default;
row->defs.fileID = info->fileID;
row->defs.merge = info->merge;
}
else
{
- bzero(di, sizeof(DoodadInfo));
+ memset(di, 0, sizeof(DoodadInfo));
di->defs.fileID = info->fileID;
di->type = type;
}
CommonInfo defs;
defs = di->defs;
- bzero(di, sizeof(DoodadInfo));
+ memset(di, 0, sizeof(DoodadInfo));
di->defs = defs;
di->defs.defined = 0;
}
}
else
{
- bzero(si, sizeof(SectionInfo));
+ memset(si, 0, sizeof(SectionInfo));
si->defs.fileID = info->fileID;
si->defs.merge = info->merge;
si->defs.next = NULL;
static void
InitGeometryInfo(GeometryInfo * info, unsigned fileID, unsigned merge)
{
- bzero(info, sizeof(GeometryInfo));
+ memset(info, 0, sizeof(GeometryInfo));
info->fileID = fileID;
info->merge = merge;
InitSectionInfo(&info->dfltSection, info);
pi = uTypedAlloc(PropertyInfo);
if (pi)
{
- bzero((char *) pi, sizeof(PropertyInfo));
+ memset(pi, 0, sizeof(PropertyInfo));
info->props = (PropertyInfo *) AddCommonInfo(&info->props->defs,
(CommonInfo *) pi);
info->nProps++;
si = uTypedAlloc(ShapeInfo);
if (si)
{
- bzero((char *) si, sizeof(ShapeInfo));
+ memset(si, 0, sizeof(ShapeInfo));
info->shapes = (ShapeInfo *) AddCommonInfo(&info->shapes->defs,
(CommonInfo *) si);
info->nShapes++;
{
haveSelf = True;
included = *info;
- bzero(info, sizeof(GeometryInfo));
+ memset(info, 0, sizeof(GeometryInfo));
}
else if (ProcessIncludeFile(stmt, XkmGeometryIndex, &rtrn, &newMerge))
{
return ReportBadType("key", field, keyText(key), "key name");
}
key->defs.defined |= _GK_Name;
- bzero(key->name, XkbKeyNameLength + 1);
+ memset(key->name, 0, XkbKeyNameLength + 1);
strncpy(key->name, tmp.keyName.name, XkbKeyNameLength);
}
else
if (def->merge != MergeDefault)
merge = def->merge;
- bzero(&si, sizeof(ShapeInfo));
+ memset(&si, 0, sizeof(ShapeInfo));
si.defs.merge = merge;
si.name = def->name;
si.dfltCornerRadius = info->dfltCornerRadius;
ACTION("Overlay ignored\n");
return True;
}
- bzero(&ol, sizeof(OverlayInfo));
+ memset(&ol, 0, sizeof(OverlayInfo));
ol.name = def->name;
for (keyDef = def->keys; keyDef;
keyDef = (OverlayKeyDef *) keyDef->common.next)
ACTION("Section not compiled\n");
return False;
}
- bzero(key.name, XkbKeyNameLength + 1);
+ memset(key.name, 0, XkbKeyNameLength + 1);
strncpy(key.name, keyDef->name, XkbKeyNameLength);
key.defs.defined |= _GK_Name;
}
return False;
}
/* now figure out how many rows are defined for the overlay */
- bzero(rowSize, sizeof(short) * 256);
+ memset(rowSize, 0, sizeof(short) * 256);
for (k = 0; k < 256; k++)
{
rowMap[k] = -1;
{
row = &ol->rows[ki->overlayRow];
key = &row->keys[row->num_keys++];
- bzero(key, sizeof(struct xkb_overlay_key));
+ memset(key, 0, sizeof(struct xkb_overlay_key));
strncpy(key->over.name, ki->over, XkbKeyNameLength);
strncpy(key->under.name, ki->under, XkbKeyNameLength);
}
{
struct xkb_geometry * geom;
struct xkb_geometry_sizes sizes;
- bzero(&sizes, sizeof(sizes));
+ memset(&sizes, 0, sizeof(sizes));
sizes.which = XkbGeomAllMask;
sizes.num_properties = info.nProps;
sizes.num_colors = 8;
{
haveSelf = True;
included = *info;
- bzero(info, sizeof(KeyNamesInfo));
+ memset(info, 0, sizeof(KeyNamesInfo));
}
else if (stmt->file && strcmp(stmt->file, "computed") == 0)
{
char *mainName;
LEDInfo *unbound = NULL;
- bzero(sections, MAX_SECTIONS * sizeof(XkbFile *));
+ memset(sections, 0, MAX_SECTIONS * sizeof(XkbFile *));
mainType = file->type;
mainName = file->name;
switch (mainType)
type = uTypedAlloc(KeyTypeInfo);
if (type != NULL)
{
- bzero(type, sizeof(KeyTypeInfo));
+ memset(type, 0, sizeof(KeyTypeInfo));
type->defs.fileID = info->fileID;
info->types = (KeyTypeInfo *) AddCommonInfo(&info->types->defs,
(CommonInfo *) type);
{
haveSelf = True;
included = *info;
- bzero(info, sizeof(KeyTypesInfo));
+ memset(info, 0, sizeof(KeyTypesInfo));
}
else if (ProcessIncludeFile(stmt, XkmTypesIndex, &rtrn, &newMerge))
{
def->common.stmtType = StmtSymbolsDef;
def->common.next = NULL;
def->merge = MergeDefault;
- bzero(def->keyName, 5);
+ memset(def->keyName, 0, 5);
strncpy(def->keyName, keyName, 4);
def->symbols = symbols;
}
shape = uTypedAlloc(ShapeDef);
if (shape != NULL)
{
- bzero(shape, sizeof(ShapeDef));
+ memset(shape, 0, sizeof(ShapeDef));
shape->common.stmtType = StmtShapeDef;
shape->common.next = NULL;
shape->merge = MergeDefault;
outline = uTypedAlloc(OutlineDef);
if (outline != NULL)
{
- bzero(outline, sizeof(OutlineDef));
+ memset(outline, 0, sizeof(OutlineDef));
outline->common.stmtType = StmtOutlineDef;
outline->common.next = NULL;
outline->field = field;
key = uTypedAlloc(KeyDef);
if (key != NULL)
{
- bzero(key, sizeof(KeyDef));
+ memset(key, 0, sizeof(KeyDef));
key->common.stmtType = StmtKeyDef;
key->common.next = NULL;
if (name)
row = uTypedAlloc(RowDef);
if (row != NULL)
{
- bzero(row, sizeof(RowDef));
+ memset(row, 0, sizeof(RowDef));
row->common.stmtType = StmtRowDef;
row->common.next = NULL;
row->nKeys = 0;
section = uTypedAlloc(SectionDef);
if (section != NULL)
{
- bzero(section, sizeof(SectionDef));
+ memset(section, 0, sizeof(SectionDef));
section->common.stmtType = StmtSectionDef;
section->common.next = NULL;
section->name = name;
key = uTypedAlloc(OverlayKeyDef);
if (key != NULL)
{
- bzero(key, sizeof(OverlayKeyDef));
+ memset(key, 0, sizeof(OverlayKeyDef));
key->common.stmtType = StmtOverlayKeyDef;
strncpy(key->over, over, XkbKeyNameLength);
strncpy(key->under, under, XkbKeyNameLength);
ol = uTypedAlloc(OverlayDef);
if (ol != NULL)
{
- bzero(ol, sizeof(OverlayDef));
+ memset(ol, 0, sizeof(OverlayDef));
ol->common.stmtType = StmtOverlayDef;
ol->name = name;
ol->keys = keys;
doodad = uTypedAlloc(DoodadDef);
if (doodad != NULL)
{
- bzero(doodad, sizeof(DoodadDef));
+ memset(doodad, 0, sizeof(DoodadDef));
doodad->common.stmtType = StmtDoodadDef;
doodad->common.next = NULL;
doodad->type = type;
if (file)
{
XkbcEnsureSafeMapName(name);
- bzero(file, sizeof(XkbFile));
+ memset(file, 0, sizeof(XkbFile));
file->type = type;
file->topName = _XkbDupString(name);
file->name = name;
ClearCommonInfo(&info->modMap->defs);
if (info->aliases)
ClearAliases(&info->aliases);
- bzero((char *) info, sizeof(SymbolsInfo));
+ memset(info, 0, sizeof(SymbolsInfo));
}
static Bool
}
}
*into = *from;
- bzero(from, sizeof(KeyInfo));
+ memset(from, 0, sizeof(KeyInfo));
return True;
}
report = ((warningLevel > 9) ||
{
haveSelf = True;
included = *info;
- bzero(info, sizeof(SymbolsInfo));
+ memset(info, 0, sizeof(SymbolsInfo));
}
else if (ProcessIncludeFile(stmt, XkmSymbolsIndex, &rtrn, &newMerge))
{
rtrn = (char *) realloc((char *) old, nNew * itemSize);
if ((rtrn) && (nNew > nOld))
{
- bzero(&rtrn[nOld * itemSize], (nNew - nOld) * itemSize);
+ memset(&rtrn[nOld * itemSize], 0, (nNew - nOld) * itemSize);
}
}
return (void *) rtrn;