Remove field reference lookup support

None of the lookup functions anyone ever used supported field
references, so don't pretend we do in the API.

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c
index 0297907..95afcde 100644 (file)
--- a/src/xkbcomp/action.c
+++ b/src/xkbcomp/action.c
@@ -795,7 +795,7 @@ HandleISOLock(struct xkb_desc * xkb,
     case F_Affect:
         if (array_ndx != NULL)
             return ReportActionNotArray(action->type, field);
-        if (!ExprResolveMask(value, &rtrn, SimpleLookup, (char *) isoNames))
+        if (!ExprResolveMask(value, &rtrn, isoNames))
             return ReportMismatch(action->type, field, "keyboard component");
         act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask;
         return True;
@@ -908,8 +908,7 @@ HandleSetLockControls(struct xkb_desc * xkb,
     {
         if (array_ndx != NULL)
             return ReportActionNotArray(action->type, field);
-        if (!ExprResolveMask
-            (value, &rtrn, SimpleLookup, (char *) ctrlNames))
+        if (!ExprResolveMask(value, &rtrn, ctrlNames))
             return ReportMismatch(action->type, field, "controls mask");
         act->ctrls = rtrn.uval;
         return True;
@@ -941,7 +940,7 @@ HandleActionMessage(struct xkb_desc * xkb,
     case F_Report:
         if (array_ndx != NULL)
             return ReportActionNotArray(action->type, field);
-        if (!ExprResolveMask(value, &rtrn, SimpleLookup, (char *) evNames))
+        if (!ExprResolveMask(value, &rtrn, evNames))
             return ReportMismatch(action->type, field, "key event mask");
         act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
         act->flags =

diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c
index 5b33ff8..3915988 100644 (file)
--- a/src/xkbcomp/expr.c
+++ b/src/xkbcomp/expr.c
@@ -156,14 +156,13 @@ ExprResolveLhs(ExprDef * expr,
 }
 
 Bool
-SimpleLookup(char * priv,
-             uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+SimpleLookup(char * priv, uint32_t field, unsigned type,
+             ExprResult * val_rtrn)
 {
     LookupEntry *entry;
     const char *str;
 
-    if ((priv == NULL) ||
-        (field == None) || (elem != None) ||
+    if ((priv == NULL) || (field == None) ||
         ((type != TypeInt) && (type != TypeFloat)))
     {
         return False;
@@ -184,13 +183,12 @@ SimpleLookup(char * priv,
 }
 
 Bool
-RadioLookup(char * priv,
-            uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+RadioLookup(char * priv, uint32_t field, unsigned type, ExprResult * val_rtrn)
 {
     const char *str;
     int rg;
 
-    if ((field == None) || (elem != None) || (type != TypeInt))
+    if ((field == None) || (type != TypeInt))
         return False;
     str = XkbcAtomText(field);
     if (str)
@@ -225,21 +223,20 @@ static LookupEntry modIndexNames[] = {
 };
 
 int
-LookupModIndex(char * priv,
-               uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+LookupModIndex(char * priv, uint32_t field, unsigned type,
+               ExprResult * val_rtrn)
 {
-    return SimpleLookup((char *) modIndexNames, elem, field, type,
-                        val_rtrn);
+    return SimpleLookup((char *) modIndexNames, field, type, val_rtrn);
 }
 
 static int
-LookupModMask(char * priv,
-              uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+LookupModMask(char * priv, uint32_t field, unsigned type,
+              ExprResult * val_rtrn)
 {
     char *str;
     Bool ret = True;
 
-    if ((elem != None) || (type != TypeInt))
+    if (type != TypeInt)
         return False;
     str = XkbcAtomGetString(field);
     if (str == NULL)
@@ -248,14 +245,13 @@ LookupModMask(char * priv,
         val_rtrn->uval = 0xff;
     else if (uStrCaseCmp(str, "none") == 0)
         val_rtrn->uval = 0;
-    else if (LookupModIndex(priv, elem, field, type, val_rtrn))
+    else if (LookupModIndex(priv, field, type, val_rtrn))
         val_rtrn->uval = (1 << val_rtrn->uval);
     else if (priv != NULL)
     {
         LookupPriv *lpriv = (LookupPriv *) priv;
         if ((lpriv->chain == NULL) ||
-            (!(*lpriv->chain) (lpriv->chainPriv, elem, field, type,
-                               val_rtrn)))
+            (!(*lpriv->chain) (lpriv->chainPriv, field, type, val_rtrn)))
             ret = False;
     }
     else
@@ -265,31 +261,6 @@ LookupModMask(char * priv,
 }
 
 int
-ExprResolveModMask(ExprDef * expr,
-                   ExprResult * val_rtrn)
-{
-    LookupPriv priv;
-
-    priv.priv = NULL;
-    priv.chain = NULL;
-    priv.chainPriv = NULL;
-    return ExprResolveMask(expr, val_rtrn, LookupModMask, (char *) & priv);
-}
-
-int
-ExprResolveVModMask(ExprDef * expr,
-                    ExprResult * val_rtrn,
-                    struct xkb_desc *xkb)
-{
-    LookupPriv priv;
-
-    priv.priv = NULL;
-    priv.chain = LookupVModMask;
-    priv.chainPriv = (char *) xkb;
-    return ExprResolveMask(expr, val_rtrn, LookupModMask, (char *) & priv);
-}
-
-int
 ExprResolveBoolean(ExprDef * expr,
                    ExprResult * val_rtrn)
 {
@@ -410,7 +381,7 @@ ExprResolveFloat(ExprDef * expr,
         ERROR("Numeric default \"%s.%s\" unknown\n",
               XkbcAtomText(expr->value.field.element),
               XkbcAtomText(expr->value.field.field));
-        return ok;
+        return False;
     case OpAdd:
     case OpSubtract:
     case OpMultiply:
@@ -588,25 +559,17 @@ ExprResolveIntegerLookup(ExprDef * expr,
     case ExprIdent:
         if (lookup)
         {
-            ok = (*lookup) (lookupPriv,
-                            None, expr->value.str, TypeInt, val_rtrn);
+            ok = (*lookup) (lookupPriv, expr->value.str, TypeInt, val_rtrn);
         }
         if (!ok)
             ERROR("Identifier \"%s\" of type int is unknown\n",
                    XkbcAtomText(expr->value.str));
         return ok;
     case ExprFieldRef:
-        if (lookup)
-        {
-            ok = (*lookup) (lookupPriv,
-                            expr->value.field.element,
-                            expr->value.field.field, TypeInt, val_rtrn);
-        }
-        if (!ok)
-            ERROR("Default \"%s.%s\" of type int is unknown\n",
-                   XkbcAtomText(expr->value.field.element),
-                   XkbcAtomText(expr->value.field.field));
-        return ok;
+        ERROR("Default \"%s.%s\" of type int is unknown\n",
+              XkbcAtomText(expr->value.field.element),
+              XkbcAtomText(expr->value.field.field));
+        return False;
     case OpAdd:
     case OpSubtract:
     case OpMultiply:
@@ -892,8 +855,7 @@ ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, LookupEntry * values)
                exprOpText(expr->op));
         return False;
     }
-    if (!SimpleLookup((char *) values, (uint32_t) None, expr->value.str,
-                      (unsigned) TypeInt, val_rtrn))
+    if (!SimpleLookup((char *) values, expr->value.str, TypeInt, val_rtrn))
     {
         int nOut = 0;
         ERROR("Illegal identifier %s (expected one of: ",
@@ -913,10 +875,11 @@ ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, LookupEntry * values)
     return True;
 }
 
-int
-ExprResolveMask(ExprDef * expr,
-                ExprResult * val_rtrn,
-                IdentLookupFunc lookup, char * lookupPriv)
+static int
+ExprResolveMaskLookup(ExprDef * expr,
+                      ExprResult * val_rtrn,
+                      IdentLookupFunc lookup,
+                      char * lookupPriv)
 {
     int ok = 0;
     ExprResult leftRtrn, rightRtrn;
@@ -936,27 +899,16 @@ ExprResolveMask(ExprDef * expr,
         val_rtrn->ival = expr->value.ival;
         return True;
     case ExprIdent:
-        if (lookup)
-        {
-            ok = (*lookup) (lookupPriv,
-                            None, expr->value.str, TypeInt, val_rtrn);
-        }
+        ok = (*lookup) (lookupPriv, expr->value.str, TypeInt, val_rtrn);
         if (!ok)
             ERROR("Identifier \"%s\" of type int is unknown\n",
                    XkbcAtomText(expr->value.str));
         return ok;
     case ExprFieldRef:
-        if (lookup)
-        {
-            ok = (*lookup) (lookupPriv,
-                            expr->value.field.element,
-                            expr->value.field.field, TypeInt, val_rtrn);
-        }
-        if (!ok)
-            ERROR("Default \"%s.%s\" of type int is unknown\n",
-                   XkbcAtomText(expr->value.field.element),
-                   XkbcAtomText(expr->value.field.field));
-        return ok;
+        ERROR("Default \"%s.%s\" of type int is unknown\n",
+              XkbcAtomText(expr->value.field.element),
+              XkbcAtomText(expr->value.field.field));
+        return False;
     case ExprArrayRef:
         bogus = "array reference";
     case ExprActionDecl:
@@ -971,8 +923,8 @@ ExprResolveMask(ExprDef * expr,
     case OpDivide:
         left = expr->value.binary.left;
         right = expr->value.binary.right;
-        if (ExprResolveMask(left, &leftRtrn, lookup, lookupPriv) &&
-            ExprResolveMask(right, &rightRtrn, lookup, lookupPriv))
+        if (ExprResolveMaskLookup(left, &leftRtrn, lookup, lookupPriv) &&
+            ExprResolveMaskLookup(right, &rightRtrn, lookup, lookupPriv))
         {
             switch (expr->op)
             {
@@ -1021,6 +973,42 @@ ExprResolveMask(ExprDef * expr,
 }
 
 int
+ExprResolveMask(ExprDef * expr,
+                ExprResult * val_rtrn,
+                LookupEntry * values)
+{
+    return ExprResolveMaskLookup(expr, val_rtrn, SimpleLookup,
+                                 (char *) values);
+}
+
+int
+ExprResolveModMask(ExprDef * expr,
+                   ExprResult * val_rtrn)
+{
+    LookupPriv priv;
+
+    priv.priv = NULL;
+    priv.chain = NULL;
+    priv.chainPriv = NULL;
+    return ExprResolveMaskLookup(expr, val_rtrn, LookupModMask,
+                                 (char *) & priv);
+}
+
+int
+ExprResolveVModMask(ExprDef * expr,
+                    ExprResult * val_rtrn,
+                    struct xkb_desc *xkb)
+{
+    LookupPriv priv;
+
+    priv.priv = NULL;
+    priv.chain = LookupVModMask;
+    priv.chainPriv = (char *) xkb;
+    return ExprResolveMaskLookup(expr, val_rtrn, LookupModMask,
+                                 (char *) & priv);
+}
+
+int
 ExprResolveKeySym(ExprDef * expr,
                   ExprResult * val_rtrn)
 {

diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h
index 8a3471c..c10be24 100644 (file)
--- a/src/xkbcomp/expr.h
+++ b/src/xkbcomp/expr.h
@@ -36,7 +36,6 @@ typedef union _ExprResult
 } ExprResult;
 
 typedef Bool(*IdentLookupFunc) (char * /* priv */ ,
-                                uint32_t /* elem */ ,
                                 uint32_t /* field */ ,
                                 unsigned /* type */ ,
                                 ExprResult *    /* val_rtrn */
@@ -73,21 +72,18 @@ extern char *exprOpText(unsigned        /* type */
     );
 
 extern int RadioLookup(char * /* priv */ ,
-                       uint32_t /* elem */ ,
                        uint32_t /* field */ ,
                        unsigned /* type */ ,
                        ExprResult *     /* val_rtrn */
     );
 
 extern int SimpleLookup(char * /* priv */ ,
-                        uint32_t /* elem */ ,
                         uint32_t /* field */ ,
                         unsigned /* type */ ,
                         ExprResult *    /* val_rtrn */
     );
 
 extern int LookupModIndex(char * /* priv */ ,
-                          uint32_t /* elem */ ,
                           uint32_t /* field */ ,
                           unsigned /* type */ ,
                           ExprResult *  /* val_rtrn */
@@ -149,8 +145,7 @@ extern int ExprResolveEnum(ExprDef * /* expr */ ,
 
 extern int ExprResolveMask(ExprDef * /* expr */ ,
                            ExprResult * /* val_rtrn */ ,
-                           IdentLookupFunc /* lookup */ ,
-                           char *     /* lookupPriv */
+                           LookupEntry * /* values */
     );
 
 extern int ExprResolveKeySym(ExprDef * /* expr */ ,

diff --git a/src/xkbcomp/indicators.c b/src/xkbcomp/indicators.c
index d999144..34d6a64 100644 (file)
--- a/src/xkbcomp/indicators.c
+++ b/src/xkbcomp/indicators.c
@@ -244,8 +244,7 @@ SetIndicatorMapField(LEDInfo * led,
     {
         if (arrayNdx != NULL)
             return ReportIndicatorNotArray(led, field);
-        if (!ExprResolveMask
-            (value, &rtrn, SimpleLookup, (char *) groupNames))
+        if (!ExprResolveMask(value, &rtrn, groupNames))
             return ReportIndicatorBadType(led, field, "group mask");
         led->groups = rtrn.uval;
         led->defs.defined |= _LED_Groups;
@@ -255,8 +254,7 @@ SetIndicatorMapField(LEDInfo * led,
     {
         if (arrayNdx != NULL)
             return ReportIndicatorNotArray(led, field);
-        if (!ExprResolveMask
-            (value, &rtrn, SimpleLookup, (char *) ctrlNames))
+        if (!ExprResolveMask(value, &rtrn, ctrlNames))
             return ReportIndicatorBadType(led, field,
                                           "controls mask");
         led->ctrls = rtrn.uval;
@@ -279,8 +277,7 @@ SetIndicatorMapField(LEDInfo * led,
     {
         if (arrayNdx != NULL)
             return ReportIndicatorNotArray(led, field);
-        if (!ExprResolveMask(value, &rtrn, SimpleLookup,
-                             (char *) modComponentNames))
+        if (!ExprResolveMask(value, &rtrn, modComponentNames))
         {
             return ReportIndicatorBadType(led, field,
                                           "mask of modifier state components");
@@ -291,8 +288,7 @@ SetIndicatorMapField(LEDInfo * led,
     {
         if (arrayNdx != NULL)
             return ReportIndicatorNotArray(led, field);
-        if (!ExprResolveMask(value, &rtrn, SimpleLookup,
-                             (char *) groupComponentNames))
+        if (!ExprResolveMask(value, &rtrn, groupComponentNames))
         {
             return ReportIndicatorBadType(led, field,
                                           "mask of group state components");

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index d2dc4bc..6011c26 100644 (file)
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -1609,7 +1609,7 @@ HandleModMapDef(ModMapDef * def,
     ExprResult rtrn;
     Bool ok;
 
-    if (!LookupModIndex(NULL, None, def->modifier, TypeInt, &rtrn))
+    if (!LookupModIndex(NULL, def->modifier, TypeInt, &rtrn))
     {
         ERROR("Illegal modifier map definition\n");
         ACTION("Ignoring map for non-modifier \"%s\"\n",

diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c
index 29ef628..17a9892 100644 (file)
--- a/src/xkbcomp/vmod.c
+++ b/src/xkbcomp/vmod.c
@@ -154,7 +154,6 @@ HandleVModDef(VModDef * stmt, struct xkb_desc *xkb, unsigned mergeMode,
  * Returns the index of the given modifier in the xkb->names->vmods array.
  *
  * @param priv Pointer to the xkb data structure.
- * @param elem Must be None, otherwise return False.
  * @param field The Atom of the modifier's name (e.g. Atom for LAlt)
  * @param type Must be TypeInt, otherwise return False.
  * @param val_rtrn Set to the index of the modifier that matches.
@@ -163,15 +162,14 @@ HandleVModDef(VModDef * stmt, struct xkb_desc *xkb, unsigned mergeMode,
  * undefined.
  */
 static int
-LookupVModIndex(char * priv,
-                uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+LookupVModIndex(char * priv, uint32_t field, unsigned type,
+                ExprResult * val_rtrn)
 {
     int i;
     struct xkb_desc * xkb;
 
     xkb = (struct xkb_desc *) priv;
-    if ((xkb == NULL) || (xkb->names == NULL) || (elem != None)
-        || (type != TypeInt))
+    if ((xkb == NULL) || (xkb->names == NULL) || (type != TypeInt))
     {
         return False;
     }
@@ -202,10 +200,9 @@ LookupVModIndex(char * priv,
  * undefined.
  */
 int
-LookupVModMask(char * priv,
-               uint32_t elem, uint32_t field, unsigned type, ExprResult * val_rtrn)
+LookupVModMask(char * priv, uint32_t field, unsigned type, ExprResult * val_rtrn)
 {
-    if (LookupVModIndex(priv, elem, field, type, val_rtrn))
+    if (LookupVModIndex(priv, field, type, val_rtrn))
     {
         register unsigned ndx = val_rtrn->uval;
         val_rtrn->uval = (1 << (XkbNumModifiers + ndx));
@@ -221,7 +218,7 @@ FindKeypadVMod(struct xkb_desc * xkb)
     ExprResult rtrn;
 
     name = xkb_intern_atom("NumLock");
-    if ((xkb) && LookupVModIndex((char *) xkb, None, name, TypeInt, &rtrn))
+    if ((xkb) && LookupVModIndex((char *) xkb, name, TypeInt, &rtrn))
     {
         return rtrn.ival;
     }

diff --git a/src/xkbcomp/vmod.h b/src/xkbcomp/vmod.h
index 1e0bb5c..55de95c 100644 (file)
--- a/src/xkbcomp/vmod.h
+++ b/src/xkbcomp/vmod.h
@@ -55,7 +55,6 @@ extern Bool ApplyVModDefs(VModInfo * /* info */ ,
     );
 
 extern int LookupVModMask(char * /* priv */ ,
-                          uint32_t /* elem */ ,
                           uint32_t /* field */ ,
                           unsigned /* type */ ,
                           ExprResult *  /* val_rtrn */