Add a code-based name lookup function

Two new function pairs:
	libevdev_event_code_from_code_name()
	libevdev_event_type_from_code_name()

	libevdev_event_code_from_code_name_n()
	libevdev_event_type_from_code_name_n()

These functions look up event codes/types by the name of the event code only,
removing the need to figure out what event type an event code has. So if all
you have is "BTN_TOUCH", you can now look up the type and code for that,
without having to check the prefix yourself to guess at the type.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

diff --git a/libevdev/libevdev-names.c b/libevdev/libevdev-names.c
index 6d06df362131352a199eb4a370dccf60172d4dad..82abddc8c235102ffb41824386cafdcd08d7c63a 100644 (file)
--- a/libevdev/libevdev-names.c
+++ b/libevdev/libevdev-names.c
@@ -184,3 +184,46 @@ libevdev_property_from_name_n(const char *name, size_t len)
 
        return entry ? (int)entry->value : -1;
 }
+
+LIBEVDEV_EXPORT int
+libevdev_event_code_from_code_name(const char *name)
+{
+       return libevdev_event_code_from_code_name_n(name, strlen(name));
+}
+
+LIBEVDEV_EXPORT int
+libevdev_event_code_from_code_name_n(const char *name, size_t len)
+{
+       const struct name_entry *entry;
+       struct name_lookup lookup;
+
+       /* now look up the name @name and return the constant */
+       lookup.name = name;
+       lookup.len = len;
+
+       entry = lookup_name(code_names, ARRAY_LENGTH(code_names), &lookup);
+
+       return entry ? (int)entry->value : -1;
+}
+
+LIBEVDEV_EXPORT int
+libevdev_event_type_from_code_name(const char *name)
+{
+       return libevdev_event_type_from_code_name_n(name, strlen(name));
+}
+
+LIBEVDEV_EXPORT int
+libevdev_event_type_from_code_name_n(const char *name, size_t len)
+{
+       const struct name_entry *entry;
+       struct name_lookup lookup;
+
+       /* First look up if the name exists, we dont' want to return a valid
+        * type for an invalid code name */
+       lookup.name = name;
+       lookup.len = len;
+
+       entry = lookup_name(code_names, ARRAY_LENGTH(code_names), &lookup);
+
+       return entry ? type_from_prefix(name, len) : -1;
+}

