Round 2 of remove unused DECLS from src/libudev/{ioprio,log,macro,set,strv}

Remove the following unused DECLS:

  IOPRIO_BITS
  IOPRIO_CLASS_SHIFT
  IOPRIO_PRIO_MASK
  IOPRIO_PRIO_CLASS
  IOPRIO_PRIO_DATA
  IOPRIO_PRIO_VALUE
  ioprio_valid
  IOPRIO_BE_NR
  IOPRIO_WHO_PROCESS
  IOPRIO_WHO_PGRP
  IOPRIO_WHO_USER
  MESSAGE_ID
  EXIT_TEST_SKIP
  XSTRINGIFY
  STRINGIFY
  ALIGN_PTR
  ALIGN4_PTR
  ALIGN8_PTR
  MAX
  MAX3
  MIN
  CLAMP
  zero
  CHAR_TO_STR
  VA_FORMAT_ADVANCE
  SET_FLAG
  SET_FOREACH
  SET_FOREACH_BACKWARDS
  STRV_FOREACH_BACKWARDS
  STRV_FOREACH_PAIR
  _unused_
  _destructor_
  _deprecated_
  _weak_
  _hidden_
  _weakref_
  _introspect_
  _alignas_

Remove the following unused static inline functions:

  static inline int ioprio_set
  static inline int ioprio_get
  static inline const char* STRV_IFNOTNULL

Signed-off-by: Anthony G. Basile <blueness@gentoo.org>

5 files changed, 1 insertions, 157 deletions

diff --git a/src/libudev/ioprio.h b/src/libudev/ioprio.h
index 9800fc2553..950e59b237 100644
--- a/src/libudev/ioprio.h
+++ b/src/libudev/ioprio.h
@@ -4,22 +4,6 @@
 /* This is minimal version of Linux' linux/ioprio.h header file, which
  * is licensed GPL2 */
 
-#include <unistd.h>
-#include <sys/syscall.h>
-
-/*
- * Gives us 8 prio classes with 13-bits of data for each class
- */
-#define IOPRIO_BITS             (16)
-#define IOPRIO_CLASS_SHIFT      (13)
-#define IOPRIO_PRIO_MASK        ((1UL << IOPRIO_CLASS_SHIFT) - 1)
-
-#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
-#define IOPRIO_PRIO_DATA(mask)  ((mask) & IOPRIO_PRIO_MASK)
-#define IOPRIO_PRIO_VALUE(class, data)  (((class) << IOPRIO_CLASS_SHIFT) | data)
-
-#define ioprio_valid(mask)      (IOPRIO_PRIO_CLASS((mask)) != IOPRIO_CLASS_NONE)
-
 /*
  * These are the io priority groups as implemented by CFQ. RT is the realtime
  * class, it always gets premium service. BE is the best-effort scheduling
@@ -33,25 +17,4 @@ enum {
         IOPRIO_CLASS_IDLE,
 };
 
-/*
- * 8 best effort priority levels are supported
- */
-#define IOPRIO_BE_NR    (8)
-
-enum {
-        IOPRIO_WHO_PROCESS = 1,
-        IOPRIO_WHO_PGRP,
-        IOPRIO_WHO_USER,
-};
-
-static inline int ioprio_set(int which, int who, int ioprio)
-{
-        return syscall(__NR_ioprio_set, which, who, ioprio);
-}
-
-static inline int ioprio_get(int which, int who)
-{
-        return syscall(__NR_ioprio_get, which, who);
-}
-
 #endif
