technocloud-public/nginx-unit
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Fixed #define style.

Browse Source 
We had a mix of styles for declaring function-like macros:

Style A:
 #define                    \
 foo()                      \
     do {                   \
         ...                \
     } while (0)

Style B:
 #define foo()              \
     do {                   \
         ...                \
     } while (0)

We had a similar number of occurences of each style:

 $ grep -rnI '^\w*(.*\\' | wc -l
 244
 $ grep -rn 'define.*(.*)' | wc -l
 239

(Those regexes aren't perfect, but a very decent approximation.)

Real examples:

 $ find src -type f | xargs sed -n '/^nxt_double_is_zero/,/^$/p'
 nxt_double_is_zero(f)                                                         \
     (fabs(f) <= FLT_EPSILON)

 $ find src -type f | xargs sed -n '/define nxt_http_field_set/,/^$/p'
 #define nxt_http_field_set(_field, _name, _value)                             \
     do {                                                                      \
         (_field)->name_length = nxt_length(_name);                            \
         (_field)->value_length = nxt_length(_value);                          \
         (_field)->name = (u_char *) _name;                                    \
         (_field)->value = (u_char *) _value;                                  \
     } while (0)

I'd like to standardize on a single style for them, and IMO,
having the identifier in the same line as #define is a better
option for the following reasons:

- Programmers are used to `#define foo() ...` (readability).
- One less line of code.
- The program for finding them is really simple (see below).

 function grep_ngx_func()
 {
     if (($# != 1)); then
         >&2 echo "Usage: ${FUNCNAME[0]} <func>";
         return 1;
     fi;

     find src -type f \
     | grep '\.[ch]$' \
     | xargs grep -l "$1" \
     | sort \
     | xargs pcregrep -Mn "(?s)^\$[\w\s*]+?^$1\(.*?^}";

     find src -type f \
     | grep '\.[ch]$' \
     | xargs grep -l "$1" \
     | sort \
     | xargs pcregrep -Mn "(?s)define $1\(.*?^$" \
     | sed -E '1s/^[^:]+:[0-9]+:/&\n\n/';
 }

 $ grep_ngx_func
 Usage: grep_ngx_func <func>

 $ grep_ngx_func nxt_http_field_set
 src/nxt_http.h:98:

 #define nxt_http_field_set(_field, _name, _value)                             \
     do {                                                                      \
         (_field)->name_length = nxt_length(_name);                            \
         (_field)->value_length = nxt_length(_value);                          \
         (_field)->name = (u_char *) _name;                                    \
         (_field)->value = (u_char *) _value;                                  \
     } while (0)

 $ grep_ngx_func nxt_sprintf
 src/nxt_sprintf.c:56:

 u_char * nxt_cdecl
 nxt_sprintf(u_char *buf, u_char *end, const char *fmt, ...)
 {
     u_char   *p;
     va_list  args;

     va_start(args, fmt);
     p = nxt_vsprintf(buf, end, fmt, args);
     va_end(args);

     return p;
 }

................
Scripted change:
................

$ find src -type f \
  | grep '\.[ch]$' \
  | xargs sed -i '/define *\\$/{N;s/ *\\\n/ /;s/        //}'
This commit is contained in:
Alejandro Colomar
2022-04-30 19:20:23 +02:00
parent d929fbe1a4
commit 952bcc50bf
41 changed files with 259 additions and 518 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/nxt_array.h
View File

@@ -35,18 +35,15 @@ NXT_EXPORT void nxt_array_remove(nxt_array_t *array, void *elt);
NXT_EXPORT nxt_array_t *nxt_array_copy(nxt_mp_t *mp, nxt_array_t *dst, NXT_EXPORT nxt_array_t *nxt_array_copy(nxt_mp_t *mp, nxt_array_t *dst,
nxt_array_t *src); nxt_array_t *src);
#define \ #define nxt_array_last(array) \
nxt_array_last(array) \
nxt_pointer_to((array)->elts, (array)->size * ((array)->nelts - 1)) nxt_pointer_to((array)->elts, (array)->size * ((array)->nelts - 1))
#define \ #define nxt_array_reset(array) \
nxt_array_reset(array) \
(array)->nelts = 0; (array)->nelts = 0;
#define \ #define nxt_array_is_empty(array) \
nxt_array_is_empty(array) \
((array)->nelts == 0) ((array)->nelts == 0)

60
src/nxt_atomic.h
View File

@@ -26,28 +26,23 @@ typedef volatile nxt_atomic_uint_t nxt_atomic_t;
* __sync_lock_release() is a release barrier. * __sync_lock_release() is a release barrier.
*/ */
#define \ #define nxt_atomic_cmp_set(lock, cmp, set) \
nxt_atomic_cmp_set(lock, cmp, set) \
__sync_bool_compare_and_swap(lock, cmp, set) __sync_bool_compare_and_swap(lock, cmp, set)
#define \ #define nxt_atomic_xchg(lock, set) \
nxt_atomic_xchg(lock, set) \
__sync_lock_test_and_set(lock, set) __sync_lock_test_and_set(lock, set)
#define \ #define nxt_atomic_fetch_add(value, add) \
nxt_atomic_fetch_add(value, add) \
__sync_fetch_and_add(value, add) __sync_fetch_and_add(value, add)
#define \ #define nxt_atomic_try_lock(lock) \
nxt_atomic_try_lock(lock) \
nxt_atomic_cmp_set(lock, 0, 1) nxt_atomic_cmp_set(lock, 0, 1)
#define \ #define nxt_atomic_release(lock) \
nxt_atomic_release(lock) \
__sync_lock_release(lock) __sync_lock_release(lock)
@@ -60,13 +55,11 @@ nxt_atomic_release(lock) \
#if (__i386__ || __i386 || __amd64__ || __amd64) #if (__i386__ || __i386 || __amd64__ || __amd64)
#define \ #define nxt_cpu_pause() \
nxt_cpu_pause() \
__asm__ ("pause") __asm__ ("pause")
#else #else
#define \ #define nxt_cpu_pause()
nxt_cpu_pause()
#endif #endif
@@ -79,18 +72,15 @@ typedef ulong_t nxt_atomic_uint_t;
typedef volatile nxt_atomic_uint_t nxt_atomic_t; typedef volatile nxt_atomic_uint_t nxt_atomic_t;
#define \ #define nxt_atomic_cmp_set(lock, cmp, set) \
nxt_atomic_cmp_set(lock, cmp, set) \
(atomic_cas_ulong(lock, cmp, set) == (ulong_t) cmp) (atomic_cas_ulong(lock, cmp, set) == (ulong_t) cmp)
#define \ #define nxt_atomic_xchg(lock, set) \
nxt_atomic_xchg(lock, set) \
atomic_add_swap(lock, set) atomic_add_swap(lock, set)
#define \ #define nxt_atomic_fetch_add(value, add) \
nxt_atomic_fetch_add(value, add) \
(atomic_add_long_nv(value, add) - add) (atomic_add_long_nv(value, add) - add)
@@ -124,13 +114,11 @@ nxt_atomic_fetch_add(value, add) \
* barrier. * barrier.
*/ */
#define \ #define nxt_atomic_try_lock(lock) \
nxt_atomic_try_lock(lock) \
nxt_atomic_cmp_set(lock, 0, 1) nxt_atomic_cmp_set(lock, 0, 1)
#define \ #define nxt_atomic_release(lock) \
nxt_atomic_release(lock) \
*lock = 0; *lock = 0;
@@ -142,13 +130,11 @@ nxt_atomic_release(lock) \
*/ */
#if (__i386__ || __i386 || __amd64__ || __amd64) #if (__i386__ || __i386 || __amd64__ || __amd64)
#define \ #define nxt_cpu_pause() \
nxt_cpu_pause() \
__asm__ ("rep; nop") __asm__ ("rep; nop")
#else #else
#define \ #define nxt_cpu_pause()
nxt_cpu_pause()
#endif #endif
@@ -192,13 +178,11 @@ nxt_atomic_cmp_set(nxt_atomic_t *lock, nxt_atomic_int_t cmp,
} }
#define \ #define nxt_atomic_xchg(lock, set) \
nxt_atomic_xchg(lock, set) \
__fetch_and_swaplp(lock, set) __fetch_and_swaplp(lock, set)
#define \ #define nxt_atomic_fetch_add(value, add) \
nxt_atomic_fetch_add(value, add) \
__fetch_and_addlp(value, add) __fetch_and_addlp(value, add)
@@ -221,13 +205,11 @@ nxt_atomic_cmp_set(nxt_atomic_t *lock, nxt_atomic_int_t cmp,
} }
#define \ #define nxt_atomic_xchg(lock, set) \
nxt_atomic_xchg(lock, set) \
__fetch_and_swap(lock, set) __fetch_and_swap(lock, set)
#define \ #define nxt_atomic_fetch_add(value, add) \
nxt_atomic_fetch_add(value, add) \
__fetch_and_add(value, add) __fetch_and_add(value, add)
@@ -270,13 +252,11 @@ nxt_atomic_try_lock(nxt_atomic_t *lock)
} }
#define \ #define nxt_atomic_release(lock) \
nxt_atomic_release(lock) \
do { __lwsync(); *lock = 0; } while (0) do { __lwsync(); *lock = 0; } while (0)
#define \ #define nxt_cpu_pause()
nxt_cpu_pause()
#endif /* NXT_HAVE_XLC_ATOMIC */ #endif /* NXT_HAVE_XLC_ATOMIC */