diff --git a/libevdev/libevdev.h b/libevdev/libevdev.h
index 198b684789b3a045d317f062717bea506791ff13..3027d2e4efc93fff4b58e771eb8840fc5a48c80c 100644 (file)
--- a/libevdev/libevdev.h
+++ b/libevdev/libevdev.h
@@ -2174,6 +2174,84 @@ int libevdev_event_code_from_name_n(unsigned int type, const char *name,
 int libevdev_event_value_from_name(unsigned int type, unsigned int code,
                                   const char *name);
 
+/**
+ * @ingroup misc
+ *
+ * Look up an event type for a  event code name. For example, the name
+ * "ABS_Y" returns EV_ABS. For the lookup to succeed, the name must be
+ * unique, which is the case for all #defines as of kernel 5.0 and likely to
+ * be the case in the future.
+ *
+ * This is equivalent to libevdev_event_type_from_name() but takes the code
+ * name instead of the type name.
+ *
+ * @param name A non-NULL string describing an input-event value
+ * ("ABS_X", "REL_Y", "KEY_A", ...)
+ *
+ * @return The given event code for the name or -1 if not found.
+ */
+int
+libevdev_event_type_from_code_name(const char *name);
+
+/**
+ * @ingroup misc
+ *
+ * Look up an event type for a  event code name. For example, the name
+ * "ABS_Y" returns EV_ABS. For the lookup to succeed, the name must be
+ * unique, which is the case for all #defines as of kernel 5.0 and likely to
+ * be the case in the future.
+ *
+ * This is equivalent to libevdev_event_type_from_name_n() but takes the code
+ * name instead of the type name.
+ *
+ * @param name A non-NULL string describing an input-event value
+ * ("ABS_X", "REL_Y", "KEY_A", ...)
+ * @param len The length of the passed string excluding any terminating 0
+ * character.
+ *
+ * @return The given event code for the name or -1 if not found.
+ */
+int
+libevdev_event_type_from_code_name_n(const char *name, size_t len);
+
+/**
+ * @ingroup misc
+ *
+ * Look up an event code by its name. For example, the name "ABS_Y" returns
+ * 1. For the lookup to succeed, the name must be unique, which is the case
+ * for all #defines as of kernel 5.0 and likely to be the case in the future.
+ *
+ * This is equivalent to libevdev_event_code_from_name() without the need
+ * for knowing the event type.
+ *
+ * @param name A non-NULL string describing an input-event value
+ * ("ABS_X", "REL_Y", "KEY_A", ...)
+ *
+ * @return The given event code for the name or -1 if not found.
+ */
+int
+libevdev_event_code_from_code_name(const char *name);
+
+/**
+ * @ingroup misc
+ *
+ * Look up an event code by its name. For example, the name "ABS_Y" returns
+ * 1. For the lookup to succeed, the name must be unique, which is the case
+ * for all #defines as of kernel 5.0 and likely to be the case in the future.
+ *
+ * This is equivalent to libevdev_event_code_from_name_n() without the need
+ * for knowing the event type.
+ *
+ * @param name A non-NULL string describing an input-event value
+ * ("ABS_X", "REL_Y", "KEY_A", ...)
+ * @param len The length of the passed string excluding any terminating 0
+ * character.
+ *
+ * @return The given event code for the name or -1 if not found.
+ */
+int
+libevdev_event_code_from_code_name_n(const char *name, size_t len);
+
 /**
  * @ingroup misc
  *

diff --git a/libevdev/libevdev.sym b/libevdev/libevdev.sym
index 7dd0c201875b6f738d384ec9a9e2b928b2bbff28..d034669e34e0475871587b80375ede42e0fc50ee 100644 (file)
--- a/libevdev/libevdev.sym
+++ b/libevdev/libevdev.sym
@@ -121,3 +121,13 @@ global:
 local:
        *;
 } LIBEVDEV_1_3;
+
+LIBEVDEV_1_7 {
+global:
+       libevdev_event_code_from_code_name;
+       libevdev_event_code_from_code_name_n;
+       libevdev_event_type_from_code_name;
+       libevdev_event_type_from_code_name_n;
+local:
+       *;
+} LIBEVDEV_1_6;

diff --git a/test/test-event-codes.c b/test/test-event-codes.c
index 643b537b8abfc60e2d8473d42cfef5d8699891e5..b4e6d020675133a0f7b26bc62d4a20a2ea7c1505 100644 (file)
--- a/test/test-event-codes.c
+++ b/test/test-event-codes.c
@@ -55,6 +55,41 @@ START_TEST(test_type_names_invalid)
 }
 END_TEST
 
+START_TEST(test_type_name_lookup)
+{
+       ck_assert_int_eq(libevdev_event_type_from_code_name("SYN_REPORT"), EV_SYN);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("KEY_A"), EV_KEY);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("REL_Z"), EV_REL);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("ABS_Z"), EV_ABS);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("MSC_SERIAL"), EV_MSC);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("SND_TONE"), EV_SND);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("SW_TABLET_MODE"), EV_SW);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("LED_CHARGING"), EV_LED);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("REP_PERIOD"), EV_REP);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("FF_SPRING"), EV_FF);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("FF_STATUS_STOPPED"), EV_FF_STATUS);
+
+       ck_assert_int_eq(libevdev_event_type_from_code_name_n("KEY_1zzzzz", 5), EV_KEY);
+       ck_assert_int_eq(libevdev_event_type_from_code_name_n("ABS_Zooom", 5), EV_ABS);
+
+       ck_assert_int_eq(libevdev_event_type_from_code_name("KEY_MAX"), EV_KEY);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("REL_MAX"), EV_REL);
+       ck_assert_int_eq(libevdev_event_type_from_code_name("ABS_MAX"), EV_ABS);
+}
+END_TEST
+
+START_TEST(test_type_name_lookup_invalid)
+{
+       ck_assert_int_eq(libevdev_event_type_from_name("SYN_REPORTED"),  -1);
+       ck_assert_int_eq(libevdev_event_type_from_name("syn_blah"), -1);
+       ck_assert_int_eq(libevdev_event_type_from_name("SYN_"), -1);
+       ck_assert_int_eq(libevdev_event_type_from_name("KEY_BANANA"), -1);
+
+       ck_assert_int_eq(libevdev_event_type_from_name_n("KEY_BA", 6), -1);
+       ck_assert_int_eq(libevdev_event_type_from_name_n("KEY_BLAH", 8), -1);
+}
+END_TEST
+
 START_TEST(test_code_names)
 {
        ck_assert_int_eq(libevdev_event_code_from_name(EV_SYN, "SYN_REPORT"), SYN_REPORT);
@@ -78,6 +113,30 @@ START_TEST(test_code_names)
 }
 END_TEST
 
+START_TEST(test_code_name_lookup)
+{
+       /* Same as test_code_names() but without the type */
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SYN_REPORT"), SYN_REPORT);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("ABS_X"), ABS_X);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("BTN_A"), BTN_A);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("KEY_A"), KEY_A);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("REL_X"), REL_X);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("MSC_RAW"), MSC_RAW);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("LED_KANA"), LED_KANA);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SND_BELL"), SND_BELL);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("REP_DELAY"), REP_DELAY);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SYN_DROPPED"), SYN_DROPPED);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("KEY_RESERVED"), KEY_RESERVED);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("BTN_0"), BTN_0);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("KEY_0"), KEY_0);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_GAIN"), FF_GAIN);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_STATUS_MAX"), FF_STATUS_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SW_PEN_INSERTED"), SW_PEN_INSERTED);
+
+       ck_assert_int_eq(libevdev_event_code_from_code_name_n("ABS_YXZ", 5), ABS_Y);
+}
+END_TEST
+
 START_TEST(test_code_names_invalid)
 {
        ck_assert_int_eq(libevdev_event_code_from_name(EV_MAX, "MAX_FAKE"), -1);
@@ -99,6 +158,28 @@ START_TEST(test_code_names_invalid)
 }
 END_TEST
 
