mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 05:58:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: enable formatting for files under lib

Browse Source
This commit is contained in:
Dundar Göc
2021-10-12 17:23:50 +02:00
parent 29b718d04c
commit f98b8d2d44
6 changed files with 986 additions and 964 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src/nvim/lib/kbtree.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
/*- /*-
* Copyright 1997-1999, 2001, John-Mark Gurney. * Copyright 1997-1999, 2001, John-Mark Gurney.
* 2008-2009, Attractive Chaos <attractor@live.co.uk> * 2008-2009, Attractive Chaos <attractor@live.co.uk>
@@ -36,10 +34,10 @@
#ifndef NVIM_LIB_KBTREE_H #ifndef NVIM_LIB_KBTREE_H
#define NVIM_LIB_KBTREE_H #define NVIM_LIB_KBTREE_H
#include <assert.h>
#include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdint.h>
#include <assert.h>
#include "nvim/memory.h" #include "nvim/memory.h"
@@ -48,7 +46,7 @@
#define __KB_KEY(type, x) (x->key) #define __KB_KEY(type, x) (x->key)
#define __KB_PTR(btr, x) (x->ptr) #define __KB_PTR(btr, x) (x->ptr)
#define __KB_TREE_T(name,key_t,T) \ #define __KB_TREE_T(name, key_t, T) \
typedef struct kbnode_##name##_s kbnode_##name##_t; \ typedef struct kbnode_##name##_s kbnode_##name##_t; \
struct kbnode_##name##_s { \ struct kbnode_##name##_s { \
int32_t n; \ int32_t n; \
@@ -71,12 +69,12 @@
} kbitr_##name##_t; \ } kbitr_##name##_t; \
#define __kb_destroy(kbnode_t,b) do { \ #define __kb_destroy(kbnode_t, b) do { \
int i; \ int i; \
unsigned int max = 8; \ unsigned int max = 8; \
kbnode_t *x, **top, **stack = 0; \ kbnode_t *x, **top, **stack = 0; \
if (b->root) { \ if (b->root) { \
top = stack = (kbnode_t**)xcalloc(max, sizeof(kbnode_t*)); \ top = stack = (kbnode_t **)xcalloc(max, sizeof(kbnode_t *)); \
*top++ = (b)->root; \ *top++ = (b)->root; \
while (top != stack) { \ while (top != stack) { \
x = *--top; \ x = *--top; \
@@ -85,7 +83,7 @@
if (__KB_PTR(b, x)[i]) { \ if (__KB_PTR(b, x)[i]) { \
if (top - stack == (int)max) { \ if (top - stack == (int)max) { \
max <<= 1; \ max <<= 1; \
stack = (kbnode_t**)xrealloc(stack, max * sizeof(kbnode_t*)); \ stack = (kbnode_t **)xrealloc(stack, max * sizeof(kbnode_t *)); \
top = stack + (max>>1); \ top = stack + (max>>1); \
} \ } \
*top++ = __KB_PTR(b, x)[i]; \ *top++ = __KB_PTR(b, x)[i]; \
@@ -94,10 +92,11 @@
} \ } \
} \ } \
XFREE_CLEAR(stack); \ XFREE_CLEAR(stack); \
} while (0) } while (0)
#define __KB_GET_AUX1(name, key_t, kbnode_t, __cmp) \ #define __KB_GET_AUX1(name, key_t, kbnode_t, __cmp) \
static inline int __kb_getp_aux_##name(const kbnode_t * __restrict x, key_t * __restrict k, int *r) \ static inline int __kb_getp_aux_##name(const kbnode_t * __restrict x, key_t * __restrict k, \
int *r) \
{ \ { \
int tr, *rr, begin = 0, end = x->n; \ int tr, *rr, begin = 0, end = x->n; \
if (x->n == 0) return -1; \ if (x->n == 0) return -1; \
@@ -134,7 +133,8 @@
} }
#define __KB_INTERVAL(name, key_t, kbnode_t) \ #define __KB_INTERVAL(name, key_t, kbnode_t) \
static inline void kb_intervalp_##name(kbtree_##name##_t *b, key_t * __restrict k, key_t **lower, key_t **upper) \ static inline void kb_intervalp_##name(kbtree_##name##_t *b, key_t * __restrict k, key_t **lower, \
key_t **upper) \
{ \ { \
if (!b->root) { \ if (!b->root) { \
return; \ return; \
@@ -164,16 +164,18 @@
static inline void __kb_split_##name(kbtree_##name##_t *b, kbnode_t *x, int i, kbnode_t *y) \ static inline void __kb_split_##name(kbtree_##name##_t *b, kbnode_t *x, int i, kbnode_t *y) \
{ \ { \
kbnode_t *z; \ kbnode_t *z; \
z = (kbnode_t*)xcalloc(1, y->is_internal? ILEN : sizeof(kbnode_##name##_t)); \ z = (kbnode_t *)xcalloc(1, y->is_internal? ILEN : sizeof(kbnode_##name##_t)); \
++b->n_nodes; \ ++b->n_nodes; \
z->is_internal = y->is_internal; \ z->is_internal = y->is_internal; \
z->n = T - 1; \ z->n = T - 1; \
memcpy(__KB_KEY(key_t, z), &__KB_KEY(key_t, y)[T], sizeof(key_t) * (T - 1)); \ memcpy(__KB_KEY(key_t, z), &__KB_KEY(key_t, y)[T], sizeof(key_t) * (T - 1)); \
if (y->is_internal) memcpy(__KB_PTR(b, z), &__KB_PTR(b, y)[T], sizeof(void*) * T); \ if (y->is_internal) memcpy(__KB_PTR(b, z), &__KB_PTR(b, y)[T], sizeof(void *) * T); \
y->n = T - 1; \ y->n = T - 1; \
memmove(&__KB_PTR(b, x)[i + 2], &__KB_PTR(b, x)[i + 1], sizeof(void*) * (unsigned int)(x->n - i)); \ memmove(&__KB_PTR(b, x)[i + 2], &__KB_PTR(b, \
x)[i + 1], sizeof(void *) * (unsigned int)(x->n - i)); \
__KB_PTR(b, x)[i + 1] = z; \ __KB_PTR(b, x)[i + 1] = z; \
memmove(&__KB_KEY(key_t, x)[i + 1], &__KB_KEY(key_t, x)[i], sizeof(key_t) * (unsigned int)(x->n - i)); \ memmove(&__KB_KEY(key_t, x)[i + 1], &__KB_KEY(key_t, x)[i], \
sizeof(key_t) * (unsigned int)(x->n - i)); \
__KB_KEY(key_t, x)[i] = __KB_KEY(key_t, y)[T - 1]; \ __KB_KEY(key_t, x)[i] = __KB_KEY(key_t, y)[T - 1]; \
++x->n; \ ++x->n; \
} \ } \
@@ -184,7 +186,9 @@
if (x->is_internal == 0) { \ if (x->is_internal == 0) { \
i = __kb_getp_aux_##name(x, k, 0); \ i = __kb_getp_aux_##name(x, k, 0); \
if (i != x->n - 1) \ if (i != x->n - 1) \
memmove(&__KB_KEY(key_t, x)[i + 2], &__KB_KEY(key_t, x)[i + 1], (unsigned int)(x->n - i - 1) * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, x)[i + 2], &__KB_KEY(key_t, \
x)[i + 1], \
(unsigned int)(x->n - i - 1) * sizeof(key_t)); \
ret = &__KB_KEY(key_t, x)[i + 1]; \ ret = &__KB_KEY(key_t, x)[i + 1]; \
*ret = *k; \ *ret = *k; \
++x->n; \ ++x->n; \
@@ -201,7 +205,7 @@
static inline key_t *kb_putp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ static inline key_t *kb_putp_##name(kbtree_##name##_t *b, key_t * __restrict k) \
{ \ { \
if (!b->root) { \ if (!b->root) { \
b->root = (kbnode_t*)xcalloc(1, ILEN); \ b->root = (kbnode_t *)xcalloc(1, ILEN); \
++b->n_nodes; \ ++b->n_nodes; \
} \ } \
kbnode_t *r, *s; \ kbnode_t *r, *s; \
@@ -209,7 +213,7 @@
r = b->root; \ r = b->root; \
if (r->n == 2 * T - 1) { \ if (r->n == 2 * T - 1) { \
++b->n_nodes; \ ++b->n_nodes; \
s = (kbnode_t*)xcalloc(1, ILEN); \ s = (kbnode_t *)xcalloc(1, ILEN); \
b->root = s; s->is_internal = 1; s->n = 0; \ b->root = s; s->is_internal = 1; s->n = 0; \
__KB_PTR(b, s)[0] = r; \ __KB_PTR(b, s)[0] = r; \
__kb_split_##name(b, s, 0, r); \ __kb_split_##name(b, s, 0, r); \
@@ -224,7 +228,8 @@
#define __KB_DEL(name, key_t, kbnode_t, T) \ #define __KB_DEL(name, key_t, kbnode_t, T) \
static inline key_t __kb_delp_aux_##name(kbtree_##name##_t *b, kbnode_t *x, key_t * __restrict k, int s) \ static inline key_t __kb_delp_aux_##name(kbtree_##name##_t *b, kbnode_t *x, key_t * __restrict k, \
int s) \
{ \ { \
int yn, zn, i, r = 0; \ int yn, zn, i, r = 0; \
kbnode_t *xp, *y, *z; \ kbnode_t *xp, *y, *z; \
@@ -237,7 +242,9 @@
if (x->is_internal == 0) { \ if (x->is_internal == 0) { \
if (s == 2) ++i; \ if (s == 2) ++i; \
kp = __KB_KEY(key_t, x)[i]; \ kp = __KB_KEY(key_t, x)[i]; \
memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, x)[i + 1], (unsigned int)(x->n - i - 1) * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, \
x)[i + 1], \
(unsigned int)(x->n - i - 1) * sizeof(key_t)); \
--x->n; \ --x->n; \
return kp; \ return kp; \
} \ } \
@@ -256,10 +263,16 @@
y = __KB_PTR(b, x)[i]; z = __KB_PTR(b, x)[i + 1]; \ y = __KB_PTR(b, x)[i]; z = __KB_PTR(b, x)[i + 1]; \
__KB_KEY(key_t, y)[y->n++] = *k; \ __KB_KEY(key_t, y)[y->n++] = *k; \
memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, z), (unsigned int)z->n * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, z), (unsigned int)z->n * sizeof(key_t)); \
if (y->is_internal) memmove(&__KB_PTR(b, y)[y->n], __KB_PTR(b, z), (unsigned int)(z->n + 1) * sizeof(void*)); \ if (y->is_internal) memmove(&__KB_PTR(b, y)[y->n], __KB_PTR(b, \
z), \
(unsigned int)(z->n + 1) * sizeof(void *)); \
y->n += z->n; \ y->n += z->n; \
memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, x)[i + 1], (unsigned int)(x->n - i - 1) * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, \
memmove(&__KB_PTR(b, x)[i + 1], &__KB_PTR(b, x)[i + 2], (unsigned int)(x->n - i - 1) * sizeof(void*)); \ x)[i + 1], \
(unsigned int)(x->n - i - 1) * sizeof(key_t)); \
memmove(&__KB_PTR(b, x)[i + 1], &__KB_PTR(b, \
x)[i + 2], \
(unsigned int)(x->n - i - 1) * sizeof(void *)); \
--x->n; \ --x->n; \
XFREE_CLEAR(z); \ XFREE_CLEAR(z); \
return __kb_delp_aux_##name(b, y, k, s); \ return __kb_delp_aux_##name(b, y, k, s); \
@@ -269,7 +282,9 @@
if ((xp = __KB_PTR(b, x)[i])->n == T - 1) { \ if ((xp = __KB_PTR(b, x)[i])->n == T - 1) { \
if (i > 0 && (y = __KB_PTR(b, x)[i - 1])->n >= T) { \ if (i > 0 && (y = __KB_PTR(b, x)[i - 1])->n >= T) { \
memmove(&__KB_KEY(key_t, xp)[1], __KB_KEY(key_t, xp), (unsigned int)xp->n * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, xp)[1], __KB_KEY(key_t, xp), (unsigned int)xp->n * sizeof(key_t)); \
if (xp->is_internal) memmove(&__KB_PTR(b, xp)[1], __KB_PTR(b, xp), (unsigned int)(xp->n + 1) * sizeof(void*)); \ if (xp->is_internal) memmove(&__KB_PTR(b, xp)[1], __KB_PTR(b, \
xp), \
(unsigned int)(xp->n + 1) * sizeof(void *)); \
__KB_KEY(key_t, xp)[0] = __KB_KEY(key_t, x)[i - 1]; \ __KB_KEY(key_t, xp)[0] = __KB_KEY(key_t, x)[i - 1]; \
__KB_KEY(key_t, x)[i - 1] = __KB_KEY(key_t, y)[y->n - 1]; \ __KB_KEY(key_t, x)[i - 1] = __KB_KEY(key_t, y)[y->n - 1]; \
if (xp->is_internal) __KB_PTR(b, xp)[0] = __KB_PTR(b, y)[y->n]; \ if (xp->is_internal) __KB_PTR(b, xp)[0] = __KB_PTR(b, y)[y->n]; \
@@ -280,24 +295,38 @@
if (xp->is_internal) __KB_PTR(b, xp)[xp->n] = __KB_PTR(b, y)[0]; \ if (xp->is_internal) __KB_PTR(b, xp)[xp->n] = __KB_PTR(b, y)[0]; \
--y->n; \ --y->n; \
memmove(__KB_KEY(key_t, y), &__KB_KEY(key_t, y)[1], (unsigned int)y->n * sizeof(key_t)); \ memmove(__KB_KEY(key_t, y), &__KB_KEY(key_t, y)[1], (unsigned int)y->n * sizeof(key_t)); \
if (y->is_internal) memmove(__KB_PTR(b, y), &__KB_PTR(b, y)[1], (unsigned int)(y->n + 1) * sizeof(void*)); \ if (y->is_internal) memmove(__KB_PTR(b, y), &__KB_PTR(b, \
y)[1], \
(unsigned int)(y->n + 1) * sizeof(void *)); \
} else if (i > 0 && (y = __KB_PTR(b, x)[i - 1])->n == T - 1) { \ } else if (i > 0 && (y = __KB_PTR(b, x)[i - 1])->n == T - 1) { \
__KB_KEY(key_t, y)[y->n++] = __KB_KEY(key_t, x)[i - 1]; \ __KB_KEY(key_t, y)[y->n++] = __KB_KEY(key_t, x)[i - 1]; \
memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, xp), (unsigned int)xp->n * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, xp), \
if (y->is_internal) memmove(&__KB_PTR(b, y)[y->n], __KB_PTR(b, xp), (unsigned int)(xp->n + 1) * sizeof(void*)); \ (unsigned int)xp->n * sizeof(key_t)); \
if (y->is_internal) memmove(&__KB_PTR(b, y)[y->n], __KB_PTR(b, \
xp), \
(unsigned int)(xp->n + 1) * sizeof(void *)); \
y->n += xp->n; \ y->n += xp->n; \
memmove(&__KB_KEY(key_t, x)[i - 1], &__KB_KEY(key_t, x)[i], (unsigned int)(x->n - i) * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, x)[i - 1], &__KB_KEY(key_t, \
memmove(&__KB_PTR(b, x)[i], &__KB_PTR(b, x)[i + 1], (unsigned int)(x->n - i) * sizeof(void*)); \ x)[i], \
(unsigned int)(x->n - i) * sizeof(key_t)); \
memmove(&__KB_PTR(b, x)[i], &__KB_PTR(b, \
x)[i + 1], (unsigned int)(x->n - i) * sizeof(void *)); \
--x->n; \ --x->n; \
XFREE_CLEAR(xp); \ XFREE_CLEAR(xp); \
xp = y; \ xp = y; \
} else if (i < x->n && (y = __KB_PTR(b, x)[i + 1])->n == T - 1) { \ } else if (i < x->n && (y = __KB_PTR(b, x)[i + 1])->n == T - 1) { \
__KB_KEY(key_t, xp)[xp->n++] = __KB_KEY(key_t, x)[i]; \ __KB_KEY(key_t, xp)[xp->n++] = __KB_KEY(key_t, x)[i]; \
memmove(&__KB_KEY(key_t, xp)[xp->n], __KB_KEY(key_t, y), (unsigned int)y->n * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, xp)[xp->n], __KB_KEY(key_t, y), \
if (xp->is_internal) memmove(&__KB_PTR(b, xp)[xp->n], __KB_PTR(b, y), (unsigned int)(y->n + 1) * sizeof(void*)); \ (unsigned int)y->n * sizeof(key_t)); \
if (xp->is_internal) memmove(&__KB_PTR(b, xp)[xp->n], __KB_PTR(b, y), \
(unsigned int)(y->n + 1) * sizeof(void *)); \
xp->n += y->n; \ xp->n += y->n; \
memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, x)[i + 1], (unsigned int)(x->n - i - 1) * sizeof(key_t)); \ memmove(&__KB_KEY(key_t, x)[i], &__KB_KEY(key_t, \
memmove(&__KB_PTR(b, x)[i + 1], &__KB_PTR(b, x)[i + 2], (unsigned int)(x->n - i - 1) * sizeof(void*)); \ x)[i + 1], \
(unsigned int)(x->n - i - 1) * sizeof(key_t)); \
memmove(&__KB_PTR(b, x)[i + 1], &__KB_PTR(b, \
x)[i + 2], \
(unsigned int)(x->n - i - 1) * sizeof(void *)); \
--x->n; \ --x->n; \
XFREE_CLEAR(y); \ XFREE_CLEAR(y); \
} \ } \
@@ -373,7 +402,8 @@
if (itr->p->x && itr->p->i >= 0) return 1; \ if (itr->p->x && itr->p->i >= 0) return 1; \
} \ } \
} \ } \
static inline int kb_itr_getp_##name(kbtree_##name##_t *b, key_t * __restrict k, kbitr_##name##_t *itr) \ static inline int kb_itr_getp_##name(kbtree_##name##_t *b, key_t * __restrict k, \
kbitr_##name##_t *itr) \
{ \ { \
if (b->n_keys == 0) { \ if (b->n_keys == 0) { \
itr->p = NULL; \ itr->p = NULL; \
@@ -396,7 +426,7 @@
} \ } \
static inline int kb_itr_get_##name(kbtree_##name##_t *b, key_t k, kbitr_##name##_t *itr) \ static inline int kb_itr_get_##name(kbtree_##name##_t *b, key_t k, kbitr_##name##_t *itr) \
{ \ { \
return kb_itr_getp_##name(b,&k,itr); \ return kb_itr_getp_##name(b, &k, itr); \
} \ } \
static inline void kb_del_itr_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ static inline void kb_del_itr_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \
{ \ { \
@@ -406,7 +436,8 @@
} }
#define KBTREE_INIT(name, key_t, __cmp, T) \ #define KBTREE_INIT(name, key_t, __cmp, T) \
KBTREE_INIT_IMPL(name, key_t, kbnode_##name##_t, __cmp, T, (sizeof(kbnode_##name##_t)+(2*T)*sizeof(void *))) KBTREE_INIT_IMPL(name, key_t, kbnode_##name##_t, __cmp, T, \
(sizeof(kbnode_##name##_t)+(2*T)*sizeof(void *)))
#define KBTREE_INIT_IMPL(name, key_t, kbnode_t, __cmp, T, ILEN) \ #define KBTREE_INIT_IMPL(name, key_t, kbnode_t, __cmp, T, ILEN) \
__KB_TREE_T(name, key_t, T) \ __KB_TREE_T(name, key_t, T) \

77
src/nvim/lib/khash.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
/* The MIT License /* The MIT License
Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk> Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
@@ -23,14 +21,14 @@
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. SOFTWARE.
*/ */
/* /*
Example: Example:
#include "nvim/khash.h" #include "nvim/khash.h"
KHASH_MAP_INIT_INT(32, char) KHASH_MAP_INIT_INT(32, char)
int main() { int main() {
int ret, is_missing; int ret, is_missing;
khiter_t k; khiter_t k;
khash_t(32) *h = kh_init(32); khash_t(32) *h = kh_init(32);
@@ -44,8 +42,8 @@ int main() {
if (kh_exist(h, k)) kh_value(h, k) = 1; if (kh_exist(h, k)) kh_value(h, k) = 1;
kh_destroy(32, h); kh_destroy(32, h);
return 0; return 0;
} }
*/ */
/* /*
2013-05-02 (0.2.8): 2013-05-02 (0.2.8):
@@ -113,7 +111,7 @@ int main() {
2008-08-31 (0.1.1): 2008-08-31 (0.1.1):
* Added destructor * Added destructor
*/ */
#ifndef NVIM_LIB_KHASH_H #ifndef NVIM_LIB_KHASH_H
@@ -127,16 +125,15 @@ int main() {
#define AC_VERSION_KHASH_H "0.2.8" #define AC_VERSION_KHASH_H "0.2.8"
#include <stdlib.h>
#include <string.h>
#include <limits.h> #include <limits.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h>
#include "nvim/memory.h" #include <string.h>
#include "nvim/func_attr.h" #include "nvim/func_attr.h"
#include "nvim/memory.h"
/* compiler specific configuration */ // compiler specific configuration
#if UINT_MAX == 0xffffffffu #if UINT_MAX == 0xffffffffu
typedef unsigned int khint32_t; typedef unsigned int khint32_t;
@@ -151,9 +148,9 @@ typedef unsigned long long khint64_t;
#endif #endif
#ifdef _MSC_VER #ifdef _MSC_VER
#define kh_inline __inline # define kh_inline __inline
#else #else
#define kh_inline inline # define kh_inline inline
#endif #endif
typedef khint32_t khint_t; typedef khint32_t khint_t;
@@ -170,20 +167,21 @@ typedef khint_t khiter_t;
#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4) #define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
#ifndef kroundup32 #ifndef kroundup32
#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x)) # define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, \
++(x))
#endif #endif
#ifndef kcalloc #ifndef kcalloc
#define kcalloc(N,Z) xcalloc(N,Z) # define kcalloc(N, Z) xcalloc(N, Z)
#endif #endif
#ifndef kmalloc #ifndef kmalloc
#define kmalloc(Z) xmalloc(Z) # define kmalloc(Z) xmalloc(Z)
#endif #endif
#ifndef krealloc #ifndef krealloc
#define krealloc(P,Z) xrealloc(P,Z) # define krealloc(P, Z) xrealloc(P, Z)
#endif #endif
#ifndef kfree #ifndef kfree
#define kfree(P) XFREE_CLEAR(P) # define kfree(P) XFREE_CLEAR(P)
#endif #endif
#define __ac_HASH_UPPER 0.77 #define __ac_HASH_UPPER 0.77
@@ -211,7 +209,7 @@ typedef khint_t khiter_t;
SCOPE kh_##name##_t *kh_init_##name(void) \ SCOPE kh_##name##_t *kh_init_##name(void) \
REAL_FATTR_UNUSED; \ REAL_FATTR_UNUSED; \
SCOPE kh_##name##_t *kh_init_##name(void) { \ SCOPE kh_##name##_t *kh_init_##name(void) { \
return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t)); \ return (kh_##name##_t *)kcalloc(1, sizeof(kh_##name##_t)); \
} \ } \
SCOPE void kh_dealloc_##name(kh_##name##_t *h) \ SCOPE void kh_dealloc_##name(kh_##name##_t *h) \
REAL_FATTR_UNUSED; \ REAL_FATTR_UNUSED; \
@@ -276,17 +274,16 @@ typedef khint_t khiter_t;
if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) { \ if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) { \
j = 0; \ j = 0; \
} else { /* hash table size to be changed (shrink or expand); rehash */ \ } else { /* hash table size to be changed (shrink or expand); rehash */ \
new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) \ new_flags = (khint32_t *)kmalloc(__ac_fsize(new_n_buckets) \
* sizeof(khint32_t)); \ * sizeof(khint32_t)); \
memset(new_flags, 0xaa, \ memset(new_flags, 0xaa, \
__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
if (h->n_buckets < new_n_buckets) { /* expand */ \ if (h->n_buckets < new_n_buckets) { /* expand */ \
khkey_t *new_keys = (khkey_t*)krealloc( \ khkey_t *new_keys = (khkey_t *)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
(void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
h->keys = new_keys; \ h->keys = new_keys; \
if (kh_is_map) { \ if (kh_is_map) { \
khval_t *new_vals = (khval_t*)krealloc( \ khval_t *new_vals = \
(void *)h->vals, new_n_buckets * sizeof(khval_t)); \ (khval_t *)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
h->vals = new_vals; \ h->vals = new_vals; \
} \ } \
} /* otherwise shrink */ \ } /* otherwise shrink */ \
@@ -337,10 +334,10 @@ typedef khint_t khiter_t;
} \ } \
} \ } \
if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \ if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
h->keys = (khkey_t*)krealloc((void *)h->keys, \ h->keys = (khkey_t *)krealloc((void *)h->keys, \
new_n_buckets * sizeof(khkey_t)); \ new_n_buckets * sizeof(khkey_t)); \
if (kh_is_map) { \ if (kh_is_map) { \
h->vals = (khval_t*)krealloc((void *)h->vals, \ h->vals = (khval_t *)krealloc((void *)h->vals, \
new_n_buckets * sizeof(khval_t)); \ new_n_buckets * sizeof(khval_t)); \
} \ } \
} \ } \
@@ -431,7 +428,7 @@ typedef khint_t khiter_t;
#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ #define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
/* --- BEGIN OF HASH FUNCTIONS --- */ // --- BEGIN OF HASH FUNCTIONS ---
/*! @function /*! @function
@abstract Integer hash function @abstract Integer hash function
@@ -461,7 +458,9 @@ typedef khint_t khiter_t;
static kh_inline khint_t __ac_X31_hash_string(const char *s) static kh_inline khint_t __ac_X31_hash_string(const char *s)
{ {
khint_t h = (khint_t)*s; khint_t h = (khint_t)*s;
if (h) for (++s ; *s; ++s) h = (h << 5) - h + (uint8_t)*s; if (h) {
for (++s ; *s; ++s) { h = (h << 5) - h + (uint8_t)*s; }
}
return h; return h;
} }
/*! @function /*! @function
@@ -487,9 +486,9 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
} }
#define kh_int_hash_func2(k) __ac_Wang_hash((khint_t)key) #define kh_int_hash_func2(k) __ac_Wang_hash((khint_t)key)
/* --- END OF HASH FUNCTIONS --- */ // --- END OF HASH FUNCTIONS ---
/* Other convenient macros... */ // Other convenient macros...
/*! /*!
@abstract Type of the hash table. @abstract Type of the hash table.
@@ -630,9 +629,9 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
*/ */
#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \ #define kh_foreach(h, kvar, vvar, code) { khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h,__i)) continue; \ if (!kh_exist(h, __i)) continue; \
(kvar) = kh_key(h,__i); \ (kvar) = kh_key(h, __i); \
(vvar) = kh_val(h,__i); \ (vvar) = kh_val(h, __i); \
code; \ code; \
} } } }
@@ -644,8 +643,8 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
*/ */
#define kh_foreach_value(h, vvar, code) { khint_t __i; \ #define kh_foreach_value(h, vvar, code) { khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h,__i)) continue; \ if (!kh_exist(h, __i)) continue; \
(vvar) = kh_val(h,__i); \ (vvar) = kh_val(h, __i); \
code; \ code; \
} } } }
@@ -667,7 +666,7 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
} \ } \
} }
/* More conenient interfaces */ // More conenient interfaces
/*! @function /*! @function
@abstract Instantiate a hash set containing integer keys @abstract Instantiate a hash set containing integer keys

8
src/nvim/lib/klist.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
/* The MIT License /* The MIT License
Copyright (c) 2008-2009, by Attractive Chaos <attractor@live.co.uk> Copyright (c) 2008-2009, by Attractive Chaos <attractor@live.co.uk>
@@ -23,16 +21,16 @@
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. SOFTWARE.
*/ */
#ifndef _AC_KLIST_H #ifndef _AC_KLIST_H
#define _AC_KLIST_H #define _AC_KLIST_H
#include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <stdlib.h>
#include "nvim/memory.h"
#include "nvim/func_attr.h" #include "nvim/func_attr.h"
#include "nvim/memory.h"
#define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f) \ #define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f) \

