util: clean-ups to enum parsers

Never log when we fail due to OOM when translating enums, let the caller
do that. Translating basic types like enums should be something where
the caller logs, not the translatior functions.

Return -1 when NULL is passed to all enum parser functions.

The non-fallback versions of the enum translator calls already handle
NULL as failure, instead of hitting an assert, and we should do this
here, too.

diff --git a/src/basic/util.c b/src/basic/util.c
index 707b0fab6b006655250eb7ef3a2b845fc29aa7c3..6063b1beb548a2cf13652fa938a919834aed733a 100644 (file)
--- a/src/basic/util.c
+++ b/src/basic/util.c
@@ -6627,7 +6627,7 @@ ssize_t string_table_lookup(const char * const *table, size_t len, const char *k
 
         for (i = 0; i < len; ++i)
                 if (streq_ptr(table[i], key))
 
         for (i = 0; i < len; ++i)
                 if (streq_ptr(table[i], key))

-                        return (ssize_t)i;
+                        return (ssize_t) i;

 
         return -1;
 }
 
         return -1;
 }

diff --git a/src/basic/util.h b/src/basic/util.h
index 42117ed31efc8b85e42732df4ed5cec7f8941957..2fde4282108b706facc62f6491fecc1104617b14 100644 (file)
--- a/src/basic/util.h
+++ b/src/basic/util.h
@@ -287,9 +287,9 @@ bool chars_intersect(const char *a, const char *b) _pure_;
 
 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key);
 
 
 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key);
 

-#define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope)                                \
-        scope inline type name##_from_string(const char *s) {                                   \
-                return (type)string_table_lookup(name##_table, ELEMENTSOF(name##_table), s);    \
+#define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope)        \
+        scope type name##_from_string(const char *s) {                  \
+                return (type) string_table_lookup(name##_table, ELEMENTSOF(name##_table), s); \

         }
 
 #define _DEFINE_STRING_TABLE_LOOKUP(name,type,scope)                    \
         }
 
 #define _DEFINE_STRING_TABLE_LOOKUP(name,type,scope)                    \


@@ -306,17 +306,15 @@ ssize_t string_table_lookup(const char * const *table, size_t len, const char *k
 #define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max)         \
         int name##_to_string_alloc(type i, char **str) {                \
                 char *s;                                                \
 #define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max)         \
         int name##_to_string_alloc(type i, char **str) {                \
                 char *s;                                                \

-                int r;                                                  \

                 if (i < 0 || i > max)                                   \
                         return -ERANGE;                                 \
                 if (i < (type) ELEMENTSOF(name##_table)) {              \
                         s = strdup(name##_table[i]);                    \
                         if (!s)                                         \
                 if (i < 0 || i > max)                                   \
                         return -ERANGE;                                 \
                 if (i < (type) ELEMENTSOF(name##_table)) {              \
                         s = strdup(name##_table[i]);                    \
                         if (!s)                                         \

-                                return log_oom();                       \
+                                return -ENOMEM;                         \

                 } else {                                                \
                 } else {                                                \

-                        r = asprintf(&s, "%i", i);                      \
-                        if (r < 0)                                      \
-                                return log_oom();                       \
+                        if (asprintf(&s, "%i", i) < 0)                  \
+                                return -ENOMEM;                         \

                 }                                                       \
                 *str = s;                                               \
                 return 0;                                               \
                 }                                                       \
                 *str = s;                                               \
                 return 0;                                               \


@@ -324,10 +322,10 @@ ssize_t string_table_lookup(const char * const *table, size_t len, const char *k
         type name##_from_string(const char *s) {                        \
                 type i;                                                 \
                 unsigned u = 0;                                         \
         type name##_from_string(const char *s) {                        \
                 type i;                                                 \
                 unsigned u = 0;                                         \

-                assert(s);                                              \
-                for (i = 0; i < (type)ELEMENTSOF(name##_table); i++)    \
-                        if (name##_table[i] &&                          \
-                            streq(name##_table[i], s))                  \
+                if (!s)                                                 \
+                        return (type) -1;                               \
+                for (i = 0; i < (type) ELEMENTSOF(name##_table); i++)   \
+                        if (streq_ptr(name##_table[i], s))              \

                                 return i;                               \
                 if (safe_atou(s, &u) >= 0 && u <= max)                  \
                         return (type) u;                                \
                                 return i;                               \
                 if (safe_atou(s, &u) >= 0 && u <= max)                  \
                         return (type) u;                                \