+START_TEST(test_code_name_lookup_invalid)
+{
+       /* Same as test_code_names_invalid() but without the type */
+       ck_assert_int_eq(libevdev_event_code_from_code_name("MAX_FAKE"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("CNT_FAKE"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("PWR_SOMETHING"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("EV_ABS"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("ABS_XY"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("BTN_GAMEPAD"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("BUS_PCI"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_STATUS"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_STATUS_"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_STATUS"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_STATUS_"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("ID_BUS"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SND_CNT"), -1);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SW_CNT"), -1);
+
+       ck_assert_int_eq(libevdev_event_code_from_code_name_n("ABS_X", 4), -1);
+}
+END_TEST
+
 START_TEST(test_code_names_max)
 {
        ck_assert_int_eq(libevdev_event_code_from_name(EV_SYN, "SYN_MAX"), SYN_MAX);
@@ -111,6 +192,17 @@ START_TEST(test_code_names_max)
        ck_assert_int_eq(libevdev_event_code_from_name(EV_SND, "SND_MAX"), SND_MAX);
        ck_assert_int_eq(libevdev_event_code_from_name(EV_REP, "REP_MAX"), REP_MAX);
        ck_assert_int_eq(libevdev_event_code_from_name(EV_FF, "FF_MAX"), FF_MAX);
+
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SYN_MAX"), SYN_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("KEY_MAX"), KEY_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("REL_MAX"), REL_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("ABS_MAX"), ABS_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("MSC_MAX"), MSC_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SW_MAX"), SW_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("LED_MAX"), LED_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("SND_MAX"), SND_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("REP_MAX"), REP_MAX);
+       ck_assert_int_eq(libevdev_event_code_from_code_name("FF_MAX"), FF_MAX);
 }
 END_TEST
 
@@ -175,11 +267,15 @@ TEST_SUITE(event_code_suite)
        TCase *tc = tcase_create("type tests");
        tcase_add_test(tc, test_type_names);
        tcase_add_test(tc, test_type_names_invalid);
+       tcase_add_test(tc, test_type_name_lookup);
+       tcase_add_test(tc, test_type_name_lookup_invalid);
        suite_add_tcase(s, tc);
 
        tc = tcase_create("code tests");
        tcase_add_test(tc, test_code_names);
+       tcase_add_test(tc, test_code_name_lookup);
        tcase_add_test(tc, test_code_names_invalid);
+       tcase_add_test(tc, test_code_name_lookup_invalid);
        tcase_add_test(tc, test_code_names_max);
        suite_add_tcase(s, tc);