84
src/nxt_buf.h
View File

@@ -113,127 +113,100 @@ struct nxt_buf_s {
#define NXT_BUF_SYNC_LAST 4 #define NXT_BUF_SYNC_LAST 4
#define \ #define nxt_buf_is_mem(b) \
nxt_buf_is_mem(b) \
((b)->mem.pos != NULL) ((b)->mem.pos != NULL)
#define \ #define nxt_buf_is_file(b) \
nxt_buf_is_file(b) \
((b)->is_file) ((b)->is_file)
#define \ #define nxt_buf_set_file(b) \
nxt_buf_set_file(b) \
(b)->is_file = 1 (b)->is_file = 1
#define \ #define nxt_buf_clear_file(b) \
nxt_buf_clear_file(b) \
(b)->is_file = 0 (b)->is_file = 0
#define \ #define nxt_buf_is_mmap(b) \
nxt_buf_is_mmap(b) \
((b)->is_mmap) ((b)->is_mmap)
#define \ #define nxt_buf_set_mmap(b) \
nxt_buf_set_mmap(b) \
(b)->is_mmap = 1 (b)->is_mmap = 1
#define \ #define nxt_buf_clear_mmap(b) \
nxt_buf_clear_mmap(b) \
(b)->is_mmap = 0 (b)->is_mmap = 0
#define \ #define nxt_buf_is_port_mmap(b) \
nxt_buf_is_port_mmap(b) \
((b)->is_port_mmap) ((b)->is_port_mmap)
#define \ #define nxt_buf_set_port_mmap(b) \
nxt_buf_set_port_mmap(b) \
(b)->is_port_mmap = 1 (b)->is_port_mmap = 1
#define \ #define nxt_buf_clear_port_mmap(b) \
nxt_buf_clear_port_mmap(b) \
(b)->is_port_mmap = 0 (b)->is_port_mmap = 0
#define \ #define nxt_buf_is_sync(b) \
nxt_buf_is_sync(b) \
((b)->is_sync) ((b)->is_sync)
#define \ #define nxt_buf_set_sync(b) \
nxt_buf_set_sync(b) \
(b)->is_sync = 1 (b)->is_sync = 1
#define \ #define nxt_buf_clear_sync(b) \
nxt_buf_clear_sync(b) \
(b)->is_sync = 0 (b)->is_sync = 0
#define \ #define nxt_buf_is_nobuf(b) \
nxt_buf_is_nobuf(b) \
((b)->is_nobuf) ((b)->is_nobuf)
#define \ #define nxt_buf_set_nobuf(b) \
nxt_buf_set_nobuf(b) \
(b)->is_nobuf = 1 (b)->is_nobuf = 1
#define \ #define nxt_buf_clear_nobuf(b) \
nxt_buf_clear_nobuf(b) \
(b)->is_nobuf = 0 (b)->is_nobuf = 0
#define \ #define nxt_buf_is_flush(b) \
nxt_buf_is_flush(b) \
((b)->is_flush) ((b)->is_flush)
#define \ #define nxt_buf_set_flush(b) \
nxt_buf_set_flush(b) \
(b)->is_flush = 1 (b)->is_flush = 1
#define \ #define nxt_buf_clear_flush(b) \
nxt_buf_clear_flush(b) \
(b)->is_flush = 0 (b)->is_flush = 0
#define \ #define nxt_buf_is_last(b) \
nxt_buf_is_last(b) \
((b)->is_last) ((b)->is_last)
#define \ #define nxt_buf_set_last(b) \
nxt_buf_set_last(b) \
(b)->is_last = 1 (b)->is_last = 1
#define \ #define nxt_buf_clear_last(b) \
nxt_buf_clear_last(b) \
(b)->is_last = 0 (b)->is_last = 0
#define \ #define nxt_buf_mem_set_size(bm, size) \
nxt_buf_mem_set_size(bm, size) \
do { \ do { \
(bm)->start = 0; \ (bm)->start = 0; \
(bm)->end = (void *) size; \ (bm)->end = (void *) size; \
} while (0) } while (0)
#define \ #define nxt_buf_mem_size(bm) \
nxt_buf_mem_size(bm) \
((bm)->end - (bm)->start) ((bm)->end - (bm)->start)
#define \ #define nxt_buf_mem_used_size(bm) \
nxt_buf_mem_used_size(bm) \
((bm)->free - (bm)->pos) ((bm)->free - (bm)->pos)
#define \ #define nxt_buf_mem_free_size(bm) \
nxt_buf_mem_free_size(bm) \
((bm)->end - (bm)->free) ((bm)->end - (bm)->free)
#define \ #define nxt_buf_used_size(b) \
nxt_buf_used_size(b) \
(nxt_buf_is_file(b) ? (b)->file_end - (b)->file_pos: \ (nxt_buf_is_file(b) ? (b)->file_end - (b)->file_pos: \
nxt_buf_mem_used_size(&(b)->mem)) nxt_buf_mem_used_size(&(b)->mem))
@@ -264,8 +237,7 @@ nxt_buf_chk_make_plain(nxt_mp_t *mp, nxt_buf_t *src, size_t size)
return src; return src;
} }
#define \ #define nxt_buf_free(mp, b) \
nxt_buf_free(mp, b) \
nxt_mp_free((mp), (b)) nxt_mp_free((mp), (b))

15
src/nxt_buf_pool.h
View File

@@ -42,8 +42,7 @@ NXT_EXPORT void nxt_buf_pool_destroy(nxt_buf_pool_t *bp);
/* There is ready free buffer. */ /* There is ready free buffer. */
#define \ #define nxt_buf_pool_ready(bp) \
nxt_buf_pool_ready(bp) \
((bp)->free != NULL \ ((bp)->free != NULL \
|| ((bp)->current != NULL \ || ((bp)->current != NULL \
&& (bp)->current->mem.free < (bp)->current->mem.end)) && (bp)->current->mem.free < (bp)->current->mem.end))
@@ -51,29 +50,25 @@ nxt_buf_pool_ready(bp) \
/* A free buffer is allowed to be allocated. */ /* A free buffer is allowed to be allocated. */
#define \ #define nxt_buf_pool_obtainable(bp) \
nxt_buf_pool_obtainable(bp) \
((bp)->num < (bp)->max) ((bp)->num < (bp)->max)
/* There is ready free buffer or it is allowed to be allocated. */ /* There is ready free buffer or it is allowed to be allocated. */
#define \ #define nxt_buf_pool_available(bp) \
nxt_buf_pool_available(bp) \
(nxt_buf_pool_obtainable(bp) || nxt_buf_pool_ready(bp)) (nxt_buf_pool_obtainable(bp) || nxt_buf_pool_ready(bp))
/* Reserve allocation of "n" free buffers as they were allocated. */ /* Reserve allocation of "n" free buffers as they were allocated. */
#define \ #define nxt_buf_pool_reserve(bp, n) \
nxt_buf_pool_reserve(bp, n) \
(bp)->num += (n) (bp)->num += (n)
/* Release a reservation. */ /* Release a reservation. */
#define \ #define nxt_buf_pool_release(bp, n) \
nxt_buf_pool_release(bp, n) \
(bp)->num -= (n) (bp)->num -= (n)

3
src/nxt_cache.c
View File

@@ -8,8 +8,7 @@
/* A cache time resolution is 10ms. */ /* A cache time resolution is 10ms. */
#define \ #define nxt_cache_time(thr) \
nxt_cache_time(thr) \
(uint64_t) (nxt_thread_time(thr) * 100) (uint64_t) (nxt_thread_time(thr) * 100)

66
src/nxt_clang.h
View File

