Use clang-tidy to auto fix C++ code style issues (this time addressing only superficial problems).

Author: matyhtf

include/swoole.h

@@ -40,15 +40,14 @@
 #endif
 
 /*--- C standard library ---*/
-#include <assert.h>
-#include <ctype.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
+#include <cassert>
+#include <cctype>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <climits>
 #include <unistd.h>
 #include <sched.h> /* sched_yield() */
 #include <pthread.h>
@@ -268,7 +267,7 @@ int sw_printf(const char *format, ...);
 
 #define sw_memset_zero(s, n) memset(s, '\0', n)
 
-static sw_inline int sw_mem_equal(const void *v1, size_t s1, const void *v2, size_t s2) {
+static inline int sw_mem_equal(const void *v1, size_t s1, const void *v2, size_t s2) {
     return s1 == s2 && memcmp(v1, v2, s2) == 0;
 }
 
@@ -284,15 +283,15 @@ static inline size_t swoole_strlcpy(char *dest, const char *src, size_t size) {
 
 static inline char *swoole_strdup(const char *s) {
     size_t l = strlen(s) + 1;
-    char *p = (char *) sw_malloc(l);
+    char *p = static_cast<char *>(sw_malloc(l));
     if (sw_likely(p)) {
         memcpy(p, s, l);
     }
     return p;
 }
 
-static inline char *swoole_strndup(const char *s, size_t n) {
-    char *p = (char *) sw_malloc(n + 1);
+static inline char *swoole_strndup(const char *s, const size_t n) {
+    char *p = static_cast<char *>(sw_malloc(n + 1));
     if (sw_likely(p)) {
         strncpy(p, s, n)[n] = '\0';
     }
@@ -321,57 +320,53 @@ static inline const char *swoole_strnstr(const char *haystack,
                                          const char *needle,
                                          uint32_t needle_length) {
     assert(needle_length > 0);
-    uint32_t i;
 
     if (sw_likely(needle_length <= haystack_length)) {
-        for (i = 0; i < haystack_length - needle_length + 1; i++) {
+        for (uint32_t i = 0; i < haystack_length - needle_length + 1; i++) {
             if ((haystack[0] == needle[0]) && (0 == memcmp(haystack, needle, needle_length))) {
                 return haystack;
             }
             haystack++;
         }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 static inline const char *swoole_strncasestr(const char *haystack,
                                              uint32_t haystack_length,
                                              const char *needle,
                                              uint32_t needle_length) {
     assert(needle_length > 0);
-    uint32_t i;
 
     if (sw_likely(needle_length <= haystack_length)) {
-        for (i = 0; i < haystack_length - needle_length + 1; i++) {
+        for (uint32_t i = 0; i < haystack_length - needle_length + 1; i++) {
             if ((haystack[0] == needle[0]) && (0 == strncasecmp(haystack, needle, needle_length))) {
                 return haystack;
             }
             haystack++;
         }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 static inline ssize_t swoole_strnpos(const char *haystack,
                                      uint32_t haystack_length,
                                      const char *needle,
                                      uint32_t needle_length) {
     assert(needle_length > 0);
-    const char *pos;
 
-    pos = swoole_strnstr(haystack, haystack_length, needle, needle_length);
-    return pos == NULL ? -1 : pos - haystack;
+    const char *pos = swoole_strnstr(haystack, haystack_length, needle, needle_length);
+    return pos == nullptr ? -1 : pos - haystack;
 }
 
 static inline ssize_t swoole_strrnpos(const char *haystack, const char *needle, uint32_t length) {
     uint32_t needle_length = strlen(needle);
     assert(needle_length > 0);
-    uint32_t i;
     haystack += (length - needle_length);
 
-    for (i = length - needle_length; i > 0; i--) {
+    for (uint32_t i = length - needle_length; i > 0; i--) {
         if ((haystack[0] == needle[0]) && (0 == memcmp(haystack, needle, needle_length))) {
             return i;
         }
@@ -381,14 +376,12 @@ static inline ssize_t swoole_strrnpos(const char *haystack, const char *needle,
     return -1;
 }
 
-static inline void swoole_strtolower(char *str, int length) {
-    char *c, *e;
-
-    c = str;
-    e = c + length;
+static inline void swoole_strtolower(char *str, const int length) {
+    char *c = str;
+    const char *e = c + length;
 
     while (c < e) {
-        *c = tolower(*c);
+        *c = static_cast<char>(tolower(*c));
         c++;
     }
 }
@@ -503,17 +496,17 @@ void swoole_random_string(std::string &str, size_t size);
 uint64_t swoole_random_int();
 size_t swoole_random_bytes(char *buf, size_t size);
 
-static sw_inline char *swoole_strlchr(char *p, char *last, char c) {
+static inline char *swoole_strlchr(char *p, const char *last, char c) {
     while (p < last) {
         if (*p == c) {
             return p;
         }
         p++;
     }
-    return NULL;
+    return nullptr;
 }
 
-static sw_inline size_t swoole_size_align(size_t size, int pagesize) {
+static inline size_t swoole_size_align(size_t size, int pagesize) {
     return size + (pagesize - (size % pagesize));
 }
 
@@ -564,18 +557,18 @@ int swoole_rand(int min, int max);
 int swoole_system_random(int min, int max);
 
 int swoole_version_compare(const char *version1, const char *version2);
-void swoole_print_backtrace(void);
-void swoole_print_backtrace_on_error(void);
+void swoole_print_backtrace();
+void swoole_print_backtrace_on_error();
 char *swoole_string_format(size_t n, const char *format, ...);
 bool swoole_get_env(const char *name, int *value);
 int swoole_get_systemd_listen_fds();
 
-void swoole_init(void);
-void swoole_clean(void);
-void swoole_exit(int __status);
+void swoole_init();
+void swoole_clean();
+void swoole_exit(int _status);
 pid_t swoole_fork(int flags);
-pid_t swoole_fork_exec(const std::function<void(void)> &child_fn);
-pid_t swoole_waitpid(pid_t __pid, int *__stat_loc, int __options);
+pid_t swoole_fork_exec(const std::function<void()> &child_fn);
+pid_t swoole_waitpid(pid_t _pid, int *_stat_loc, int _options);
 void swoole_thread_init(bool main_thread);
 void swoole_thread_clean(bool main_thread);
 void swoole_redirect_stdout(int new_fd);
@@ -606,18 +599,18 @@ int swoole_get_cpu_affinity(cpu_set_t *set);
 int swoole_clock_realtime(struct timespec *t);
 #endif
 
-static inline struct timespec swoole_time_until(int milliseconds) {
-    struct timespec t;
+static inline timespec swoole_time_until(time_t milliseconds) {
+    timespec t;
     swoole_clock_realtime(&t);
 
-    int sec = milliseconds / 1000;
-    int msec = milliseconds - (sec * 1000);
+    const time_t sec = milliseconds / 1000;
+    const time_t msec = milliseconds - (sec * 1000);
 
     t.tv_sec += sec;
     t.tv_nsec += msec * 1000 * 1000;
 
     if (t.tv_nsec > SW_NUM_BILLION) {
-        int _sec = t.tv_nsec / SW_NUM_BILLION;
+        const time_t _sec = t.tv_nsec / SW_NUM_BILLION;
         t.tv_sec += _sec;
         t.tv_nsec -= _sec * SW_NUM_BILLION;
     }
@@ -631,11 +624,11 @@ typedef long SessionId;
 typedef long TaskId;
 typedef uint8_t ReactorId;
 typedef uint32_t WorkerId;
-typedef enum swEventType EventType;
-typedef enum swSocketType SocketType;
-typedef enum swFdType FdType;
-typedef enum swReturnCode ReturnCode;
-typedef enum swResultCode ResultCode;
+typedef swEventType EventType;
+typedef swSocketType SocketType;
+typedef swFdType FdType;
+typedef swReturnCode ReturnCode;
+typedef swResultCode ResultCode;
 
 struct Event {
     int fd;
@@ -663,11 +656,11 @@ struct EventData {
     DataHead info;
     char data[SW_IPC_BUFFER_SIZE];
 
-    uint32_t size() {
+    uint32_t size() const {
         return sizeof(info) + len();
     }
 
-    uint32_t len() {
+    uint32_t len() const {
         return info.len;
     }
 };
@@ -718,7 +711,7 @@ struct NameResolver {
     };
     std::function<std::string(const std::string &, Context *, void *)> resolve;
     void *private_data;
-    enum Type type;
+    Type type;
 };
 
 struct DnsServer {
@@ -790,7 +783,7 @@ struct Global {
 std::string dirname(const std::string &file);
 int hook_add(void **hooks, int type, const Callback &func, int push_back);
 void hook_call(void **hooks, int type, void *arg);
-double microtime(void);
+double microtime();
 }  // namespace swoole
 
 extern swoole::Global SwooleG;                      // Local Global Variable
@@ -802,22 +795,22 @@ static inline void swoole_set_last_error(int error) {
     SwooleTG.error = error;
 }
 
-static inline int swoole_get_last_error(void) {
+static inline int swoole_get_last_error() {
     return SwooleTG.error;
 }
 
-static inline void swoole_clear_last_error(void) {
+static inline void swoole_clear_last_error() {
     SwooleTG.error = 0;
 }
 
-void swoole_clear_last_error_msg(void);
-const char *swoole_get_last_error_msg(void);
+void swoole_clear_last_error_msg();
+const char *swoole_get_last_error_msg();
 
-static inline int swoole_get_thread_id(void) {
+static inline int swoole_get_thread_id() {
     return SwooleTG.id;
 }
 
-static inline int swoole_get_thread_type(void) {
+static inline int swoole_get_thread_type() {
     return SwooleTG.type;
 }
 

include/swoole_async.h

@@ -103,9 +103,9 @@ class AsyncThreads {
         return task_num;
     }
 
-    size_t get_queue_size();
-    size_t get_worker_num();
-    void notify_one();
+    size_t get_queue_size() const;
+    size_t get_worker_num() const;
+    void notify_one() const;
 
     static int callback(Reactor *reactor, Event *event);
 };

include/swoole_atomic.h

@@ -44,65 +44,5 @@ typedef sw_atomic_uint32_t sw_atomic_t;
 
 void sw_spinlock(sw_atomic_t *lock);
 #define sw_spinlock_release(lock) __sync_lock_release(lock)
-
-#ifdef HAVE_FUTEX
-#include <linux/futex.h>
-#include <syscall.h>
-
-static inline int sw_atomic_futex_wait(sw_atomic_t *atomic, double timeout) {
-    if (sw_atomic_cmp_set(atomic, 1, 0)) {
-        return 0;
-    }
-
-    int ret;
-    struct timespec _timeout;
-
-    if (timeout > 0) {
-        _timeout.tv_sec = (long) timeout;
-        _timeout.tv_nsec = (timeout - _timeout.tv_sec) * 1000 * 1000 * 1000;
-        ret = syscall(SYS_futex, atomic, FUTEX_WAIT, 0, &_timeout, NULL, 0);
-    } else {
-        ret = syscall(SYS_futex, atomic, FUTEX_WAIT, 0, NULL, NULL, 0);
-    }
-    if (ret == 0 && sw_atomic_cmp_set(atomic, 1, 0)) {
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-static inline int sw_atomic_futex_wakeup(sw_atomic_t *atomic, int n) {
-    if (sw_atomic_cmp_set(atomic, 0, 1)) {
-        return syscall(SYS_futex, atomic, FUTEX_WAKE, n, NULL, NULL, 0);
-    } else {
-        return 0;
-    }
-}
-
-#else
-static inline int sw_atomic_futex_wait(sw_atomic_t *atomic, double timeout) {
-    if (sw_atomic_cmp_set(atomic, (sw_atomic_t) 1, (sw_atomic_t) 0)) {
-        return 0;
-    }
-    timeout = timeout <= 0 ? INT_MAX : timeout;
-    int32_t i = (int32_t) sw_atomic_sub_fetch(atomic, 1);
-    while (timeout > 0) {
-        if ((int32_t) *atomic > i) {
-            return 0;
-        } else {
-            usleep(1000);
-            timeout -= 0.001;
-        }
-    }
-    sw_atomic_fetch_add(atomic, 1);
-    return -1;
-}
-
-static inline int sw_atomic_futex_wakeup(sw_atomic_t *atomic, int n) {
-    if (1 == (int32_t) *atomic) {
-        return 0;
-    }
-    sw_atomic_fetch_add(atomic, n);
-    return 0;
-}
-#endif
+int sw_atomic_futex_wait(sw_atomic_t *atomic, double timeout);
+int sw_atomic_futex_wakeup(sw_atomic_t *atomic, int n);

include/swoole_base64.h

@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
 
 #define BASE64_ENCODE_OUT_SIZE(s) (((s) + 2) / 3 * 4)
 #define BASE64_DECODE_OUT_SIZE(s) (((s)) / 4 * 3)

include/swoole_buffer.h

@@ -58,7 +58,7 @@ class Buffer {
 
     BufferChunk *alloc(BufferChunk::Type type, uint32_t size);
 
-    BufferChunk *front() {
+    BufferChunk *front() const {
         return queue_.front();
     }