9
src/nvim/lib/kvec.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
// The MIT License // The MIT License
// //
// Copyright (c) 2008, by Attractive Chaos <attractor@live.co.uk> // Copyright (c) 2008, by Attractive Chaos <attractor@live.co.uk>
@@ -104,11 +102,11 @@
(*kv_pushp(v) = (x)) (*kv_pushp(v) = (x))
#define kv_a(v, i) \ #define kv_a(v, i) \
(*(((v).capacity <= (size_t) (i) \ (*(((v).capacity <= (size_t)(i) \
? ((v).capacity = (v).size = (i) + 1, \ ? ((v).capacity = (v).size = (i) + 1, \
kv_roundup32((v).capacity), \ kv_roundup32((v).capacity), \
kv_resize((v), (v).capacity), 0UL) \ kv_resize((v), (v).capacity), 0UL) \
: ((v).size <= (size_t) (i) \ : ((v).size <= (size_t)(i) \
? (v).size = (i) + 1 \ ? (v).size = (i) + 1 \
: 0UL)), \ : 0UL)), \
&(v).items[(i)])) &(v).items[(i)]))
@@ -138,8 +136,7 @@
(v).items = (v).init_array) (v).items = (v).init_array)
/// Move data to a new destination and free source /// Move data to a new destination and free source
static inline void *_memcpy_free(void *const restrict dest, static inline void *_memcpy_free(void *const restrict dest, void *const restrict src,
void *const restrict src,
const size_t size) const size_t size)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_ALWAYS_INLINE
{ {

2
src/nvim/lib/queue.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
// Queue implemented by circularly-linked list. // Queue implemented by circularly-linked list.
// //
// Adapted from libuv. Simpler and more efficient than klist.h for implementing // Adapted from libuv. Simpler and more efficient than klist.h for implementing

143
src/nvim/lib/ringbuf.h
View File

@@ -1,5 +1,3 @@
// uncrustify:off
/// Macros-based ring buffer implementation. /// Macros-based ring buffer implementation.
/// ///
/// Supported functions: /// Supported functions:
@@ -17,19 +15,24 @@
#ifndef NVIM_LIB_RINGBUF_H #ifndef NVIM_LIB_RINGBUF_H
#define NVIM_LIB_RINGBUF_H #define NVIM_LIB_RINGBUF_H
#include <stddef.h>
#include <string.h>
#include <assert.h> #include <assert.h>
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <string.h>
#include "nvim/memory.h"
#include "nvim/func_attr.h" #include "nvim/func_attr.h"
#include "nvim/memory.h"
#define _RINGBUF_LENGTH(rb) \ #define _RINGBUF_LENGTH(rb) \
((rb)->first == NULL ? 0 \ ((rb)->first == NULL ? 0 \
: ((rb)->next == (rb)->first) ? (size_t) ((rb)->buf_end - (rb)->buf) + 1 \ : ((rb)->next == (rb)->first) ? (size_t)((rb)->buf_end - (rb)->buf) + 1 \
: ((rb)->next > (rb)->first) ? (size_t) ((rb)->next - (rb)->first) \ : ((rb)->next > \
: (size_t) ((rb)->next - (rb)->buf + (rb)->buf_end - (rb)->first + 1)) (rb)->first) ? (size_t)((rb)->next - \
(rb)->first) \
: (size_t)((rb)->\
next - (rb)->buf + \
(rb)->buf_end - \
(rb)->first + 1))
#define _RINGBUF_NEXT(rb, var) \ #define _RINGBUF_NEXT(rb, var) \
((var) == (rb)->buf_end ? (rb)->buf : (var) + 1) ((var) == (rb)->buf_end ? (rb)->buf : (var) + 1)
@@ -69,12 +72,12 @@
/// `{TypeName}RingBuffer`. /// `{TypeName}RingBuffer`.
/// @param RBType Type of the single ring buffer element. /// @param RBType Type of the single ring buffer element.
#define RINGBUF_TYPEDEF(TypeName, RBType) \ #define RINGBUF_TYPEDEF(TypeName, RBType) \
typedef struct { \ typedef struct { \
RBType *buf; \ RBType *buf; \
RBType *next; \ RBType *next; \
RBType *first; \ RBType *first; \
RBType *buf_end; \ RBType *buf_end; \
} TypeName##RingBuffer; } TypeName##RingBuffer;
/// Dummy item free macros, for use in RINGBUF_INIT /// Dummy item free macros, for use in RINGBUF_INIT
/// ///
@@ -94,13 +97,13 @@ typedef struct { \
/// @param varname Variable name. /// @param varname Variable name.
/// @param rbsize Ring buffer size. /// @param rbsize Ring buffer size.
#define RINGBUF_STATIC(scope, TypeName, RBType, varname, rbsize) \ #define RINGBUF_STATIC(scope, TypeName, RBType, varname, rbsize) \
static RBType _##varname##_buf[rbsize]; \ static RBType _##varname##_buf[rbsize]; \
scope TypeName##RingBuffer varname = { \ scope TypeName##RingBuffer varname = { \
.buf = _##varname##_buf, \ .buf = _##varname##_buf, \
.next = _##varname##_buf, \ .next = _##varname##_buf, \
.first = NULL, \ .first = NULL, \
.buf_end = _##varname##_buf + rbsize - 1, \ .buf_end = _##varname##_buf + rbsize - 1, \
}; };
/// Initialize a new ring buffer /// Initialize a new ring buffer
/// ///
@@ -114,10 +117,10 @@ scope TypeName##RingBuffer varname = { \
/// ///
/// Intended function signature: `void *rbfree(RBType *)`; /// Intended function signature: `void *rbfree(RBType *)`;
#define RINGBUF_INIT(TypeName, funcprefix, RBType, rbfree) \ #define RINGBUF_INIT(TypeName, funcprefix, RBType, rbfree) \
static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \ static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \
REAL_FATTR_WARN_UNUSED_RESULT; \ REAL_FATTR_WARN_UNUSED_RESULT; \
static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \ static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \
{ \ { \
assert(size != 0); \ assert(size != 0); \
RBType *buf = xmalloc(size * sizeof(RBType)); \ RBType *buf = xmalloc(size * sizeof(RBType)); \
return (TypeName##RingBuffer) { \ return (TypeName##RingBuffer) { \
@@ -126,12 +129,12 @@ static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \
.first = NULL, \ .first = NULL, \
.buf_end = buf + size - 1, \ .buf_end = buf + size - 1, \
}; \ }; \
} \ } \
\ \
static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \ static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \
REAL_FATTR_UNUSED; \ REAL_FATTR_UNUSED; \
static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \ static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \
{ \ { \
if (rb == NULL) { \ if (rb == NULL) { \
return; \ return; \
} \ } \
@@ -139,21 +142,21 @@ static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \
rbfree(rbitem); \ rbfree(rbitem); \
} \ } \
XFREE_CLEAR(rb->buf); \ XFREE_CLEAR(rb->buf); \
} \ } \
\ \
static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \ static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \
REAL_FATTR_UNUSED; \ REAL_FATTR_UNUSED; \
static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \ static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \
{ \ { \
XFREE_CLEAR(rb->buf); \ XFREE_CLEAR(rb->buf); \
} \ } \
\ \
static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \
RBType item) \ RBType item) \
REAL_FATTR_NONNULL_ARG(1); \ REAL_FATTR_NONNULL_ARG(1); \
static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \
RBType item) \ RBType item) \
{ \ { \
if (rb->next == rb->first) { \ if (rb->next == rb->first) { \
rbfree(rb->first); \ rbfree(rb->first); \
rb->first = _RINGBUF_NEXT(rb, rb->first); \ rb->first = _RINGBUF_NEXT(rb, rb->first); \
@@ -162,14 +165,14 @@ static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \
} \ } \
*rb->next = item; \ *rb->next = item; \
rb->next = _RINGBUF_NEXT(rb, rb->next); \ rb->next = _RINGBUF_NEXT(rb, rb->next); \
} \ } \
\ \
static inline ptrdiff_t funcprefix##_rb_find_idx( \ static inline ptrdiff_t funcprefix##_rb_find_idx(const TypeName##RingBuffer *const rb, \
const TypeName##RingBuffer *const rb, const RBType *const item_p) \ const RBType *const item_p) \
REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \
static inline ptrdiff_t funcprefix##_rb_find_idx( \ static inline ptrdiff_t funcprefix##_rb_find_idx(const TypeName##RingBuffer *const rb, \
const TypeName##RingBuffer *const rb, const RBType *const item_p) \ const RBType *const item_p) \
{ \ { \
assert(rb->buf <= item_p); \ assert(rb->buf <= item_p); \
assert(rb->buf_end >= item_p); \ assert(rb->buf_end >= item_p); \
if (rb->first == NULL) { \ if (rb->first == NULL) { \
@@ -179,32 +182,28 @@ static inline ptrdiff_t funcprefix##_rb_find_idx( \
} else { \ } else { \
return item_p - rb->buf + rb->buf_end - rb->first + 1; \ return item_p - rb->buf + rb->buf_end - rb->first + 1; \
} \ } \
} \ } \
\ \
static inline size_t funcprefix##_rb_size( \ static inline size_t funcprefix##_rb_size(const TypeName##RingBuffer *const rb) \
const TypeName##RingBuffer *const rb) \
REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \
static inline size_t funcprefix##_rb_size( \ static inline size_t funcprefix##_rb_size(const TypeName##RingBuffer *const rb) \
const TypeName##RingBuffer *const rb) \ { \
{ \ return (size_t)(rb->buf_end - rb->buf) + 1; \
return (size_t) (rb->buf_end - rb->buf) + 1; \ } \
} \
\ \
static inline size_t funcprefix##_rb_length( \ static inline size_t funcprefix##_rb_length(const TypeName##RingBuffer *const rb) \
const TypeName##RingBuffer *const rb) \
REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \
static inline size_t funcprefix##_rb_length( \ static inline size_t funcprefix##_rb_length(const TypeName##RingBuffer *const rb) \
const TypeName##RingBuffer *const rb) \ { \
{ \
return _RINGBUF_LENGTH(rb); \ return _RINGBUF_LENGTH(rb); \
} \ } \
\ \
static inline RBType *funcprefix##_rb_idx_p( \ static inline RBType *funcprefix##_rb_idx_p(const TypeName##RingBuffer *const rb, \
const TypeName##RingBuffer *const rb, const size_t idx) \ const size_t idx) \
REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \
static inline RBType *funcprefix##_rb_idx_p( \ static inline RBType *funcprefix##_rb_idx_p(const TypeName##RingBuffer *const rb, \
const TypeName##RingBuffer *const rb, const size_t idx) \ const size_t idx) \
{ \ { \
assert(idx <= funcprefix##_rb_size(rb)); \ assert(idx <= funcprefix##_rb_size(rb)); \
assert(idx <= funcprefix##_rb_length(rb)); \ assert(idx <= funcprefix##_rb_length(rb)); \
if (rb->first + idx > rb->buf_end) { \ if (rb->first + idx > rb->buf_end) { \
@@ -212,25 +211,25 @@ static inline RBType *funcprefix##_rb_idx_p( \
} else { \ } else { \
return rb->first + idx; \ return rb->first + idx; \
} \ } \
} \ } \
\ \
static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \
const size_t idx) \ const size_t idx) \
REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \
static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \
const size_t idx) \ const size_t idx) \
{ \ { \
return *funcprefix##_rb_idx_p(rb, idx); \ return *funcprefix##_rb_idx_p(rb, idx); \
} \ } \
\ \
static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \
const size_t idx, \ const size_t idx, \
RBType item) \ RBType item) \
REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \ REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \
static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \
const size_t idx, \ const size_t idx, \
RBType item) \ RBType item) \
{ \ { \
assert(idx <= funcprefix##_rb_size(rb)); \ assert(idx <= funcprefix##_rb_size(rb)); \
assert(idx <= funcprefix##_rb_length(rb)); \ assert(idx <= funcprefix##_rb_length(rb)); \
const size_t length = funcprefix##_rb_length(rb); \ const size_t length = funcprefix##_rb_length(rb); \
@@ -248,29 +247,29 @@ static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \
} \ } \
if (insertpos < rb->next) { \ if (insertpos < rb->next) { \
memmove(insertpos + 1, insertpos, \ memmove(insertpos + 1, insertpos, \
(size_t) ((uintptr_t) rb->next - (uintptr_t) insertpos)); \ (size_t)((uintptr_t)rb->next - (uintptr_t)insertpos)); \
} else { \ } else { \
assert(insertpos > rb->first); \ assert(insertpos > rb->first); \
assert(rb->next <= rb->first); \ assert(rb->next <= rb->first); \
memmove(rb->buf + 1, rb->buf, \ memmove(rb->buf + 1, rb->buf, \
(size_t) ((uintptr_t) rb->next - (uintptr_t) rb->buf)); \ (size_t)((uintptr_t)rb->next - (uintptr_t)rb->buf)); \
*rb->buf = *rb->buf_end; \ *rb->buf = *rb->buf_end; \
memmove(insertpos + 1, insertpos, \ memmove(insertpos + 1, insertpos, \
(size_t) ((uintptr_t) (rb->buf_end + 1) - (uintptr_t) insertpos)); \ (size_t)((uintptr_t)(rb->buf_end + 1) - (uintptr_t)insertpos)); \
} \ } \
*insertpos = item; \ *insertpos = item; \
if (length == funcprefix##_rb_size(rb)) { \ if (length == funcprefix##_rb_size(rb)) { \
rb->first = _RINGBUF_NEXT(rb, rb->first); \ rb->first = _RINGBUF_NEXT(rb, rb->first); \
} \ } \
rb->next = _RINGBUF_NEXT(rb, rb->next); \ rb->next = _RINGBUF_NEXT(rb, rb->next); \
} \ } \
\ \
static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \
const size_t idx) \ const size_t idx) \
REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \ REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \
static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \
const size_t idx) \ const size_t idx) \
{ \ { \
assert(idx < funcprefix##_rb_size(rb)); \ assert(idx < funcprefix##_rb_size(rb)); \
assert(idx < funcprefix##_rb_length(rb)); \ assert(idx < funcprefix##_rb_length(rb)); \
RBType *const rmpos = funcprefix##_rb_idx_p(rb, idx); \ RBType *const rmpos = funcprefix##_rb_idx_p(rb, idx); \
@@ -291,18 +290,18 @@ static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \
assert(rmpos > rb->first); \ assert(rmpos > rb->first); \
assert(rmpos <= _RINGBUF_PREV(rb, rb->next)); \ assert(rmpos <= _RINGBUF_PREV(rb, rb->next)); \
memmove(rb->first + 1, rb->first, \ memmove(rb->first + 1, rb->first, \
(size_t) ((uintptr_t) rmpos - (uintptr_t) rb->first)); \ (size_t)((uintptr_t)rmpos - (uintptr_t)rb->first)); \
rb->first = _RINGBUF_NEXT(rb, rb->first); \ rb->first = _RINGBUF_NEXT(rb, rb->first); \
} else if (rmpos < rb->next) { \ } else if (rmpos < rb->next) { \
memmove(rmpos, rmpos + 1, \ memmove(rmpos, rmpos + 1, \
(size_t) ((uintptr_t) rb->next - (uintptr_t) rmpos)); \ (size_t)((uintptr_t)rb->next - (uintptr_t)rmpos)); \
rb->next = _RINGBUF_PREV(rb, rb->next); \ rb->next = _RINGBUF_PREV(rb, rb->next); \
} else { \ } else { \
assert(rb->first < rb->buf_end); \ assert(rb->first < rb->buf_end); \
memmove(rb->first + 1, rb->first, \ memmove(rb->first + 1, rb->first, \
(size_t) ((uintptr_t) rmpos - (uintptr_t) rb->first)); \ (size_t)((uintptr_t)rmpos - (uintptr_t)rb->first)); \
rb->first = _RINGBUF_NEXT(rb, rb->first); \ rb->first = _RINGBUF_NEXT(rb, rb->first); \
} \ } \
} }
#endif // NVIM_LIB_RINGBUF_H #endif // NVIM_LIB_RINGBUF_H