diff --git a/src/libudev/log.h b/src/libudev/log.h
index 0a15adb41c..2ecba45abb 100644
--- a/src/libudev/log.h
+++ b/src/libudev/log.h
@@ -97,5 +97,3 @@ _noreturn_ void log_assert_failed_unreachable(
 
 const char *log_target_to_string(LogTarget target) _const_;
 LogTarget log_target_from_string(const char *s) _pure_;
-
-#define MESSAGE_ID(x) "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(x)
diff --git a/src/libudev/macro.h b/src/libudev/macro.h
index bfe03f2ae0..d24c779e7c 100644
--- a/src/libudev/macro.h
+++ b/src/libudev/macro.h
@@ -31,29 +31,15 @@
 #define _alloc_(...) __attribute__ ((alloc_size(__VA_ARGS__)))
 #define _sentinel_ __attribute__ ((sentinel))
 #define _noreturn_ __attribute__((noreturn))
-#define _unused_ __attribute__ ((unused))
-#define _destructor_ __attribute__ ((destructor))
 #define _pure_ __attribute__ ((pure))
 #define _const_ __attribute__ ((const))
-#define _deprecated_ __attribute__ ((deprecated))
 #define _packed_ __attribute__ ((packed))
 #define _malloc_ __attribute__ ((malloc))
-#define _weak_ __attribute__ ((weak))
 #define _likely_(x) (__builtin_expect(!!(x),1))
 #define _unlikely_(x) (__builtin_expect(!!(x),0))
 #define _public_ __attribute__ ((visibility("default")))
-#define _hidden_ __attribute__ ((visibility("hidden")))
-#define _weakref_(x) __attribute__((weakref(#x)))
-#define _introspect_(x) __attribute__((section("introspect." x)))
-#define _alignas_(x) __attribute__((aligned(__alignof(x))))
 #define _cleanup_(x) __attribute__((cleanup(x)))
 
-/* automake test harness */
-#define EXIT_TEST_SKIP 77
-
-#define XSTRINGIFY(x) #x
-#define STRINGIFY(x) XSTRINGIFY(x)
-
 /* Rounds up */
 
 #define ALIGN4(l) (((l) + 3) & ~3)
@@ -67,10 +53,6 @@
 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
 #endif
 
-#define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) p))
-#define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) p))
-#define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) p))
-
 static inline size_t ALIGN_TO(size_t l, size_t ali) {
         return ((l + ali - 1) & ~(ali - 1));
 }
@@ -86,44 +68,13 @@ static inline size_t ALIGN_TO(size_t l, size_t ali) {
  * @member: the name of the member within the struct.
  *
  */
+
 #define container_of(ptr, type, member)                                 \
         __extension__ ({                                                \
                         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
                         (type *)( (char *)__mptr - offsetof(type,member) ); \
                 })
 
-#undef MAX
-#define MAX(a,b)                                 \
-        __extension__ ({                         \
-                        typeof(a) _a = (a);      \
-                        typeof(b) _b = (b);      \
-                        _a > _b ? _a : _b;       \
-                })
-
-#define MAX3(x,y,z)                              \
-        __extension__ ({                         \
-                        typeof(x) _c = MAX(x,y); \
-                        MAX(_c, z);              \
-                })
-
-#undef MIN
-#define MIN(a,b)                                \
-        __extension__ ({                        \
-                        typeof(a) _a = (a);     \
-                        typeof(b) _b = (b);     \
-                        _a < _b ? _a : _b;      \
-                })
-
-#ifndef CLAMP
-#define CLAMP(x, low, high)                                             \
-        __extension__ ({                                                \
-                        typeof(x) _x = (x);                             \
-                        typeof(low) _low = (low);                       \
-                        typeof(high) _high = (high);                    \
-                        ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
-                })
-#endif
-
 #define assert_se(expr)                                                 \
         do {                                                            \
                 if (_unlikely_(!(expr)))                                \
@@ -180,9 +131,6 @@ static inline size_t ALIGN_TO(size_t l, size_t ali) {
 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 
 #define memzero(x,l) (memset((x), 0, (l)))
-#define zero(x) (memzero(&(x), sizeof(x)))
-
-#define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 
 #define char_array_0(x) x[sizeof(x)-1] = 0;
 
@@ -222,51 +170,6 @@ static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
         return k;
 }
 
-#define VA_FORMAT_ADVANCE(format, ap)                                   \
-do {                                                                    \
-        int _argtypes[128];                                             \
-        size_t _i, _k;                                                  \
-        _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
-        assert(_k < ELEMENTSOF(_argtypes));                             \
-        for (_i = 0; _i < _k; _i++) {                                   \
-                if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
-                        (void) va_arg(ap, void*);                       \
-                        continue;                                       \
-                }                                                       \
-                                                                        \
-                switch (_argtypes[_i]) {                                \
-                case PA_INT:                                            \
-                case PA_INT|PA_FLAG_SHORT:                              \
-                case PA_CHAR:                                           \
-                        (void) va_arg(ap, int);                         \
-                        break;                                          \
-                case PA_INT|PA_FLAG_LONG:                               \
-                        (void) va_arg(ap, long int);                    \
-                        break;                                          \
-                case PA_INT|PA_FLAG_LONG_LONG:                          \
-                        (void) va_arg(ap, long long int);               \
-                        break;                                          \
-                case PA_WCHAR:                                          \
-                        (void) va_arg(ap, wchar_t);                     \
-                        break;                                          \
-                case PA_WSTRING:                                        \
-                case PA_STRING:                                         \
-                case PA_POINTER:                                        \
-                        (void) va_arg(ap, void*);                       \
-                        break;                                          \
-                case PA_FLOAT:                                          \
-                case PA_DOUBLE:                                         \
-                        (void) va_arg(ap, double);                      \
-                        break;                                          \
-                case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
-                        (void) va_arg(ap, long double);                 \
-                        break;                                          \
-                default:                                                \
-                        assert_not_reached("Unknown format string argument."); \
-                }                                                       \
-        }                                                               \
-} while(false)
-
  /* Because statfs.t_type can be int on some architecures, we have to cast
   * the const magic to the type, otherwise the compiler warns about
   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
@@ -284,7 +187,4 @@ do {                                                                    \
             sizeof(type) <= 4 ? 10 :                                    \
             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 
-#define SET_FLAG(v, flag, b) \
-        (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
-
 #include "log.h"
diff --git a/src/libudev/set.h b/src/libudev/set.h
index 3296b2b6bf..76383a423a 100644
--- a/src/libudev/set.h
+++ b/src/libudev/set.h
@@ -44,10 +44,4 @@ bool set_contains(Set *s, void *value);
 void *set_iterate(Set *s, Iterator *i);
 void *set_iterate_backwards(Set *s, Iterator *i);
 
-#define SET_FOREACH(e, s, i) \
-        for ((i) = ITERATOR_FIRST, (e) = set_iterate((s), &(i)); (e); (e) = set_iterate((s), &(i)))
-
-#define SET_FOREACH_BACKWARDS(e, s, i) \
-        for ((i) = ITERATOR_LAST, (e) = set_iterate_backwards((s), &(i)); (e); (e) = set_iterate_backwards((s), &(i)))
-
 #define _cleanup_set_free_ _cleanup_(set_freep)
diff --git a/src/libudev/strv.h b/src/libudev/strv.h
index 821610ba19..d9e0e1c20b 100644
--- a/src/libudev/strv.h
+++ b/src/libudev/strv.h
@@ -42,20 +42,9 @@ char **strv_uniq(char **l);
 char **strv_new(const char *x, ...) _sentinel_;
 char **strv_new_ap(const char *x, va_list ap);
 
-static inline const char* STRV_IFNOTNULL(const char *x) {
-        return x ? x : (const char *) -1;
-}
-
 static inline bool strv_isempty(char * const *l) {
         return !l || !*l;
 }
 
 #define STRV_FOREACH(s, l)                      \
         for ((s) = (l); (s) && *(s); (s)++)
-
-#define STRV_FOREACH_BACKWARDS(s, l)            \
-        for (; (l) && ((s) >= (l)); (s)--)
-
-#define STRV_FOREACH_PAIR(x, y, l)               \
-        for ((x) = (l), (y) = (x+1); (x) && *(x) && *(y); (x) += 2, (y) = (x + 1))
-