_X_EXPORT extern void
xkb_init_atoms(InternAtomFuncPtr intern, GetAtomValueFuncPtr get_atom_value);
+_X_EXPORT extern uint32_t
+xkb_intern_atom(const char *name);
+
_X_EXPORT extern struct xkb_desc *
xkb_compile_keymap_from_rules(const struct xkb_rule_names *rules);
return ret ? strdup(ret) : NULL;
}
-static uint32_t
-_XkbcMakeAtom(const char *string, unsigned len, Bool makeit)
+uint32_t
+xkb_intern_atom(const char *string)
{
NodePtr *np;
unsigned i;
int comp;
unsigned int fp = 0;
+ unsigned len;
+ int makeit = True;
+
+ if (!string)
+ return None;
+ if (do_intern_atom)
+ return do_intern_atom(string);
+ len = strlen(string);
np = &atomRoot;
for (i = 0; i < (len + 1) / 2; i++) {
fp = fp * 27 + string[i];
else
return None;
}
-
-uint32_t
-XkbcInternAtom(const char *name, Bool onlyIfExists)
-{
- if (!name)
- return None;
- if (do_intern_atom)
- return do_intern_atom(name);
- return _XkbcMakeAtom(name, strlen(name), !onlyIfExists);
-}
constTrue.common.next = NULL;
constTrue.op = ExprIdent;
constTrue.type = TypeBoolean;
- constTrue.value.str = XkbcInternAtom("true", False);
+ constTrue.value.str = xkb_intern_atom("true");
constFalse.common.stmtType = StmtExpr;
constFalse.common.next = NULL;
constFalse.op = ExprIdent;
constFalse.type = TypeBoolean;
- constFalse.value.str = XkbcInternAtom("false", False);
+ constFalse.value.str = xkb_intern_atom("false");
actionsInitialized = 1;
}
return;
{
if (XkbcAllocNames(xkb, XkbCompatNameMask, 0, 0) == Success)
xkb->names->compat =
- XkbcInternAtom(info.name, False);
- else
+ xkb_intern_atom(info.name);
+ else
{
WSGO("Couldn't allocate space for compat name\n");
ACTION("Name \"%s\" (from %s) NOT assigned\n",
{
*si = info->dfltSection;
si->defs.defined &= ~_GS_Default;
- si->name = XkbcInternAtom("unknown", False);
+ si->name = xkb_intern_atom("unknown");
si->priority = info->nextPriority++;
if (info->nextPriority > XkbGeomMaxPriority)
info->nextPriority = XkbGeomMaxPriority;
si->defs.merge = info->merge;
si->defs.next = NULL;
si->geometry = info;
- si->name = XkbcInternAtom("default", False);
+ si->name = xkb_intern_atom("default");
InitRowInfo(&si->dfltRow, si, info);
}
return;
{
si->defs.defined &= ~_GS_Default;
- si->name = XkbcInternAtom("default", False);
+ si->name = xkb_intern_atom("default");
si->top = si->left = 0;
si->width = si->height = 0;
si->angle = 0;
info->errorCount++;
return ReportBadType(typeName, field, ddText(di), "string");
}
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
di->defs.defined |= _GD_Shape;
return True;
}
return ReportBadType(typeName, field, ddText(di), "string");
}
di->defs.defined |= def;
- *pField.str = XkbcInternAtom(tmp.str, False);
+ *pField.str = xkb_intern_atom(tmp.str);
}
else
{
if (uStrCaseCmp(field, "oncolor") == 0)
{
di->defs.defined |= _GD_Color;
- di->color = XkbcInternAtom(tmp.str, False);
+ di->color = xkb_intern_atom(tmp.str);
}
else if (uStrCaseCmp(field, "offcolor") == 0)
{
di->defs.defined |= _GD_OffColor;
- di->offColor = XkbcInternAtom(tmp.str, False);
+ di->offColor = xkb_intern_atom(tmp.str);
}
else if (uStrCaseCmp(field, "shape") == 0)
{
di->defs.defined |= _GD_Shape;
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
}
return True;
}
info->errorCount++;
return ReportBadType(typeName, field, ddText(di), "string");
}
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
di->defs.defined |= _GD_Shape;
return True;
}
return ReportBadType("doodad", field, ddText(di), "string");
}
di->defs.defined |= _GD_Color;
- di->color = XkbcInternAtom(tmp.str, False);
+ di->color = xkb_intern_atom(tmp.str);
free(tmp.str);
return True;
}
return ReportBadType("key", field, keyText(key), "string");
}
key->defs.defined |= _GK_Shape;
- key->shape = XkbcInternAtom(tmp.str, False);
+ key->shape = xkb_intern_atom(tmp.str);
free(tmp.str);
}
else if ((uStrCaseCmp(field, "color") == 0) ||
return ReportBadType("key", field, keyText(key), "string");
}
key->defs.defined |= _GK_Color;
- key->color = XkbcInternAtom(tmp.str, False);
+ key->color = xkb_intern_atom(tmp.str);
free(tmp.str);
}
else if ((uStrCaseCmp(field, "name") == 0)
ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
else {
- info->baseColor = XkbcInternAtom(tmp.str, False);
+ info->baseColor = xkb_intern_atom(tmp.str);
free(tmp.str);
ret = True;
}
ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
else {
- info->labelColor = XkbcInternAtom(tmp.str, False);
+ info->labelColor = xkb_intern_atom(tmp.str);
free(tmp.str);
ret = True;
}
ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
else {
- *pField = XkbcInternAtom(tmp.str, False);
+ *pField = xkb_intern_atom(tmp.str);
free(tmp.str);
}
free(field.str);
WARN("No color for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
break;
case XkbTextDoodad:
WARN("No color specified for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
if ((di->defs.defined & _GD_FontSpec) != 0)
{
WARN("No font specified for doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_FONT);
}
- di->font = XkbcInternAtom(DFLT_FONT, False);
+ di->font = xkb_intern_atom(DFLT_FONT);
}
if ((di->defs.defined & _GD_FontSlant) == 0)
{
WARN("No font slant for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_SLANT);
}
- di->fontSlant = XkbcInternAtom(DFLT_SLANT, False);
+ di->fontSlant = xkb_intern_atom(DFLT_SLANT);
}
if ((di->defs.defined & _GD_FontWeight) == 0)
{
WARN("No font weight for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_WEIGHT);
}
- di->fontWeight = XkbcInternAtom(DFLT_WEIGHT, False);
+ di->fontWeight = xkb_intern_atom(DFLT_WEIGHT);
}
if ((di->defs.defined & _GD_FontSetWidth) == 0)
{
WARN("No font set width for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_SET_WIDTH);
}
- di->fontSetWidth = XkbcInternAtom(DFLT_SET_WIDTH, False);
+ di->fontSetWidth = xkb_intern_atom(DFLT_SET_WIDTH);
}
if ((di->defs.defined & _GD_FontVariant) == 0)
{
WARN("No font variant for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_VARIANT);
}
- di->fontVariant = XkbcInternAtom(DFLT_VARIANT, False);
+ di->fontVariant = xkb_intern_atom(DFLT_VARIANT);
}
if ((di->defs.defined & _GD_FontEncoding) == 0)
{
WARN("No font encoding for doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_ENCODING);
}
- di->fontEncoding = XkbcInternAtom(DFLT_ENCODING, False);
+ di->fontEncoding = xkb_intern_atom(DFLT_ENCODING);
}
if ((di->defs.defined & _GD_FontSize) == 0)
{
ddText(di));
ACTION("Using green\n");
}
- di->color = XkbcInternAtom("green", False);
+ di->color = xkb_intern_atom("green");
}
if ((di->defs.defined & _GD_OffColor) == 0)
{
ddText(di));
ACTION("Using black\n");
}
- di->offColor = XkbcInternAtom("black", False);
+ di->offColor = xkb_intern_atom("black");
}
break;
case XkbLogoDoodad:
WARN("No color for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
break;
default:
geom->height_mm = info.heightMM;
if (info.name != NULL)
{
- geom->name = XkbcInternAtom(info.name, False);
+ geom->name = xkb_intern_atom(info.name);
if (XkbcAllocNames(xkb, XkbGeometryNameMask, 0, 0) == Success)
xkb->names->geometry = geom->name;
}
XkbcAddGeomColor(geom, "white", geom->num_colors);
if (info.baseColor == None)
- info.baseColor = XkbcInternAtom("white", False);
+ info.baseColor = xkb_intern_atom("white");
if (info.labelColor == None)
- info.labelColor = XkbcInternAtom("black", False);
+ info.labelColor = xkb_intern_atom("black");
geom->base_color =
XkbcAddGeomColor(geom, XkbcAtomText(info.baseColor),
geom->num_colors);
void
ClearIndicatorMapInfo(LEDInfo * info)
{
- info->name = XkbcInternAtom("default", False);
+ info->name = xkb_intern_atom("default");
info->indicator = _LED_NotBound;
info->flags = info->which_mods = info->real_mods = 0;
info->vmods = 0;
info->errorCount++;
return ReportBadType("indicator", "name", buf, "string");
}
- ii.name = XkbcInternAtom(tmp.str, False);
+ ii.name = xkb_intern_atom(tmp.str);
free(tmp.str);
ii.virtual = def->virtual;
if (!AddIndicatorName(info, &ii))
== Success)
{
register int i;
- xkb->names->keycodes = XkbcInternAtom(info.name, False);
+ xkb->names->keycodes = xkb_intern_atom(info.name);
for (i = info.computedMin; i <= info.computedMax; i++)
{
LongToKeyName(info.names[i], xkb->names->keys[i].name);
static void
InitKeyTypesInfo(KeyTypesInfo * info, struct xkb_desc * xkb, KeyTypesInfo * from)
{
- tok_ONE_LEVEL = XkbcInternAtom("ONE_LEVEL", False);
- tok_TWO_LEVEL = XkbcInternAtom("TWO_LEVEL", False);
- tok_ALPHABETIC = XkbcInternAtom("ALPHABETIC", False);
- tok_KEYPAD = XkbcInternAtom("KEYPAD", False);
+ tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
+ tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
+ tok_ALPHABETIC = xkb_intern_atom("ALPHABETIC");
+ tok_KEYPAD = xkb_intern_atom("KEYPAD");
info->name = strdup("default");
info->errorCount = 0;
info->stdPresent = 0;
ACTION("Ignoring illegal level name definition\n");
return False;
}
- level_name = XkbcInternAtom(rtrn.str, False);
+ level_name = xkb_intern_atom(rtrn.str);
free(rtrn.str);
return AddLevelName(type, level, level_name, True, True);
}
if (info.name != NULL)
{
if (XkbcAllocNames(xkb, XkbTypesNameMask, 0, 0) == Success)
- xkb->names->types = XkbcInternAtom(info.name, False);
+ xkb->names->types = xkb_intern_atom(info.name);
else
{
WSGO("Couldn't allocate space for types name\n");
{
register int i;
- tok_ONE_LEVEL = XkbcInternAtom("ONE_LEVEL", False);
- tok_TWO_LEVEL = XkbcInternAtom("TWO_LEVEL", False);
- tok_KEYPAD = XkbcInternAtom("KEYPAD", False);
+ tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
+ tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
+ tok_KEYPAD = xkb_intern_atom("KEYPAD");
info->name = NULL;
info->explicit_group = 0;
info->errorCount = 0;
}
if (arrayNdx == NULL)
{
- key->dfltType = XkbcInternAtom(tmp.str, False);
+ key->dfltType = xkb_intern_atom(tmp.str);
key->defs.defined |= _Key_Type_Dflt;
}
else if (!ExprResolveInteger(arrayNdx, &ndx, SimpleLookup,
}
else
{
- key->types[ndx.uval - 1] = XkbcInternAtom(tmp.str, False);
+ key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
key->typesDefined |= (1 << (ndx.uval - 1));
}
free(tmp.str);
return False;
}
info->groupNames[tmp.uval - 1 + info->explicit_group] =
- XkbcInternAtom(name.str, False);
+ xkb_intern_atom(name.str);
return True;
}
*autoType = False;
if ((width == 1) || (width == 0))
{
- *typeNameRtrn = XkbcInternAtom("ONE_LEVEL", False);
+ *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
*autoType = True;
}
else if (width == 2)
{
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
{
- *typeNameRtrn = XkbcInternAtom("ALPHABETIC", False);
+ *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
}
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
{
- *typeNameRtrn = XkbcInternAtom("KEYPAD", False);
+ *typeNameRtrn = xkb_intern_atom("KEYPAD");
*autoType = True;
}
else
{
- *typeNameRtrn = XkbcInternAtom("TWO_LEVEL", False);
+ *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
*autoType = True;
}
}
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
*typeNameRtrn =
- XkbcInternAtom("FOUR_LEVEL_ALPHABETIC", False);
+ xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
else
- *typeNameRtrn = XkbcInternAtom("FOUR_LEVEL_SEMIALPHABETIC",
- False);
+ *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
- *typeNameRtrn = XkbcInternAtom("FOUR_LEVEL_KEYPAD", False);
+ *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
else
- *typeNameRtrn = XkbcInternAtom("FOUR_LEVEL", False);
+ *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
/* XXX: why not set autoType here? */
}
return ((width >= 0) && (width <= 4));
}
/* now copy info into xkb. */
- xkb->names->symbols = XkbcInternAtom(info.name, False);
+ xkb->names->symbols = xkb_intern_atom(info.name);
if (info.aliases)
ApplyAliases(xkb, False, &info.aliases);
for (i = 0; i < XkbNumKbdGroups; i++)
uint32_t name;
ExprResult rtrn;
- name = XkbcInternAtom("NumLock", False);
+ name = xkb_intern_atom("NumLock");
if ((xkb) && LookupVModIndex((char *) xkb, None, name, TypeInt, &rtrn))
{
return rtrn.ival;
;
Element : ACTION_TOK
- { $$= XkbcInternAtom("action",False); }
+ { $$= xkb_intern_atom("action"); }
| INTERPRET
- { $$= XkbcInternAtom("interpret",False); }
+ { $$= xkb_intern_atom("interpret"); }
| TYPE
- { $$= XkbcInternAtom("type",False); }
+ { $$= xkb_intern_atom("type"); }
| KEY
- { $$= XkbcInternAtom("key",False); }
+ { $$= xkb_intern_atom("key"); }
| GROUP
- { $$= XkbcInternAtom("group",False); }
+ { $$= xkb_intern_atom("group"); }
| MODIFIER_MAP
- {$$=XkbcInternAtom("modifier_map",False);}
+ {$$= xkb_intern_atom("modifier_map");}
| INDICATOR
- { $$= XkbcInternAtom("indicator",False); }
+ { $$= xkb_intern_atom("indicator"); }
| SHAPE
- { $$= XkbcInternAtom("shape",False); }
+ { $$= xkb_intern_atom("shape"); }
| ROW
- { $$= XkbcInternAtom("row",False); }
+ { $$= xkb_intern_atom("row"); }
| SECTION
- { $$= XkbcInternAtom("section",False); }
+ { $$= xkb_intern_atom("section"); }
| TEXT
- { $$= XkbcInternAtom("text",False); }
+ { $$= xkb_intern_atom("text"); }
;
OptMergeMode : MergeMode { $$= $1; }
KeyName : KEYNAME { $$= strdup(scanBuf); }
;
-Ident : IDENT { $$= XkbcInternAtom(scanBuf,False); }
- | DEFAULT { $$= XkbcInternAtom("default",False); }
+Ident : IDENT { $$= xkb_intern_atom(scanBuf); }
+ | DEFAULT { $$= xkb_intern_atom("default"); }
;
-String : STRING { $$= XkbcInternAtom(scanBuf,False); }
+String : STRING { $$= xkb_intern_atom(scanBuf); }
;
OptMapName : MapName { $$= $1; }
extern char *
XkbcAtomGetString(uint32_t atom);
-extern uint32_t
-XkbcInternAtom(const char *name, Bool onlyIfExists);
-
/***====================================================================***/
extern const char *