@@ -16,45 +16,37 @@
#if (NXT_CLANG) #if (NXT_CLANG)
/* Any __asm__ directive disables loop vectorization in GCC and Clang. */ /* Any __asm__ directive disables loop vectorization in GCC and Clang. */
#define \ #define nxt_pragma_loop_disable_vectorization \
nxt_pragma_loop_disable_vectorization \
__asm__("") __asm__("")
#else #else
#define \ #define nxt_pragma_loop_disable_vectorization
nxt_pragma_loop_disable_vectorization
#endif #endif
#if (NXT_HAVE_BUILTIN_EXPECT) #if (NXT_HAVE_BUILTIN_EXPECT)
#define \ #define nxt_expect(c, x) \
nxt_expect(c, x) \
__builtin_expect((long) (x), (c)) __builtin_expect((long) (x), (c))
#define \ #define nxt_fast_path(x) \
nxt_fast_path(x) \
nxt_expect(1, x) nxt_expect(1, x)
#define \ #define nxt_slow_path(x) \
nxt_slow_path(x) \
nxt_expect(0, x) nxt_expect(0, x)
#else #else
#define \ #define nxt_expect(c, x) \
nxt_expect(c, x) \
(x) (x)
#define \ #define nxt_fast_path(x) \
nxt_fast_path(x) \
(x) (x)
#define \ #define nxt_slow_path(x) \
nxt_slow_path(x) \
(x) (x)
#endif #endif
@@ -62,28 +54,24 @@ nxt_slow_path(x) \
#if (NXT_HAVE_BUILTIN_UNREACHABLE) #if (NXT_HAVE_BUILTIN_UNREACHABLE)
#define \ #define nxt_unreachable() \
nxt_unreachable() \
__builtin_unreachable() __builtin_unreachable()
#else #else
#define \ #define nxt_unreachable()
nxt_unreachable()
#endif #endif
#if (NXT_HAVE_BUILTIN_PREFETCH) #if (NXT_HAVE_BUILTIN_PREFETCH)
#define \ #define nxt_prefetch(a) \
nxt_prefetch(a) \
__builtin_prefetch(a) __builtin_prefetch(a)
#else #else
#define \ #define nxt_prefetch(a)
nxt_prefetch(a)
#endif #endif
@@ -206,13 +194,11 @@ nxt_popcount(unsigned int x)
#endif #endif
#define \ #define nxt_alloca(size) \
nxt_alloca(size) \
alloca(size) alloca(size)
#define \ #define nxt_container_of(p, type, field) \
nxt_container_of(p, type, field) \
(type *) ((u_char *) (p) - offsetof(type, field)) (type *) ((u_char *) (p) - offsetof(type, field))
@@ -224,30 +210,25 @@ nxt_container_of(p, type, field) \
*(type *) ((u_char *) p + offset) *(type *) ((u_char *) p + offset)
#define \ #define nxt_nitems(x) \
nxt_nitems(x) \
(sizeof(x) / sizeof((x)[0])) (sizeof(x) / sizeof((x)[0]))
/* GCC and Clang use __builtin_abs() instead of libc abs(). */ /* GCC and Clang use __builtin_abs() instead of libc abs(). */
#define \ #define nxt_abs(val) \
nxt_abs(val) \
abs(val) abs(val)
#define \ #define nxt_max(val1, val2) \
nxt_max(val1, val2) \
((val1 < val2) ? (val2) : (val1)) ((val1 < val2) ? (val2) : (val1))
#define \ #define nxt_min(val1, val2) \
nxt_min(val1, val2) \
((val1 > val2) ? (val2) : (val1)) ((val1 > val2) ? (val2) : (val1))
#define \ #define nxt_bswap32(val) \
nxt_bswap32(val) \
( ((val) >> 24) \ ( ((val) >> 24) \
| (((val) & 0x00FF0000) >> 8) \ | (((val) & 0x00FF0000) >> 8) \
| (((val) & 0x0000FF00) << 8) \ | (((val) & 0x0000FF00) << 8) \
@@ -258,18 +239,15 @@ nxt_bswap32(val) \
((((value) - 1) & (value)) == 0) ((((value) - 1) & (value)) == 0)
#define \ #define nxt_align_size(d, a) \
nxt_align_size(d, a) \
(((d) + ((size_t) (a) - 1)) & ~((size_t) (a) - 1)) (((d) + ((size_t) (a) - 1)) & ~((size_t) (a) - 1))
#define \ #define nxt_align_ptr(p, a) \
nxt_align_ptr(p, a) \
(u_char *) (((uintptr_t) (p) + ((uintptr_t) (a) - 1)) \ (u_char *) (((uintptr_t) (p) + ((uintptr_t) (a) - 1)) \
& ~((uintptr_t) (a) - 1)) & ~((uintptr_t) (a) - 1))
#define \ #define nxt_trunc_ptr(p, a) \
nxt_trunc_ptr(p, a) \
(u_char *) ((uintptr_t) (p) & ~((uintptr_t) (a) - 1)) (u_char *) ((uintptr_t) (p) & ~((uintptr_t) (a) - 1))

3
src/nxt_djb_hash.h
View File

@@ -18,8 +18,7 @@ NXT_EXPORT uint32_t nxt_djb_hash_lowcase(const void *data, size_t len);
#define NXT_DJB_HASH_INIT 5381 #define NXT_DJB_HASH_INIT 5381
#define \ #define nxt_djb_hash_add(hash, val) \
nxt_djb_hash_add(hash, val) \
((uint32_t) ((((hash) << 5) + (hash)) ^ (uint32_t) (val))) ((uint32_t) ((((hash) << 5) + (hash)) ^ (uint32_t) (val)))

3
src/nxt_dyld.h
View File

@@ -17,8 +17,7 @@ typedef struct {
#define NXT_DYLD_ANY RTLD_DEFAULT #define NXT_DYLD_ANY RTLD_DEFAULT
#define \ #define nxt_dyld_is_valid(dyld) \
nxt_dyld_is_valid(dyld) \
((dyld)->handle != NULL) ((dyld)->handle != NULL)

12
src/nxt_errno.h
View File

@@ -65,20 +65,16 @@ typedef int nxt_err_t;
#define NXT_DONE (-4) #define NXT_DONE (-4)
#define \ #define nxt_errno \
nxt_errno \
errno errno
#define \ #define nxt_socket_errno \
nxt_socket_errno \
errno errno
#define \ #define nxt_set_errno(err) \
nxt_set_errno(err) \
errno = err errno = err
#define \ #define nxt_set_socket_errno(err) \
nxt_set_socket_errno(err) \
errno = err errno = err

36
src/nxt_event_engine.h
View File

@@ -351,43 +351,35 @@ void nxt_fd_event_hash_delete(nxt_task_t *task, nxt_lvlhsh_t *lvlhsh,
void nxt_fd_event_hash_destroy(nxt_lvlhsh_t *lvlhsh); void nxt_fd_event_hash_destroy(nxt_lvlhsh_t *lvlhsh);
#define \ #define nxt_fd_event_disable(engine, ev) \
nxt_fd_event_disable(engine, ev) \
(engine)->event.disable(engine, ev) (engine)->event.disable(engine, ev)
#define \ #define nxt_fd_event_delete(engine, ev) \
nxt_fd_event_delete(engine, ev) \
(engine)->event.delete(engine, ev) (engine)->event.delete(engine, ev)
#define \ #define nxt_fd_event_close(engine, ev) \
nxt_fd_event_close(engine, ev) \
(engine)->event.close(engine, ev) (engine)->event.close(engine, ev)
#define \ #define nxt_fd_event_enable_read(engine, ev) \
nxt_fd_event_enable_read(engine, ev) \
(engine)->event.enable_read(engine, ev) (engine)->event.enable_read(engine, ev)
#define \ #define nxt_fd_event_enable_write(engine, ev) \
nxt_fd_event_enable_write(engine, ev) \
(engine)->event.enable_write(engine, ev) (engine)->event.enable_write(engine, ev)
#define \ #define nxt_fd_event_disable_read(engine, ev) \
nxt_fd_event_disable_read(engine, ev) \
(engine)->event.disable_read(engine, ev) (engine)->event.disable_read(engine, ev)
#define \ #define nxt_fd_event_disable_write(engine, ev) \
nxt_fd_event_disable_write(engine, ev) \
(engine)->event.disable_write(engine, ev) (engine)->event.disable_write(engine, ev)
#define \ #define nxt_fd_event_block_read(engine, ev) \
nxt_fd_event_block_read(engine, ev) \
do { \ do { \
if (nxt_fd_event_is_active((ev)->read)) { \ if (nxt_fd_event_is_active((ev)->read)) { \
(engine)->event.block_read(engine, ev); \ (engine)->event.block_read(engine, ev); \
@@ -395,8 +387,7 @@ nxt_fd_event_block_read(engine, ev) \
} while (0) } while (0)
#define \ #define nxt_fd_event_block_write(engine, ev) \
nxt_fd_event_block_write(engine, ev) \
do { \ do { \
if (nxt_fd_event_is_active((ev)->write)) { \ if (nxt_fd_event_is_active((ev)->write)) { \
(engine)->event.block_write(engine, ev); \ (engine)->event.block_write(engine, ev); \
@@ -404,18 +395,15 @@ nxt_fd_event_block_write(engine, ev) \
} while (0) } while (0)
#define \ #define nxt_fd_event_oneshot_read(engine, ev) \
nxt_fd_event_oneshot_read(engine, ev) \
(engine)->event.oneshot_read(engine, ev) (engine)->event.oneshot_read(engine, ev)
#define \ #define nxt_fd_event_oneshot_write(engine, ev) \
nxt_fd_event_oneshot_write(engine, ev) \
(engine)->event.oneshot_write(engine, ev) (engine)->event.oneshot_write(engine, ev)
#define \ #define nxt_fd_event_enable_accept(engine, ev) \
nxt_fd_event_enable_accept(engine, ev) \
(engine)->event.enable_accept(engine, ev) (engine)->event.enable_accept(engine, ev)

3
src/nxt_fastcgi_source.c
View File

@@ -18,8 +18,7 @@ typedef struct {
} nxt_fastcgi_param_t; } nxt_fastcgi_param_t;
#define \ #define nxt_fastcgi_set_record_length(p, length) \
nxt_fastcgi_set_record_length(p, length) \
do { \ do { \
uint32_t len = length; \ uint32_t len = length; \
\ \

6
src/nxt_fd_event.h
View File

@@ -44,13 +44,11 @@ typedef enum {
} nxt_fd_event_state_t; } nxt_fd_event_state_t;
#define \ #define nxt_fd_event_is_disabled(state) \
nxt_fd_event_is_disabled(state) \
((state) < NXT_EVENT_ONESHOT) ((state) < NXT_EVENT_ONESHOT)
#define \ #define nxt_fd_event_is_active(state) \
nxt_fd_event_is_active(state) \
((state) >= NXT_EVENT_ONESHOT) ((state) >= NXT_EVENT_ONESHOT)

3
src/nxt_fiber.c
View File

@@ -14,8 +14,7 @@ static void nxt_fiber_switch(nxt_task_t *task, nxt_fiber_t *fib);
static void nxt_fiber_timer_handler(nxt_task_t *task, void *obj, void *data); static void nxt_fiber_timer_handler(nxt_task_t *task, void *obj, void *data);
#define \ #define nxt_fiber_enqueue(thr, task, fib) \
nxt_fiber_enqueue(thr, task, fib) \
nxt_work_queue_add(&(thr)->engine->fast_work_queue, \ nxt_work_queue_add(&(thr)->engine->fast_work_queue, \
nxt_fiber_switch_handler, task, fib, NULL) nxt_fiber_switch_handler, task, fib, NULL)

39
src/nxt_file.h
View File

@@ -27,23 +27,19 @@ typedef struct {
} nxt_file_name_str_t; } nxt_file_name_str_t;
#define \ #define nxt_file_name_str_set(file_name, mem_pool, name) \
nxt_file_name_str_set(file_name, mem_pool, name) \
((file_name) = (nxt_file_name_t *) (name), NXT_OK) ((file_name) = (nxt_file_name_t *) (name), NXT_OK)
#define \ #define nxt_file_name_alloc(mem_pool, len) \
nxt_file_name_alloc(mem_pool, len) \
nxt_mp_nget(mem_pool, len) nxt_mp_nget(mem_pool, len)
#define \ #define nxt_file_name_copy(dst, src, len) \
nxt_file_name_copy(dst, src, len) \
nxt_cpymem(dst, src, len) nxt_cpymem(dst, src, len)
#define \ #define nxt_file_name_add(dst, src, len) \
nxt_file_name_add(dst, src, len) \
nxt_cpymem(dst, src, len) nxt_cpymem(dst, src, len)
@@ -51,21 +47,18 @@ nxt_file_name_add(dst, src, len) \
/* MacOSX, Cygwin. */ /* MacOSX, Cygwin. */
#define \ #define nxt_file_name_eq(fn1, fn2) \
nxt_file_name_eq(fn1, fn2) \
(nxt_strcasecmp(fn1, fn2) == 0) (nxt_strcasecmp(fn1, fn2) == 0)
#else #else
#define \ #define nxt_file_name_eq(fn1, fn2) \
nxt_file_name_eq(fn1, fn2) \
(nxt_strcmp(fn1, fn2) == 0) (nxt_strcmp(fn1, fn2) == 0)
#endif #endif
#define \ #define nxt_file_name_is_absolute(name) \
nxt_file_name_is_absolute(name) \
(name[0] == '/') (name[0] == '/')
@@ -168,20 +161,16 @@ NXT_EXPORT void nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset,
NXT_EXPORT nxt_int_t nxt_file_info(nxt_file_t *file, nxt_file_info_t *fi); NXT_EXPORT nxt_int_t nxt_file_info(nxt_file_t *file, nxt_file_info_t *fi);
#define \ #define nxt_is_dir(fi) \
nxt_is_dir(fi) \
(S_ISDIR((fi)->st_mode)) (S_ISDIR((fi)->st_mode))
#define \ #define nxt_is_file(fi) \
nxt_is_file(fi) \
(S_ISREG((fi)->st_mode)) (S_ISREG((fi)->st_mode))
#define \ #define nxt_file_size(fi) \
nxt_file_size(fi) \
(fi)->st_size (fi)->st_size
#define \ #define nxt_file_mtime(fi) \
nxt_file_mtime(fi) \
(fi)->st_mtime (fi)->st_mtime
@@ -206,12 +195,10 @@ NXT_EXPORT nxt_int_t nxt_stderr_start(void);
#define nxt_stderr STDERR_FILENO #define nxt_stderr STDERR_FILENO
#define \ #define nxt_write_console(fd, buf, size) \
nxt_write_console(fd, buf, size) \
write(fd, buf, size) write(fd, buf, size)
#define \ #define nxt_write_syslog(priority, message) \
nxt_write_syslog(priority, message) \
syslog(priority, "%s", message) syslog(priority, "%s", message)

3
src/nxt_http_chunk_parse.c
View File

@@ -12,8 +12,7 @@
#define NXT_HTTP_CHUNK_END 2 #define NXT_HTTP_CHUNK_END 2
#define \ #define nxt_size_is_sufficient(cs) \
nxt_size_is_sufficient(cs) \
(cs < ((__typeof__(cs)) 1 << (sizeof(cs) * 8 - 4))) (cs < ((__typeof__(cs)) 1 << (sizeof(cs) * 8 - 4)))

3
src/nxt_http_parse.c
View File

@@ -827,8 +827,7 @@ nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos,
} }
#define \ #define nxt_http_is_normal(c) \
nxt_http_is_normal(c) \
(nxt_fast_path((nxt_http_normal[c / 8] & (1 << (c & 7))) != 0)) (nxt_fast_path((nxt_http_normal[c / 8] & (1 << (c & 7))) != 0))

9
src/nxt_job.h
View File

@@ -67,21 +67,18 @@ NXT_EXPORT void nxt_job_return(nxt_task_t *task, nxt_job_t *job,
nxt_work_handler_t handler); nxt_work_handler_t handler);
#define \ #define nxt_job_cancel(job) \
nxt_job_cancel(job) \
(job)->cancel = 1 (job)->cancel = 1
#if (NXT_DEBUG) #if (NXT_DEBUG)
#define \ #define nxt_job_set_name(job, text) \
nxt_job_set_name(job, text) \
(job)->name = text (job)->name = text
#else #else
#define \ #define nxt_job_set_name(job, text)
nxt_job_set_name(job, text)
#endif #endif

12
src/nxt_list.h
View File

@@ -37,18 +37,15 @@ typedef struct {
} nxt_list_next_t; } nxt_list_next_t;
#define \ #define nxt_list_part(list) \
nxt_list_part(list) \
(&(list)->part) (&(list)->part)
#define \ #define nxt_list_data(part) \
nxt_list_data(part) \
((void *) part->data) ((void *) part->data)
#define \ #define nxt_list_first(list) \
nxt_list_first(list) \
nxt_list_data(nxt_list_part(list)) nxt_list_data(nxt_list_part(list))
@@ -102,8 +99,7 @@ NXT_EXPORT void *nxt_list_zero_add(nxt_list_t *list);
NXT_EXPORT void *nxt_list_next(nxt_list_t *list, nxt_list_next_t *next); NXT_EXPORT void *nxt_list_next(nxt_list_t *list, nxt_list_next_t *next);
#define \ #define nxt_list_next_value(list, next) \
nxt_list_next_value(list, next) \
(nxt_pointer_to(nxt_list_data((next)->part), (next)->elt * (list)->size)) (nxt_pointer_to(nxt_list_data((next)->part), (next)->elt * (list)->size))

21
src/nxt_log.h
View File

@@ -41,8 +41,7 @@ NXT_EXPORT void nxt_cdecl nxt_log_handler(nxt_uint_t level, nxt_log_t *log,
const char *fmt, ...); const char *fmt, ...);
#define \ #define nxt_log_level_enough(log, level) \
nxt_log_level_enough(log, level) \
((log)->level >= (level)) ((log)->level >= (level))
@@ -83,8 +82,7 @@ nxt_log_level_enough(log, level) \
} while (0) } while (0)
#define \ #define nxt_log_error(_level, _log, ...) \
nxt_log_error(_level, _log, ...) \
do { \ do { \
nxt_log_t *_log_ = (_log); \ nxt_log_t *_log_ = (_log); \
nxt_uint_t _level_ = (_level); \ nxt_uint_t _level_ = (_level); \
@@ -107,8 +105,7 @@ nxt_log_error(_level, _log, ...) \
} while (0) } while (0)
#define \ #define nxt_log_debug(_log, ...) \
nxt_log_debug(_log, ...) \
do { \ do { \
nxt_log_t *_log_ = (_log); \ nxt_log_t *_log_ = (_log); \
\ \
@@ -131,8 +128,7 @@ nxt_log_debug(_log, ...) \
#define nxt_debug(...) #define nxt_debug(...)
#define \ #define nxt_log_debug(...)
nxt_log_debug(...)
#define nxt_assert(c) #define nxt_assert(c)
@@ -151,18 +147,15 @@ nxt_log_debug(...)
#endif #endif
#define \ #define nxt_main_log_alert(...) \
nxt_main_log_alert(...) \
nxt_log_alert(&nxt_main_log, __VA_ARGS__) nxt_log_alert(&nxt_main_log, __VA_ARGS__)
#define \ #define nxt_main_log_error(level, ...) \
nxt_main_log_error(level, ...) \
nxt_log_error(level, &nxt_main_log, __VA_ARGS__) nxt_log_error(level, &nxt_main_log, __VA_ARGS__)
#define \ #define nxt_main_log_debug(...) \
nxt_main_log_debug(...) \
nxt_log_debug(&nxt_main_log, __VA_ARGS__) nxt_log_debug(&nxt_main_log, __VA_ARGS__)

6
src/nxt_log_moderation.h
View File

@@ -23,8 +23,7 @@ typedef struct {
#define NXT_LOG_MODERATION 0, -1, 0, 0, NXT_TIMER #define NXT_LOG_MODERATION 0, -1, 0, 0, NXT_TIMER
#define \ #define nxt_log_alert_moderate(_mod, _log, ...) \
nxt_log_alert_moderate(_mod, _log, ...) \
do { \ do { \
nxt_log_t *_log_ = _log; \ nxt_log_t *_log_ = _log; \
\ \
@@ -34,8 +33,7 @@ nxt_log_alert_moderate(_mod, _log, ...) \
} while (0) } while (0)
#define \ #define nxt_log_moderate(_mod, _level, _log, ...) \
nxt_log_moderate(_mod, _level, _log, ...) \
do { \ do { \
nxt_log_t *_log_ = _log; \ nxt_log_t *_log_ = _log; \
\ \

69
src/nxt_lvlhsh.c
View File

@@ -43,121 +43,98 @@
* several levels. * several levels.
*/ */
#define \ #define nxt_lvlhsh_is_bucket(p) \
nxt_lvlhsh_is_bucket(p) \
((uintptr_t) (p) & 1) ((uintptr_t) (p) & 1)
#define \ #define nxt_lvlhsh_count_inc(n) \
nxt_lvlhsh_count_inc(n) \
n = (void *) ((uintptr_t) (n) + 2) n = (void *) ((uintptr_t) (n) + 2)
#define \ #define nxt_lvlhsh_count_dec(n) \
nxt_lvlhsh_count_dec(n) \
n = (void *) ((uintptr_t) (n) - 2) n = (void *) ((uintptr_t) (n) - 2)
#define \ #define nxt_lvlhsh_level_size(proto, nlvl) \
nxt_lvlhsh_level_size(proto, nlvl) \
((uintptr_t) 1 << proto->shift[nlvl]) ((uintptr_t) 1 << proto->shift[nlvl])
#define \ #define nxt_lvlhsh_level(lvl, mask) \
nxt_lvlhsh_level(lvl, mask) \
(void **) ((uintptr_t) lvl & (~mask << 2)) (void **) ((uintptr_t) lvl & (~mask << 2))
#define \ #define nxt_lvlhsh_level_entries(lvl, mask) \
nxt_lvlhsh_level_entries(lvl, mask) \
((uintptr_t) lvl & (mask << 1)) ((uintptr_t) lvl & (mask << 1))
#define \ #define nxt_lvlhsh_store_bucket(slot, bkt) \
nxt_lvlhsh_store_bucket(slot, bkt) \
slot = (void **) ((uintptr_t) bkt | 2 | 1) slot = (void **) ((uintptr_t) bkt | 2 | 1)
#define \ #define nxt_lvlhsh_bucket_size(proto) \
nxt_lvlhsh_bucket_size(proto) \
proto->bucket_size proto->bucket_size
#define \ #define nxt_lvlhsh_bucket(proto, bkt) \
nxt_lvlhsh_bucket(proto, bkt) \
(uint32_t *) ((uintptr_t) bkt & ~(uintptr_t) proto->bucket_mask) (uint32_t *) ((uintptr_t) bkt & ~(uintptr_t) proto->bucket_mask)
#define \ #define nxt_lvlhsh_bucket_entries(proto, bkt) \
nxt_lvlhsh_bucket_entries(proto, bkt) \
(((uintptr_t) bkt & (uintptr_t) proto->bucket_mask) >> 1) (((uintptr_t) bkt & (uintptr_t) proto->bucket_mask) >> 1)
#define \ #define nxt_lvlhsh_bucket_end(proto, bkt) \
nxt_lvlhsh_bucket_end(proto, bkt) \
&bkt[proto->bucket_end] &bkt[proto->bucket_end]
#define \ #define nxt_lvlhsh_free_entry(e) \
nxt_lvlhsh_free_entry(e) \
(!(nxt_lvlhsh_valid_entry(e))) (!(nxt_lvlhsh_valid_entry(e)))
#define \ #define nxt_lvlhsh_next_bucket(proto, bkt) \
nxt_lvlhsh_next_bucket(proto, bkt) \
((void **) &bkt[proto->bucket_end]) ((void **) &bkt[proto->bucket_end])
#if (NXT_64BIT) #if (NXT_64BIT)
#define \ #define nxt_lvlhsh_valid_entry(e) \
nxt_lvlhsh_valid_entry(e) \
(((e)[0] | (e)[1]) != 0) (((e)[0] | (e)[1]) != 0)
#define \ #define nxt_lvlhsh_entry_value(e) \
nxt_lvlhsh_entry_value(e) \
(void *) (((uintptr_t) (e)[1] << 32) + (e)[0]) (void *) (((uintptr_t) (e)[1] << 32) + (e)[0])
#define \ #define nxt_lvlhsh_set_entry_value(e, n) \
nxt_lvlhsh_set_entry_value(e, n) \
(e)[0] = (uint32_t) (uintptr_t) n; \ (e)[0] = (uint32_t) (uintptr_t) n; \
(e)[1] = (uint32_t) ((uintptr_t) n >> 32) (e)[1] = (uint32_t) ((uintptr_t) n >> 32)
#define \ #define nxt_lvlhsh_entry_key(e) \
nxt_lvlhsh_entry_key(e) \
(e)[2] (e)[2]
#define \ #define nxt_lvlhsh_set_entry_key(e, n) \
nxt_lvlhsh_set_entry_key(e, n) \
(e)[2] = n (e)[2] = n
#else #else
#define \ #define nxt_lvlhsh_valid_entry(e) \
nxt_lvlhsh_valid_entry(e) \
((e)[0] != 0) ((e)[0] != 0)
#define \ #define nxt_lvlhsh_entry_value(e) \
nxt_lvlhsh_entry_value(e) \
(void *) (e)[0] (void *) (e)[0]
#define \ #define nxt_lvlhsh_set_entry_value(e, n) \
nxt_lvlhsh_set_entry_value(e, n) \
(e)[0] = (uint32_t) n (e)[0] = (uint32_t) n
#define \ #define nxt_lvlhsh_entry_key(e) \
nxt_lvlhsh_entry_key(e) \
(e)[1] (e)[1]
#define \ #define nxt_lvlhsh_set_entry_key(e, n) \
nxt_lvlhsh_set_entry_key(e, n) \
(e)[1] = n (e)[1] = n
#endif #endif

6
src/nxt_lvlhsh.h
View File

@@ -114,13 +114,11 @@ typedef struct {
} nxt_lvlhsh_each_t; } nxt_lvlhsh_each_t;
#define \ #define nxt_lvlhsh_is_empty(lh) \
nxt_lvlhsh_is_empty(lh) \
((lh)->slot == NULL) ((lh)->slot == NULL)
#define \ #define nxt_lvlhsh_init(lh) \
nxt_lvlhsh_init(lh) \
(lh)->slot = NULL (lh)->slot = NULL
/* /*

27
src/nxt_malloc.h
View File

@@ -24,8 +24,7 @@ NXT_EXPORT void nxt_free(void *p);
#else #else
#define \ #define nxt_free(p) \
nxt_free(p) \
free(p) free(p)
#endif #endif
@@ -54,12 +53,10 @@ nxt_free(p) \
* Glibc malloc_usable_size() is fast operation. * Glibc malloc_usable_size() is fast operation.
*/ */
#define \ #define nxt_malloc_usable_size(p, size) \
nxt_malloc_usable_size(p, size) \
size = malloc_usable_size(p) size = malloc_usable_size(p)
#define \ #define nxt_malloc_cutback(cutback, size) \
nxt_malloc_cutback(cutback, size) \
size = ((cutback) && size > 127 * 1024) ? size - 32 : size size = ((cutback) && size > 127 * 1024) ? size - 32 : size
#elif (NXT_FREEBSD) #elif (NXT_FREEBSD)
@@ -81,12 +78,10 @@ nxt_malloc_cutback(cutback, size) \
* are lesser than 1M. Larger allocations require mutex acquiring. * are lesser than 1M. Larger allocations require mutex acquiring.
*/ */
#define \ #define nxt_malloc_usable_size(p, size) \
nxt_malloc_usable_size(p, size) \
size = malloc_usable_size(p) size = malloc_usable_size(p)
#define \ #define nxt_malloc_cutback(cutback, size)
nxt_malloc_cutback(cutback, size)
#endif #endif
@@ -103,20 +98,16 @@ nxt_malloc_cutback(cutback, size)
* malloc_good_size() is faster than malloc_size() * malloc_good_size() is faster than malloc_size()
*/ */
#define \ #define nxt_malloc_usable_size(p, size) \
nxt_malloc_usable_size(p, size) \
size = malloc_good_size(size) size = malloc_good_size(size)
#define \ #define nxt_malloc_cutback(cutback, size)
nxt_malloc_cutback(cutback, size)
#else #else
#define \ #define nxt_malloc_usable_size(p, size)
nxt_malloc_usable_size(p, size)
#define \ #define nxt_malloc_cutback(cutback, size)
nxt_malloc_cutback(cutback, size)
#endif #endif

9
src/nxt_mem_map.h
View File

@@ -43,17 +43,14 @@
#define NXT_MEM_MAP_FILE (MAP_SHARED | NXT_MEM_MAP_PREFAULT) #define NXT_MEM_MAP_FILE (MAP_SHARED | NXT_MEM_MAP_PREFAULT)
#define \ #define nxt_mem_map_file_ctx_t(ctx)
nxt_mem_map_file_ctx_t(ctx)
#define \ #define nxt_mem_map(addr, ctx, len, protection, flags, fd, offset) \
nxt_mem_map(addr, ctx, len, protection, flags, fd, offset) \
nxt_mem_mmap(addr, len, protection, flags, fd, offset) nxt_mem_mmap(addr, len, protection, flags, fd, offset)
#define \ #define nxt_mem_unmap(addr, ctx, len) \
nxt_mem_unmap(addr, ctx, len) \
nxt_mem_munmap(addr, len) nxt_mem_munmap(addr, len)

27
src/nxt_mem_zone.c
View File

@@ -87,48 +87,39 @@ struct nxt_mem_zone_s {
}; };
#define \ #define nxt_mem_zone_page_addr(zone, page) \
nxt_mem_zone_page_addr(zone, page) \
(void *) (zone->start + ((page - zone->pages) << zone->page_size_shift)) (void *) (zone->start + ((page - zone->pages) << zone->page_size_shift))
#define \ #define nxt_mem_zone_addr_page(zone, addr) \
nxt_mem_zone_addr_page(zone, addr) \
&zone->pages[((u_char *) addr - zone->start) >> zone->page_size_shift] &zone->pages[((u_char *) addr - zone->start) >> zone->page_size_shift]
#define \ #define nxt_mem_zone_page_is_free(page) \
nxt_mem_zone_page_is_free(page) \
(page->size < NXT_MEM_ZONE_PAGE_USED) (page->size < NXT_MEM_ZONE_PAGE_USED)
#define \ #define nxt_mem_zone_page_is_chunked(page) \
nxt_mem_zone_page_is_chunked(page) \
(page->size >= 16) (page->size >= 16)
#define \ #define nxt_mem_zone_page_bitmap(zone, slot) \
nxt_mem_zone_page_bitmap(zone, slot) \
(slot->size < zone->small_bitmap_min_size) (slot->size < zone->small_bitmap_min_size)
#define \ #define nxt_mem_zone_set_chunk_free(map, chunk) \
nxt_mem_zone_set_chunk_free(map, chunk) \
map[chunk / 8] &= ~(0x80 >> (chunk & 7)) map[chunk / 8] &= ~(0x80 >> (chunk & 7))
#define \ #define nxt_mem_zone_chunk_is_free(map, chunk) \
nxt_mem_zone_chunk_is_free(map, chunk) \
((map[chunk / 8] & (0x80 >> (chunk & 7))) == 0) ((map[chunk / 8] & (0x80 >> (chunk & 7))) == 0)
#define \ #define nxt_mem_zone_fresh_junk(p, size) \
nxt_mem_zone_fresh_junk(p, size) \
nxt_memset((p), 0xA5, size) nxt_memset((p), 0xA5, size)
#define \ #define nxt_mem_zone_free_junk(p, size) \
nxt_mem_zone_free_junk(p, size) \
nxt_memset((p), 0x5A, size) nxt_memset((p), 0x5A, size)

3
src/nxt_mem_zone.h
View File

@@ -14,8 +14,7 @@ typedef struct nxt_mem_zone_s nxt_mem_zone_t;
NXT_EXPORT nxt_mem_zone_t *nxt_mem_zone_init(u_char *start, size_t zone_size, NXT_EXPORT nxt_mem_zone_t *nxt_mem_zone_init(u_char *start, size_t zone_size,
nxt_uint_t page_size); nxt_uint_t page_size);
#define \ #define nxt_mem_zone_alloc(zone, size) \
nxt_mem_zone_alloc(zone, size) \
nxt_mem_zone_align((zone), 1, (size)) nxt_mem_zone_align((zone), 1, (size))
NXT_EXPORT void *nxt_mem_zone_align(nxt_mem_zone_t *zone, size_t alignment, NXT_EXPORT void *nxt_mem_zone_align(nxt_mem_zone_t *zone, size_t alignment,

60
src/nxt_queue.h
View File

@@ -21,16 +21,14 @@ typedef struct {
} nxt_queue_t; } nxt_queue_t;
#define \ #define nxt_queue_init(queue) \
nxt_queue_init(queue) \
do { \ do { \
(queue)->head.prev = &(queue)->head; \ (queue)->head.prev = &(queue)->head; \
(queue)->head.next = &(queue)->head; \ (queue)->head.next = &(queue)->head; \
} while (0) } while (0)
#define \ #define nxt_queue_sentinel(link) \
nxt_queue_sentinel(link) \
do { \ do { \
(link)->prev = (link); \ (link)->prev = (link); \
(link)->next = (link); \ (link)->next = (link); \
@@ -42,13 +40,11 @@ nxt_queue_sentinel(link) \
* using nxt_queue_remove(). * using nxt_queue_remove().
*/ */
#define \ #define nxt_queue_self(link) \
nxt_queue_self(link) \
nxt_queue_sentinel(link) nxt_queue_sentinel(link)
#define \ #define nxt_queue_is_empty(queue) \
nxt_queue_is_empty(queue) \
(&(queue)->head == (queue)->head.prev) (&(queue)->head == (queue)->head.prev)
/* /*
@@ -73,38 +69,31 @@ nxt_queue_is_empty(queue) \
* tp = nxt_queue_link_data(lnk, nxt_type_t, link); * tp = nxt_queue_link_data(lnk, nxt_type_t, link);
*/ */
#define \ #define nxt_queue_first(queue) \
nxt_queue_first(queue) \
(queue)->head.next (queue)->head.next
#define \ #define nxt_queue_last(queue) \
nxt_queue_last(queue) \
(queue)->head.prev (queue)->head.prev
#define \ #define nxt_queue_head(queue) \
nxt_queue_head(queue) \
(&(queue)->head) (&(queue)->head)
#define \ #define nxt_queue_tail(queue) \
nxt_queue_tail(queue) \
(&(queue)->head) (&(queue)->head)
#define \ #define nxt_queue_next(link) \
nxt_queue_next(link) \
(link)->next (link)->next
#define \ #define nxt_queue_prev(link) \
nxt_queue_prev(link) \
(link)->prev (link)->prev
#define \ #define nxt_queue_insert_head(queue, link) \
nxt_queue_insert_head(queue, link) \
do { \ do { \
(link)->next = (queue)->head.next; \ (link)->next = (queue)->head.next; \
(link)->next->prev = (link); \ (link)->next->prev = (link); \
@@ -113,8 +102,7 @@ nxt_queue_insert_head(queue, link) \
} while (0) } while (0)
#define \ #define nxt_queue_insert_tail(queue, link) \
nxt_queue_insert_tail(queue, link) \
do { \ do { \
(link)->prev = (queue)->head.prev; \ (link)->prev = (queue)->head.prev; \
(link)->prev->next = (link); \ (link)->prev->next = (link); \
@@ -123,8 +111,7 @@ nxt_queue_insert_tail(queue, link) \
} while (0) } while (0)
#define \ #define nxt_queue_insert_after(target, link) \
nxt_queue_insert_after(target, link) \
do { \ do { \
(link)->next = (target)->next; \ (link)->next = (target)->next; \
(link)->next->prev = (link); \ (link)->next->prev = (link); \
@@ -133,8 +120,7 @@ nxt_queue_insert_after(target, link) \
} while (0) } while (0)
#define \ #define nxt_queue_insert_before(target, link) \
nxt_queue_insert_before(target, link) \
do { \ do { \
(link)->next = (target); \ (link)->next = (target); \
(link)->prev = (target)->prev; \ (link)->prev = (target)->prev; \
@@ -145,8 +131,7 @@ nxt_queue_insert_before(target, link) \
#if (NXT_DEBUG) #if (NXT_DEBUG)
#define \ #define nxt_queue_remove(link) \
nxt_queue_remove(link) \
do { \ do { \
(link)->next->prev = (link)->prev; \ (link)->next->prev = (link)->prev; \
(link)->prev->next = (link)->next; \ (link)->prev->next = (link)->next; \
@@ -156,8 +141,7 @@ nxt_queue_remove(link) \
#else #else
#define \ #define nxt_queue_remove(link) \
nxt_queue_remove(link) \
do { \ do { \
(link)->next->prev = (link)->prev; \ (link)->next->prev = (link)->prev; \
(link)->prev->next = (link)->next; \ (link)->prev->next = (link)->next; \
@@ -171,8 +155,7 @@ nxt_queue_remove(link) \
* the "tail" is the new tail queue. * the "tail" is the new tail queue.
*/ */
#define \ #define nxt_queue_split(queue, link, tail) \
nxt_queue_split(queue, link, tail) \
do { \ do { \
(tail)->head.prev = (queue)->head.prev; \ (tail)->head.prev = (queue)->head.prev; \
(tail)->head.prev->next = &(tail)->head; \ (tail)->head.prev->next = &(tail)->head; \
@@ -185,8 +168,7 @@ nxt_queue_split(queue, link, tail) \
/* Truncate the queue "queue" starting at element "link". */ /* Truncate the queue "queue" starting at element "link". */
#define \ #define nxt_queue_truncate(queue, link) \
nxt_queue_truncate(queue, link) \
do { \ do { \
(queue)->head.prev = (link)->prev; \ (queue)->head.prev = (link)->prev; \
(queue)->head.prev->next = &(queue)->head; \ (queue)->head.prev->next = &(queue)->head; \
@@ -199,8 +181,7 @@ nxt_queue_truncate(queue, link) \
* it must be initiated with nxt_queue_init(tail). * it must be initiated with nxt_queue_init(tail).
*/ */
#define \ #define nxt_queue_add(queue, tail) \
nxt_queue_add(queue, tail) \
do { \ do { \
(queue)->head.prev->next = (tail)->head.next; \ (queue)->head.prev->next = (tail)->head.next; \
(tail)->head.next->prev = (queue)->head.prev; \ (tail)->head.next->prev = (queue)->head.prev; \
@@ -209,8 +190,7 @@ nxt_queue_add(queue, tail) \
} while (0) } while (0)
#define \ #define nxt_queue_link_data(lnk, type, link) \
nxt_queue_link_data(lnk, type, link) \
nxt_container_of(lnk, type, link) nxt_container_of(lnk, type, link)

3
src/nxt_service.h
View File

@@ -15,8 +15,7 @@ typedef struct {
} nxt_service_t; } nxt_service_t;
#define \ #define nxt_service_is_module(s) \
nxt_service_is_module(s) \
((s)->type == NULL) ((s)->type == NULL)

6
src/nxt_signal.h
View File

@@ -36,12 +36,10 @@ typedef struct {
nxt_event_signals_t *nxt_event_engine_signals(const nxt_sig_event_t *sigev); nxt_event_signals_t *nxt_event_engine_signals(const nxt_sig_event_t *sigev);
#define \ #define nxt_event_engine_signals_start(engine) \
nxt_event_engine_signals_start(engine) \
nxt_signal_thread_start(engine) nxt_signal_thread_start(engine)
#define \ #define nxt_event_engine_signals_stop(engine) \
nxt_event_engine_signals_stop(engine) \
nxt_signal_thread_stop(engine) nxt_signal_thread_stop(engine)

6
src/nxt_socket.h
View File

@@ -118,12 +118,10 @@ NXT_EXPORT ssize_t nxt_socketpair_recv(nxt_fd_event_t *ev,
nxt_iobuf_t *iob, nxt_uint_t niob, void *oob); nxt_iobuf_t *iob, nxt_uint_t niob, void *oob);
#define \ #define nxt_socket_nonblocking(task, fd) \
nxt_socket_nonblocking(task, fd) \
nxt_fd_nonblocking(task, fd) nxt_fd_nonblocking(task, fd)
#define \ #define nxt_socket_blocking(task, fd) \
nxt_socket_blocking(task, fd) \
nxt_fd_blocking(task, fd) nxt_fd_blocking(task, fd)

3
src/nxt_source.h
View File

@@ -22,8 +22,7 @@ typedef void (*nxt_source_handler_t)(void *source_context,
nxt_source_hook_t *query); nxt_source_hook_t *query);
#define \ #define nxt_source_filter(thr, wq, task, next, out) \
nxt_source_filter(thr, wq, task, next, out) \
do { \ do { \
if (thr->engine->batch != 0) { \ if (thr->engine->batch != 0) { \
nxt_thread_work_queue_add(thr, wq, nxt_source_filter_handler, \ nxt_thread_work_queue_add(thr, wq, nxt_source_filter_handler, \

3
src/nxt_sprintf.c
View File

@@ -90,8 +90,7 @@ static u_char *nxt_number(nxt_sprintf_t *spf, u_char *buf, double n);
/* A right way of "f == 0.0". */ /* A right way of "f == 0.0". */
#define \ #define nxt_double_is_zero(f) \
nxt_double_is_zero(f) \
(fabs(f) <= FLT_EPSILON) (fabs(f) <= FLT_EPSILON)

69
src/nxt_string.h
View File

@@ -8,50 +8,40 @@
#define _NXT_STRING_H_INCLUDED_ #define _NXT_STRING_H_INCLUDED_
#define \ #define nxt_lowcase(c) \
nxt_lowcase(c) \
(u_char) ((c >= 'A' && c <= 'Z') ? c | 0x20 : c) (u_char) ((c >= 'A' && c <= 'Z') ? c | 0x20 : c)
#define \ #define nxt_upcase(c) \
nxt_upcase(c) \
(u_char) ((c >= 'a' && c <= 'z') ? c & ~0x20 : c) (u_char) ((c >= 'a' && c <= 'z') ? c & ~0x20 : c)
#define \ #define nxt_isdigit(c) \
nxt_isdigit(c) \
((u_char) ((c) - '0') <= 9) ((u_char) ((c) - '0') <= 9)
#define \ #define nxt_strtod(s, endptr) \
nxt_strtod(s, endptr) \
strtod((char *) s, (char **) endptr) strtod((char *) s, (char **) endptr)
#define \ #define nxt_strlen(s) \
nxt_strlen(s) \
strlen((char *) s) strlen((char *) s)
#define \ #define nxt_strdup(s) \
nxt_strdup(s) \
strdup((char *) s) strdup((char *) s)
#define \ #define nxt_strchr(buf, delim) \
nxt_strchr(buf, delim) \
(u_char *) strchr((char *) buf, delim) (u_char *) strchr((char *) buf, delim)
#define \ #define nxt_memzero(buf, length) \
nxt_memzero(buf, length) \
(void) memset(buf, 0, length) (void) memset(buf, 0, length)
#define \ #define nxt_memset(buf, c, length) \
nxt_memset(buf, c, length) \
(void) memset(buf, c, length) (void) memset(buf, c, length)
#define \ #define nxt_memcpy(dst, src, length) \
nxt_memcpy(dst, src, length) \
(void) memcpy(dst, src, length) (void) memcpy(dst, src, length)
@@ -72,28 +62,23 @@ nxt_cpymem(void *dst, const void *src, size_t length)
} }
#define \ #define nxt_memmove(dst, src, length) \
nxt_memmove(dst, src, length) \
(void) memmove(dst, src, length) (void) memmove(dst, src, length)
#define \ #define nxt_memcmp(s1, s2, length) \
nxt_memcmp(s1, s2, length) \
memcmp((char *) s1, (char *) s2, length) memcmp((char *) s1, (char *) s2, length)
#define \ #define nxt_memchr(s, c, length) \
nxt_memchr(s, c, length) \
memchr((char *) s, c, length) memchr((char *) s, c, length)
#define \ #define nxt_strcmp(s1, s2) \
nxt_strcmp(s1, s2) \
strcmp((char *) s1, (char *) s2) strcmp((char *) s1, (char *) s2)
#define \ #define nxt_strncmp(s1, s2, length) \
nxt_strncmp(s1, s2, length) \
strncmp((char *) s1, (char *) s2, length) strncmp((char *) s1, (char *) s2, length)
@@ -125,16 +110,14 @@ typedef struct {
#define nxt_null_string { 0, NULL } #define nxt_null_string { 0, NULL }
#define \ #define nxt_str_set(str, text) \
nxt_str_set(str, text) \
do { \ do { \
(str)->length = nxt_length(text); \ (str)->length = nxt_length(text); \
(str)->start = (u_char *) text; \ (str)->start = (u_char *) text; \
} while (0) } while (0)
#define \ #define nxt_str_null(str) \
nxt_str_null(str) \
do { \ do { \
(str)->length = 0; \ (str)->length = 0; \
(str)->start = NULL; \ (str)->start = NULL; \
@@ -147,35 +130,29 @@ NXT_EXPORT nxt_str_t *nxt_str_dup(nxt_mp_t *mp, nxt_str_t *dst,
NXT_EXPORT char *nxt_str_cstrz(nxt_mp_t *mp, const nxt_str_t *src); NXT_EXPORT char *nxt_str_cstrz(nxt_mp_t *mp, const nxt_str_t *src);
#define \ #define nxt_strstr_eq(s1, s2) \
nxt_strstr_eq(s1, s2) \
(((s1)->length == (s2)->length) \ (((s1)->length == (s2)->length) \
&& (nxt_memcmp((s1)->start, (s2)->start, (s1)->length) == 0)) && (nxt_memcmp((s1)->start, (s2)->start, (s1)->length) == 0))
#define \ #define nxt_strcasestr_eq(s1, s2) \
nxt_strcasestr_eq(s1, s2) \
(((s1)->length == (s2)->length) \ (((s1)->length == (s2)->length) \
&& (nxt_memcasecmp((s1)->start, (s2)->start, (s1)->length) == 0)) && (nxt_memcasecmp((s1)->start, (s2)->start, (s1)->length) == 0))
#define \ #define nxt_str_eq(s, p, _length) \
nxt_str_eq(s, p, _length) \
(((s)->length == _length) && (nxt_memcmp((s)->start, p, _length) == 0)) (((s)->length == _length) && (nxt_memcmp((s)->start, p, _length) == 0))
#define \ #define nxt_str_start(s, p, _length) \
nxt_str_start(s, p, _length) \
(((s)->length >= _length) && (nxt_memcmp((s)->start, p, _length) == 0)) (((s)->length >= _length) && (nxt_memcmp((s)->start, p, _length) == 0))
#define \ #define nxt_strchr_eq(s, c) \
nxt_strchr_eq(s, c) \
(((s)->length == 1) && ((s)->start[0] == c)) (((s)->length == 1) && ((s)->start[0] == c))
#define \ #define nxt_strchr_start(s, c) \
nxt_strchr_start(s, c) \
(((s)->length != 0) && ((s)->start[0] == c)) (((s)->length != 0) && ((s)->start[0] == c))

33
src/nxt_thread.h
View File

@@ -30,19 +30,15 @@
#if (NXT_HAVE_THREAD_STORAGE_CLASS) #if (NXT_HAVE_THREAD_STORAGE_CLASS)
#define \ #define nxt_thread_extern_data(type, tsd) \
nxt_thread_extern_data(type, tsd) \
NXT_EXPORT extern __thread type tsd NXT_EXPORT extern __thread type tsd
#define \ #define nxt_thread_declare_data(type, tsd) \
nxt_thread_declare_data(type, tsd) \
__thread type tsd __thread type tsd
#define \ #define nxt_thread_init_data(tsd)
nxt_thread_init_data(tsd)
#define \ #define nxt_thread_get_data(tsd) \
nxt_thread_get_data(tsd) \
&tsd &tsd
@@ -67,18 +63,15 @@ typedef struct {
} nxt_thread_specific_data_t[1]; } nxt_thread_specific_data_t[1];
#define \ #define nxt_thread_extern_data(type, tsd) \
nxt_thread_extern_data(type, tsd) \
NXT_EXPORT extern nxt_thread_specific_data_t tsd NXT_EXPORT extern nxt_thread_specific_data_t tsd
#define \ #define nxt_thread_declare_data(type, tsd) \
nxt_thread_declare_data(type, tsd) \
nxt_thread_specific_data_t tsd = { { (nxt_atomic_int_t) -1, sizeof(type) } } nxt_thread_specific_data_t tsd = { { (nxt_atomic_int_t) -1, sizeof(type) } }
NXT_EXPORT void nxt_thread_init_data(nxt_thread_specific_data_t tsd); NXT_EXPORT void nxt_thread_init_data(nxt_thread_specific_data_t tsd);
#define \ #define nxt_thread_get_data(tsd) \
nxt_thread_get_data(tsd) \
pthread_getspecific((pthread_key_t) tsd->key) pthread_getspecific((pthread_key_t) tsd->key)
#endif #endif
@@ -101,8 +94,7 @@ NXT_EXPORT void nxt_thread_cancel(nxt_thread_handle_t handle);
NXT_EXPORT void nxt_thread_wait(nxt_thread_handle_t handle); NXT_EXPORT void nxt_thread_wait(nxt_thread_handle_t handle);
#define \ #define nxt_thread_handle() \
nxt_thread_handle() \
pthread_self() pthread_self()
@@ -125,18 +117,15 @@ NXT_EXPORT nxt_err_t nxt_thread_cond_wait(nxt_thread_cond_t *cond,
#if (NXT_HAVE_PTHREAD_YIELD) #if (NXT_HAVE_PTHREAD_YIELD)
#define \ #define nxt_thread_yield() \
nxt_thread_yield() \
pthread_yield() pthread_yield()
#elif (NXT_HAVE_PTHREAD_YIELD_NP) #elif (NXT_HAVE_PTHREAD_YIELD_NP)
#define \ #define nxt_thread_yield() \
nxt_thread_yield() \
pthread_yield_np() pthread_yield_np()
#else #else
#define \ #define nxt_thread_yield() \
nxt_thread_yield() \
nxt_sched_yield() nxt_sched_yield()
#endif #endif

6
src/nxt_thread_id.h
View File

@@ -179,12 +179,10 @@ NXT_EXPORT nxt_tid_t nxt_thread_tid(nxt_thread_t *thr);
typedef pthread_t nxt_thread_handle_t; typedef pthread_t nxt_thread_handle_t;
#define \ #define nxt_thread_handle_clear(th) \
nxt_thread_handle_clear(th) \
th = (pthread_t) 0 th = (pthread_t) 0
#define \ #define nxt_thread_handle_equal(th0, th1) \
nxt_thread_handle_equal(th0, th1) \
pthread_equal(th0, th1) pthread_equal(th0, th1)

9
src/nxt_thread_time.h
View File

@@ -70,21 +70,18 @@ NXT_EXPORT u_char *nxt_thread_time_string(nxt_thread_t *thr,
void nxt_time_thread_start(nxt_msec_t interval); void nxt_time_thread_start(nxt_msec_t interval);
#define \ #define nxt_thread_monotonic_time(thr) \
nxt_thread_monotonic_time(thr) \
(thr)->time.now.monotonic (thr)->time.now.monotonic
#if (NXT_DEBUG) #if (NXT_DEBUG)
#define \ #define nxt_thread_time_debug_update(thr) \
nxt_thread_time_debug_update(thr) \
nxt_thread_time_update(thr) nxt_thread_time_update(thr)
#else #else
#define \ #define nxt_thread_time_debug_update(thr)
nxt_thread_time_debug_update(thr)
#endif #endif

12
src/nxt_time.h
View File

@@ -74,20 +74,17 @@ NXT_EXPORT void nxt_timezone_update(void);
#if (NXT_HAVE_TM_GMTOFF) #if (NXT_HAVE_TM_GMTOFF)
#define \ #define nxt_timezone(tm) \
nxt_timezone(tm) \
((tm)->tm_gmtoff) ((tm)->tm_gmtoff)
#elif (NXT_HAVE_ALTZONE) #elif (NXT_HAVE_ALTZONE)
#define \ #define nxt_timezone(tm) \
nxt_timezone(tm) \
(-(((tm)->tm_isdst > 0) ? altzone : timezone)) (-(((tm)->tm_isdst > 0) ? altzone : timezone))
#else #else
#define \ #define nxt_timezone(tm) \
nxt_timezone(tm) \
(-(((tm)->tm_isdst > 0) ? timezone + 3600 : timezone)) (-(((tm)->tm_isdst > 0) ? timezone + 3600 : timezone))
#endif #endif
@@ -103,8 +100,7 @@ typedef int32_t nxt_msec_int_t;
* every 49 days. This signed subtraction takes into account that overflow. * every 49 days. This signed subtraction takes into account that overflow.
* "nxt_msec_diff(m1, m2) < 0" means that m1 is lesser than m2. * "nxt_msec_diff(m1, m2) < 0" means that m1 is lesser than m2.
*/ */
#define \ #define nxt_msec_diff(m1, m2) \
nxt_msec_diff(m1, m2) \
((int32_t) ((m1) - (m2))) ((int32_t) ((m1) - (m2)))

12
src/nxt_unix.h
View File

@@ -275,23 +275,19 @@
typedef struct iovec nxt_iobuf_t; typedef struct iovec nxt_iobuf_t;
#define \ #define nxt_iobuf_data(iob) \
nxt_iobuf_data(iob) \
(iob)->iov_base (iob)->iov_base
#define \ #define nxt_iobuf_size(iob) \
nxt_iobuf_size(iob) \
(iob)->iov_len (iob)->iov_len
#define \ #define nxt_iobuf_set(iob, p, size) \
nxt_iobuf_set(iob, p, size) \
do { \ do { \
(iob)->iov_base = (void *) p; \ (iob)->iov_base = (void *) p; \
(iob)->iov_len = size; \ (iob)->iov_len = size; \
} while (0) } while (0)
#define \ #define nxt_iobuf_add(iob, size) \
nxt_iobuf_add(iob, size) \
(iob)->iov_len += size (iob)->iov_len += size

9
src/nxt_vector.h
View File

@@ -41,19 +41,16 @@ NXT_EXPORT void *nxt_vector_zero_add(nxt_vector_t *vector,
NXT_EXPORT void nxt_vector_remove(nxt_vector_t *vector, void *item); NXT_EXPORT void nxt_vector_remove(nxt_vector_t *vector, void *item);
#define \ #define nxt_vector_last(vector) \
nxt_vector_last(vector) \
nxt_pointer_to((vector)->start, \ nxt_pointer_to((vector)->start, \
(vector)->item_size * ((vector)->items - 1)) (vector)->item_size * ((vector)->items - 1))
#define \ #define nxt_vector_reset(vector) \
nxt_vector_reset(vector) \
(vector)->items = 0; (vector)->items = 0;
#define \ #define nxt_vector_is_empty(vector) \
nxt_vector_is_empty(vector) \
((vector)->items == 0) ((vector)->items == 0)

3
src/nxt_work_queue.h
View File

@@ -109,8 +109,7 @@ NXT_EXPORT void nxt_work_queue_thread_adopt(nxt_work_queue_t *wq);
#else #else
#define \ #define nxt_work_queue_name(_wq, _name)
nxt_work_queue_name(_wq, _name)
#define nxt_work_queue_thread_adopt(_wq) #define nxt_work_queue_thread_adopt(_wq)

6
src/test/nxt_rbtree1_test.c
View File

@@ -9,13 +9,11 @@
#include "nxt_rbtree1.h" #include "nxt_rbtree1.h"
#define \ #define nxt_rbtree1_is_empty(tree) \
nxt_rbtree1_is_empty(tree) \
(((tree)->root) == (tree)->sentinel) (((tree)->root) == (tree)->sentinel)
#define \ #define nxt_rbtree1_is_there_successor(tree, node) \
nxt_rbtree1_is_there_successor(tree, node) \
((node) != (tree)->sentinel) ((node) != (tree)->sentinel)