diff options
Diffstat (limited to 'src')
32 files changed, 1339 insertions, 1318 deletions
diff --git a/src/nvim/edit.c b/src/nvim/edit.c index ea49222a93..b3a08971e9 100644 --- a/src/nvim/edit.c +++ b/src/nvim/edit.c @@ -6216,8 +6216,8 @@ static void internal_format(int textwidth, int second_indent, int flags, int for open_line(FORWARD, OPENLINE_DELSPACES + OPENLINE_MARKFIX + (fo_white_par ? OPENLINE_KEEPTRAIL : 0) + (do_comments ? OPENLINE_DO_COM : 0) - + ((flags & INSCHAR_COM_LIST) ? OPENLINE_COM_LIST : 0) - , ((flags & INSCHAR_COM_LIST) ? second_indent : old_indent)); + + ((flags & INSCHAR_COM_LIST) ? OPENLINE_COM_LIST : 0), + ((flags & INSCHAR_COM_LIST) ? second_indent : old_indent)); if (!(flags & INSCHAR_COM_LIST)) { old_indent = 0; } diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c index 5c22bf0f8f..946bde060d 100644 --- a/src/nvim/eval/funcs.c +++ b/src/nvim/eval/funcs.c @@ -1963,13 +1963,13 @@ static void f_environ(typval_T *argvars, typval_T *rettv, FunPtr fptr) os_copy_fullenv(env, env_size); for (ssize_t i = env_size - 1; i >= 0; i--) { - const char * str = env[i]; + const char *str = env[i]; const char * const end = strchr(str + (str[0] == '=' ? 1 : 0), '='); assert(end != NULL); ptrdiff_t len = end - str; assert(len > 0); - const char * value = str + len + 1; + const char *value = str + len + 1; char c = env[i][len]; env[i][len] = NUL; @@ -5345,7 +5345,7 @@ static const char *required_env_vars[] = { static dict_T *create_environment(const dictitem_T *job_env, const bool clear_env, const bool pty, const char * const pty_term_name) { - dict_T * env = tv_dict_alloc(); + dict_T *env = tv_dict_alloc(); if (!clear_env) { typval_T temp_env = TV_INITIAL_VALUE; @@ -9644,7 +9644,7 @@ static void f_sign_jump(typval_T *argvars, typval_T *rettv, FunPtr fptr) } // Sign group - const char * sign_group_chk = tv_get_string_chk(&argvars[1]); + const char *sign_group_chk = tv_get_string_chk(&argvars[1]); if (sign_group_chk == NULL) { return; } diff --git a/src/nvim/event/loop.h b/src/nvim/event/loop.h index 03cf7e489a..acd1d1a334 100644 --- a/src/nvim/event/loop.h +++ b/src/nvim/event/loop.h @@ -8,7 +8,7 @@ #include "nvim/lib/klist.h" #include "nvim/os/time.h" -typedef void * WatcherPtr; +typedef void *WatcherPtr; #define _noop(x) KLIST_INIT(WatcherPtr, WatcherPtr, _noop) diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c index f649266b9f..4524026e3f 100644 --- a/src/nvim/ex_docmd.c +++ b/src/nvim/ex_docmd.c @@ -5697,7 +5697,7 @@ void ex_comclear(exarg_T *eap) uc_clear(&curbuf->b_ucmds); } -static void free_ucmd(ucmd_T * cmd) { +static void free_ucmd(ucmd_T *cmd) { xfree(cmd->uc_name); xfree(cmd->uc_rep); xfree(cmd->uc_compl_arg); @@ -7501,8 +7501,8 @@ void do_exedit(exarg_T *eap, win_T *old_curwin) // After a split we can use an existing buffer. + (old_curwin != NULL ? ECMD_OLDBUF : 0) + (eap->cmdidx == CMD_badd ? ECMD_ADDBUF : 0) - + (eap->cmdidx == CMD_balt ? ECMD_ALTBUF : 0) - , old_curwin == NULL ? curwin : NULL) == FAIL) { + + (eap->cmdidx == CMD_balt ? ECMD_ALTBUF : 0), + old_curwin == NULL ? curwin : NULL) == FAIL) { // Editing the file failed. If the window was split, close it. if (old_curwin != NULL) { need_hide = (curbufIsChanged() && curbuf->b_nwindows <= 1); diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c index 9eab579243..fca62353d5 100644 --- a/src/nvim/file_search.c +++ b/src/nvim/file_search.c @@ -642,8 +642,8 @@ char_u *vim_findfile(void *search_ctx_arg) if (stackp->ffs_filearray == NULL && ff_check_visited(&search_ctx->ffsc_dir_visited_list ->ffvl_visited_list, - stackp->ffs_fix_path - , stackp->ffs_wc_path + stackp->ffs_fix_path, + stackp->ffs_wc_path ) == FAIL) { #ifdef FF_VERBOSE if (p_verbose >= 5) { @@ -840,15 +840,15 @@ char_u *vim_findfile(void *search_ctx_arg) == os_isdir(file_path))))) #ifndef FF_VERBOSE && (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list, - file_path - , (char_u *)"" + file_path, + (char_u *)"" ) == OK) #endif ) { #ifdef FF_VERBOSE if (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list, - file_path - , (char_u *)"" + file_path, + (char_u *)"" ) == FAIL) { if (p_verbose >= 5) { verbose_enter_scroll(); diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c index bd78818ab2..4a33d74011 100644 --- a/src/nvim/fileio.c +++ b/src/nvim/fileio.c @@ -3154,8 +3154,8 @@ nobackup: O_WRONLY | (append ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND) - : (O_CREAT | O_TRUNC)) - , perm < 0 ? 0666 : (perm & 0777))) < 0) { + : (O_CREAT | O_TRUNC)), + perm < 0 ? 0666 : (perm & 0777))) < 0) { // A forced write will try to create a new file if the old one // is still readonly. This may also happen when the directory // is read-only. In that case the mch_remove() will fail. @@ -4684,7 +4684,7 @@ int vim_rename(const char_u *from, const char_u *to) } STRCPY(tempname, from); for (n = 123; n < 99999; n++) { - char * tail = (char *)path_tail(tempname); + char *tail = (char *)path_tail(tempname); snprintf(tail, (MAXPATHL + 1) - (tail - (char *)tempname - 1), "%d", n); if (!os_path_exists(tempname)) { diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c index 99e0bff81c..0b828777f4 100644 --- a/src/nvim/hardcopy.c +++ b/src/nvim/hardcopy.c @@ -2438,7 +2438,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit) static int prt_add_resource(struct prt_ps_resource_S *resource) { - FILE * fd_resource; + FILE *fd_resource; char_u resource_buffer[512]; size_t bytes_read; @@ -2696,8 +2696,8 @@ int mch_print_begin(prt_settings_T *psettings) prt_dsc_resources(NULL, "encoding", buffer); } prt_dsc_requirements(prt_duplex, prt_tumble, prt_collate, - psettings->do_syntax - , prt_num_copies); + psettings->do_syntax, + prt_num_copies); prt_dsc_noarg("EndComments"); /* diff --git a/src/nvim/highlight_defs.h b/src/nvim/highlight_defs.h index a0e8bad11f..12f2b62313 100644 --- a/src/nvim/highlight_defs.h +++ b/src/nvim/highlight_defs.h @@ -49,62 +49,61 @@ typedef struct attr_entry { /// Values for index in highlight_attr[]. /// When making changes, also update hlf_names below! typedef enum { - HLF_8 = 0 // Meta & special keys listed with ":map", text that is + HLF_8 = 0, // Meta & special keys listed with ":map", text that is // displayed different from what it is - , HLF_EOB // after the last line in the buffer - , HLF_TERM // terminal cursor focused - , HLF_TERMNC // terminal cursor unfocused - , HLF_AT // @ characters at end of screen, characters that - // don't really exist in the text - , HLF_D // directories in CTRL-D listing - , HLF_E // error messages - , HLF_I // incremental search - , HLF_L // last search string - , HLF_M // "--More--" message - , HLF_CM // Mode (e.g., "-- INSERT --") - , HLF_N // line number for ":number" and ":#" commands - , HLF_LNA // LineNrAbove - , HLF_LNB // LineNrBelow - , HLF_CLN // current line number when 'cursorline' is set - , HLF_R // return to continue message and yes/no questions - , HLF_S // status lines - , HLF_SNC // status lines of not-current windows - , HLF_C // column to separate vertically split windows - , HLF_T // Titles for output from ":set all", ":autocmd" etc. - , HLF_V // Visual mode - , HLF_VNC // Visual mode, autoselecting and not clipboard owner - , HLF_W // warning messages - , HLF_WM // Wildmenu highlight - , HLF_FL // Folded line - , HLF_FC // Fold column - , HLF_ADD // Added diff line - , HLF_CHD // Changed diff line - , HLF_DED // Deleted diff line - , HLF_TXD // Text Changed in diff line - , HLF_SC // Sign column - , HLF_CONCEAL // Concealed text - , HLF_SPB // SpellBad - , HLF_SPC // SpellCap - , HLF_SPR // SpellRare - , HLF_SPL // SpellLocal - , HLF_PNI // popup menu normal item - , HLF_PSI // popup menu selected item - , HLF_PSB // popup menu scrollbar - , HLF_PST // popup menu scrollbar thumb - , HLF_TP // tabpage line - , HLF_TPS // tabpage line selected - , HLF_TPF // tabpage line filler - , HLF_CUC // 'cursorcolumn' - , HLF_CUL // 'cursorline' - , HLF_MC // 'colorcolumn' - , HLF_QFL // selected quickfix line - , HLF_0 // Whitespace - , HLF_INACTIVE // NormalNC: Normal text in non-current windows - , HLF_MSGSEP // message separator line - , HLF_NFLOAT // Floating window - , HLF_MSG // Message area - , HLF_BORDER // Floating window border - , HLF_COUNT // MUST be the last one + HLF_EOB, // after the last line in the buffer + HLF_TERM, // terminal cursor focused + HLF_TERMNC, // terminal cursor unfocused + HLF_AT, // @ characters at end of screen, characters that don't really exist in the text + HLF_D, // directories in CTRL-D listing + HLF_E, // error messages + HLF_I, // incremental search + HLF_L, // last search string + HLF_M, // "--More--" message + HLF_CM, // Mode (e.g., "-- INSERT --") + HLF_N, // line number for ":number" and ":#" commands + HLF_LNA, // LineNrAbove + HLF_LNB, // LineNrBelow + HLF_CLN, // current line number when 'cursorline' is set + HLF_R, // return to continue message and yes/no questions + HLF_S, // status lines + HLF_SNC, // status lines of not-current windows + HLF_C, // column to separate vertically split windows + HLF_T, // Titles for output from ":set all", ":autocmd" etc. + HLF_V, // Visual mode + HLF_VNC, // Visual mode, autoselecting and not clipboard owner + HLF_W, // warning messages + HLF_WM, // Wildmenu highlight + HLF_FL, // Folded line + HLF_FC, // Fold column + HLF_ADD, // Added diff line + HLF_CHD, // Changed diff line + HLF_DED, // Deleted diff line + HLF_TXD, // Text Changed in diff line + HLF_SC, // Sign column + HLF_CONCEAL, // Concealed text + HLF_SPB, // SpellBad + HLF_SPC, // SpellCap + HLF_SPR, // SpellRare + HLF_SPL, // SpellLocal + HLF_PNI, // popup menu normal item + HLF_PSI, // popup menu selected item + HLF_PSB, // popup menu scrollbar + HLF_PST, // popup menu scrollbar thumb + HLF_TP, // tabpage line + HLF_TPS, // tabpage line selected + HLF_TPF, // tabpage line filler + HLF_CUC, // 'cursorcolumn' + HLF_CUL, // 'cursorline' + HLF_MC, // 'colorcolumn' + HLF_QFL, // selected quickfix line + HLF_0, // Whitespace + HLF_INACTIVE, // NormalNC: Normal text in non-current windows + HLF_MSGSEP, // message separator line + HLF_NFLOAT, // Floating window + HLF_MSG, // Message area + HLF_BORDER, // Floating window border + HLF_COUNT // MUST be the last one } hlf_T; EXTERN const char *hlf_names[] INIT(= { diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c index f236b966ca..d731e79473 100644 --- a/src/nvim/if_cscope.c +++ b/src/nvim/if_cscope.c @@ -41,7 +41,7 @@ # include "if_cscope.c.generated.h" #endif -static csinfo_T * csinfo = NULL; +static csinfo_T *csinfo = NULL; static size_t csinfo_size = 0; // number of items allocated in csinfo[] static int eap_arg_len; // length of eap->arg, set in cs_lookup_cmd() diff --git a/src/nvim/if_cscope_defs.h b/src/nvim/if_cscope_defs.h index 39cfd807f9..182cbc28e1 100644 --- a/src/nvim/if_cscope_defs.h +++ b/src/nvim/if_cscope_defs.h @@ -26,17 +26,17 @@ // See ":help cscope-find" for the possible queries. typedef struct { - char * name; + char *name; int (*func)(exarg_T *eap); - char * help; - char * usage; + char *help; + char *usage; int cansplit; // if supports splitting window } cscmd_T; typedef struct csi { - char * fname; // cscope db name - char * ppath; // path to prepend (the -P option) - char * flags; // additional cscope flags/options (e.g, -p2) + char *fname; // cscope db name + char *ppath; // path to prepend (the -P option) + char *flags; // additional cscope flags/options (e.g, -p2) #if defined(UNIX) pid_t pid; // PID of the connected cscope process #else @@ -48,8 +48,8 @@ typedef struct csi { #endif FileID file_id; - FILE * fr_fp; // from cscope: FILE. - FILE * to_fp; // to cscope: FILE. + FILE *fr_fp; // from cscope: FILE. + FILE *to_fp; // to cscope: FILE. } csinfo_T; typedef enum { Add, Find, Help, Kill, Reset, Show } csid_e; diff --git a/src/nvim/keymap.h b/src/nvim/keymap.h index f2de341976..663a7a12ec 100644 --- a/src/nvim/keymap.h +++ b/src/nvim/keymap.h @@ -122,130 +122,130 @@ // // Entries must be in the range 0x02-0x7f (see comment at K_SPECIAL). enum key_extra { - KE_NAME = 3 // name of this terminal entry - - , KE_S_UP = 4 // shift-up - , KE_S_DOWN = 5 // shift-down - - , KE_S_F1 = 6 // shifted function keys - , KE_S_F2 = 7 - , KE_S_F3 = 8 - , KE_S_F4 = 9 - , KE_S_F5 = 10 - , KE_S_F6 = 11 - , KE_S_F7 = 12 - , KE_S_F8 = 13 - , KE_S_F9 = 14 - , KE_S_F10 = 15 - - , KE_S_F11 = 16 - , KE_S_F12 = 17 - , KE_S_F13 = 18 - , KE_S_F14 = 19 - , KE_S_F15 = 20 - , KE_S_F16 = 21 - , KE_S_F17 = 22 - , KE_S_F18 = 23 - , KE_S_F19 = 24 - , KE_S_F20 = 25 - - , KE_S_F21 = 26 - , KE_S_F22 = 27 - , KE_S_F23 = 28 - , KE_S_F24 = 29 - , KE_S_F25 = 30 - , KE_S_F26 = 31 - , KE_S_F27 = 32 - , KE_S_F28 = 33 - , KE_S_F29 = 34 - , KE_S_F30 = 35 - - , KE_S_F31 = 36 - , KE_S_F32 = 37 - , KE_S_F33 = 38 - , KE_S_F34 = 39 - , KE_S_F35 = 40 - , KE_S_F36 = 41 - , KE_S_F37 = 42 - - , KE_MOUSE = 43 // mouse event start - - // Symbols for pseudo keys which are translated from the real key symbols - // above. - , KE_LEFTMOUSE = 44 // Left mouse button click - , KE_LEFTDRAG = 45 // Drag with left mouse button down - , KE_LEFTRELEASE = 46 // Left mouse button release - , KE_MIDDLEMOUSE = 47 // Middle mouse button click - , KE_MIDDLEDRAG = 48 // Drag with middle mouse button down - , KE_MIDDLERELEASE = 49 // Middle mouse button release - , KE_RIGHTMOUSE = 50 // Right mouse button click - , KE_RIGHTDRAG = 51 // Drag with right mouse button down - , KE_RIGHTRELEASE = 52 // Right mouse button release - - , KE_IGNORE = 53 // Ignored mouse drag/release - - , KE_TAB = 54 // unshifted TAB key - , KE_S_TAB_OLD = 55 // shifted TAB key (no longer used) - - // , KE_SNIFF_UNUSED = 56 // obsolete - , KE_XF1 = 57 // extra vt100 function keys for xterm - , KE_XF2 = 58 - , KE_XF3 = 59 - , KE_XF4 = 60 - , KE_XEND = 61 // extra (vt100) end key for xterm - , KE_ZEND = 62 // extra (vt100) end key for xterm - , KE_XHOME = 63 // extra (vt100) home key for xterm - , KE_ZHOME = 64 // extra (vt100) home key for xterm - , KE_XUP = 65 // extra vt100 cursor keys for xterm - , KE_XDOWN = 66 - , KE_XLEFT = 67 - , KE_XRIGHT = 68 - - , KE_LEFTMOUSE_NM = 69 // non-mappable Left mouse button click - , KE_LEFTRELEASE_NM = 70 // non-mappable left mouse button release - - , KE_S_XF1 = 71 // vt100 shifted function keys for xterm - , KE_S_XF2 = 72 - , KE_S_XF3 = 73 - , KE_S_XF4 = 74 - - // NOTE: The scroll wheel events are inverted: i.e. UP is the same as - // moving the actual scroll wheel down, LEFT is the same as moving the - // scroll wheel right. - , KE_MOUSEDOWN = 75 // scroll wheel pseudo-button Down - , KE_MOUSEUP = 76 // scroll wheel pseudo-button Up - , KE_MOUSELEFT = 77 // scroll wheel pseudo-button Left - , KE_MOUSERIGHT = 78 // scroll wheel pseudo-button Right - - , KE_KINS = 79 // keypad Insert key - , KE_KDEL = 80 // keypad Delete key - - , KE_CSI = 81 // CSI typed directly - , KE_SNR = 82 // <SNR> - , KE_PLUG = 83 // <Plug> - , KE_CMDWIN = 84 // open command-line window from Command-line Mode - - , KE_C_LEFT = 85 // control-left - , KE_C_RIGHT = 86 // control-right - , KE_C_HOME = 87 // control-home - , KE_C_END = 88 // control-end - - , KE_X1MOUSE = 89 // X1/X2 mouse-buttons - , KE_X1DRAG = 90 - , KE_X1RELEASE = 91 - , KE_X2MOUSE = 92 - , KE_X2DRAG = 93 - , KE_X2RELEASE = 94 - - , KE_DROP = 95 // DnD data is available - // , KE_CURSORHOLD = 96 // CursorHold event - , KE_NOP = 97 // no-op: does nothing - // , KE_FOCUSGAINED = 98 // focus gained - // , KE_FOCUSLOST = 99 // focus lost - , KE_MOUSEMOVE = 100 // mouse moved with no button down - // , KE_CANCEL = 101 // return from vgetc - , KE_EVENT = 102 // event - , KE_COMMAND = 104 // <Cmd> special key + KE_NAME = 3, // name of this terminal entry + + KE_S_UP = 4, // shift-up + KE_S_DOWN = 5, // shift-down + + KE_S_F1 = 6, // shifted function keys + KE_S_F2 = 7, + KE_S_F3 = 8, + KE_S_F4 = 9, + KE_S_F5 = 10, + KE_S_F6 = 11, + KE_S_F7 = 12, + KE_S_F8 = 13, + KE_S_F9 = 14, + KE_S_F10 = 15, + + KE_S_F11 = 16, + KE_S_F12 = 17, + KE_S_F13 = 18, + KE_S_F14 = 19, + KE_S_F15 = 20, + KE_S_F16 = 21, + KE_S_F17 = 22, + KE_S_F18 = 23, + KE_S_F19 = 24, + KE_S_F20 = 25, + + KE_S_F21 = 26, + KE_S_F22 = 27, + KE_S_F23 = 28, + KE_S_F24 = 29, + KE_S_F25 = 30, + KE_S_F26 = 31, + KE_S_F27 = 32, + KE_S_F28 = 33, + KE_S_F29 = 34, + KE_S_F30 = 35, + + KE_S_F31 = 36, + KE_S_F32 = 37, + KE_S_F33 = 38, + KE_S_F34 = 39, + KE_S_F35 = 40, + KE_S_F36 = 41, + KE_S_F37 = 42, + + KE_MOUSE = 43, // mouse event start + + // Symbols for pseudo keys which are translated from the real key symbols + // above. + KE_LEFTMOUSE = 44, // Left mouse button click + KE_LEFTDRAG = 45, // Drag with left mouse button down + KE_LEFTRELEASE = 46, // Left mouse button release + KE_MIDDLEMOUSE = 47, // Middle mouse button click + KE_MIDDLEDRAG = 48, // Drag with middle mouse button down + KE_MIDDLERELEASE = 49, // Middle mouse button release + KE_RIGHTMOUSE = 50, // Right mouse button click + KE_RIGHTDRAG = 51, // Drag with right mouse button down + KE_RIGHTRELEASE = 52, // Right mouse button release + + KE_IGNORE = 53, // Ignored mouse drag/release + + KE_TAB = 54, // unshifted TAB key + KE_S_TAB_OLD = 55, // shifted TAB key (no longer used) + + // , KE_SNIFF_UNUSED = 56 // obsolete + KE_XF1 = 57, // extra vt100 function keys for xterm + KE_XF2 = 58, + KE_XF3 = 59, + KE_XF4 = 60, + KE_XEND = 61, // extra (vt100) end key for xterm + KE_ZEND = 62, // extra (vt100) end key for xterm + KE_XHOME = 63, // extra (vt100) home key for xterm + KE_ZHOME = 64, // extra (vt100) home key for xterm + KE_XUP = 65, // extra vt100 cursor keys for xterm + KE_XDOWN = 66, + KE_XLEFT = 67, + KE_XRIGHT = 68, + + KE_LEFTMOUSE_NM = 69, // non-mappable Left mouse button click + KE_LEFTRELEASE_NM = 70, // non-mappable left mouse button release + + KE_S_XF1 = 71, // vt100 shifted function keys for xterm + KE_S_XF2 = 72, + KE_S_XF3 = 73, + KE_S_XF4 = 74, + + // NOTE: The scroll wheel events are inverted: i.e. UP is the same as + // moving the actual scroll wheel down, LEFT is the same as moving the + // scroll wheel right. + KE_MOUSEDOWN = 75, // scroll wheel pseudo-button Down + KE_MOUSEUP = 76, // scroll wheel pseudo-button Up + KE_MOUSELEFT = 77, // scroll wheel pseudo-button Left + KE_MOUSERIGHT = 78, // scroll wheel pseudo-button Right + + KE_KINS = 79, // keypad Insert key + KE_KDEL = 80, // keypad Delete key + + KE_CSI = 81, // CSI typed directly + KE_SNR = 82, // <SNR> + KE_PLUG = 83, // <Plug> + KE_CMDWIN = 84, // open command-line window from Command-line Mode + + KE_C_LEFT = 85, // control-left + KE_C_RIGHT = 86, // control-right + KE_C_HOME = 87, // control-home + KE_C_END = 88, // control-end + + KE_X1MOUSE = 89, // X1/X2 mouse-buttons + KE_X1DRAG = 90, + KE_X1RELEASE = 91, + KE_X2MOUSE = 92, + KE_X2DRAG = 93, + KE_X2RELEASE = 94, + + KE_DROP = 95, // DnD data is available + // , KE_CURSORHOLD = 96 // CursorHold event + KE_NOP = 97, // no-op: does nothing + // , KE_FOCUSGAINED = 98 // focus gained + // , KE_FOCUSLOST = 99 // focus lost + KE_MOUSEMOVE = 100, // mouse moved with no button down + // , KE_CANCEL = 101 // return from vgetc + KE_EVENT = 102, // event + KE_COMMAND = 104 // <Cmd> special key }; /* diff --git a/src/nvim/lib/kbtree.h b/src/nvim/lib/kbtree.h index 6b10db0bbc..e2a4e9edea 100644 --- a/src/nvim/lib/kbtree.h +++ b/src/nvim/lib/kbtree.h @@ -1,5 +1,3 @@ -// uncrustify:off - /*- * Copyright 1997-1999, 2001, John-Mark Gurney. * 2008-2009, Attractive Chaos <attractor@live.co.uk> @@ -36,386 +34,419 @@ #ifndef NVIM_LIB_KBTREE_H #define NVIM_LIB_KBTREE_H +#include <assert.h> +#include <stdint.h> #include <stdlib.h> #include <string.h> -#include <stdint.h> -#include <assert.h> #include "nvim/memory.h" #define KB_MAX_DEPTH 64 -#define __KB_KEY(type, x) (x->key) -#define __KB_PTR(btr, x) (x->ptr) +#define __KB_KEY(type, x) (x->key) +#define __KB_PTR(btr, x) (x->ptr) -#define __KB_TREE_T(name,key_t,T) \ - typedef struct kbnode_##name##_s kbnode_##name##_t; \ - struct kbnode_##name##_s { \ - int32_t n; \ - bool is_internal; \ - key_t key[2*T-1]; \ - kbnode_##name##_t *ptr[]; \ - } ; \ +#define __KB_TREE_T(name, key_t, T) \ + typedef struct kbnode_##name##_s kbnode_##name##_t; \ + struct kbnode_##name##_s { \ + int32_t n; \ + bool is_internal; \ + key_t key[2*T-1]; \ + kbnode_##name##_t *ptr[]; \ + } ; \ \ - typedef struct { \ - kbnode_##name##_t *root; \ - int n_keys, n_nodes; \ - } kbtree_##name##_t; \ + typedef struct { \ + kbnode_##name##_t *root; \ + int n_keys, n_nodes; \ + } kbtree_##name##_t; \ \ - typedef struct { \ - kbnode_##name##_t *x; \ - int i; \ - } kbpos_##name##_t; \ - typedef struct { \ - kbpos_##name##_t stack[KB_MAX_DEPTH], *p; \ - } kbitr_##name##_t; \ + typedef struct { \ + kbnode_##name##_t *x; \ + int i; \ + } kbpos_##name##_t; \ + typedef struct { \ + kbpos_##name##_t stack[KB_MAX_DEPTH], *p; \ + } kbitr_##name##_t; \ -#define __kb_destroy(kbnode_t,b) do { \ - int i; \ - unsigned int max = 8; \ - kbnode_t *x, **top, **stack = 0; \ - if (b->root) { \ - top = stack = (kbnode_t**)xcalloc(max, sizeof(kbnode_t*)); \ - *top++ = (b)->root; \ - while (top != stack) { \ - x = *--top; \ - if (x->is_internal == 0) { XFREE_CLEAR(x); continue; } \ - for (i = 0; i <= x->n; ++i) \ - if (__KB_PTR(b, x)[i]) { \ - if (top - stack == (int)max) { \ - max <<= 1; \ - stack = (kbnode_t**)xrealloc(stack, max * sizeof(kbnode_t*)); \ - top = stack + (max>>1); \ - } \ - *top++ = __KB_PTR(b, x)[i]; \ - } \ - XFREE_CLEAR(x); \ - } \ - } \ - XFREE_CLEAR(stack); \ - } while (0) +#define __kb_destroy(kbnode_t, b) do { \ + int i; \ + unsigned int max = 8; \ + kbnode_t *x, **top, **stack = 0; \ + if (b->root) { \ + top = stack = (kbnode_t **)xcalloc(max, sizeof(kbnode_t *)); \ + *top++ = (b)->root; \ + while (top != stack) { \ + x = *--top; \ + if (x->is_internal == 0) { XFREE_CLEAR(x); continue; } \ + for (i = 0; i <= x->n; ++i) \ + if (__KB_PTR(b, x)[i]) { \ + if (top - stack == (int)max) { \ + max <<= 1; \ + stack = (kbnode_t **)xrealloc(stack, max * sizeof(kbnode_t *)); \ + top = stack + (max>>1); \ + } \ + *top++ = __KB_PTR(b, x)[i]; \ + } \ + XFREE_CLEAR(x); \ + } \ + } \ + XFREE_CLEAR(stack); \ +} while (0) -#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) \ - { \ - int tr, *rr, begin = 0, end = x->n; \ - if (x->n == 0) return -1; \ - rr = r? r : &tr; \ - while (begin < end) { \ - int mid = (begin + end) >> 1; \ - if (__cmp(__KB_KEY(key_t, x)[mid], *k) < 0) begin = mid + 1; \ - else end = mid; \ - } \ - if (begin == x->n) { *rr = 1; return x->n - 1; } \ - if ((*rr = __cmp(*k, __KB_KEY(key_t, x)[begin])) < 0) --begin; \ - return begin; \ - } +#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) \ + { \ + int tr, *rr, begin = 0, end = x->n; \ + if (x->n == 0) return -1; \ + rr = r? r : &tr; \ + while (begin < end) { \ + int mid = (begin + end) >> 1; \ + if (__cmp(__KB_KEY(key_t, x)[mid], *k) < 0) begin = mid + 1; \ + else end = mid; \ + } \ + if (begin == x->n) { *rr = 1; return x->n - 1; } \ + if ((*rr = __cmp(*k, __KB_KEY(key_t, x)[begin])) < 0) --begin; \ + return begin; \ + } -#define __KB_GET(name, key_t, kbnode_t) \ - static key_t *kb_getp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ - { \ - if (!b->root) { \ - return 0; \ - } \ - int i, r = 0; \ - kbnode_t *x = b->root; \ - while (x) { \ - i = __kb_getp_aux_##name(x, k, &r); \ - if (i >= 0 && r == 0) return &__KB_KEY(key_t, x)[i]; \ - if (x->is_internal == 0) return 0; \ - x = __KB_PTR(b, x)[i + 1]; \ - } \ - return 0; \ - } \ - static inline key_t *kb_get_##name(kbtree_##name##_t *b, key_t k) \ - { \ - return kb_getp_##name(b, &k); \ - } +#define __KB_GET(name, key_t, kbnode_t) \ + static key_t *kb_getp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ + { \ + if (!b->root) { \ + return 0; \ + } \ + int i, r = 0; \ + kbnode_t *x = b->root; \ + while (x) { \ + i = __kb_getp_aux_##name(x, k, &r); \ + if (i >= 0 && r == 0) return &__KB_KEY(key_t, x)[i]; \ + if (x->is_internal == 0) return 0; \ + x = __KB_PTR(b, x)[i + 1]; \ + } \ + return 0; \ + } \ + static inline key_t *kb_get_##name(kbtree_##name##_t *b, key_t k) \ + { \ + return kb_getp_##name(b, &k); \ + } -#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) \ - { \ - if (!b->root) { \ - return; \ - } \ - int i, r = 0; \ - kbnode_t *x = b->root; \ - *lower = *upper = 0; \ - while (x) { \ - i = __kb_getp_aux_##name(x, k, &r); \ - if (i >= 0 && r == 0) { \ - *lower = *upper = &__KB_KEY(key_t, x)[i]; \ - return; \ - } \ - if (i >= 0) *lower = &__KB_KEY(key_t, x)[i]; \ - if (i < x->n - 1) *upper = &__KB_KEY(key_t, x)[i + 1]; \ - if (x->is_internal == 0) return; \ - x = __KB_PTR(b, x)[i + 1]; \ - } \ - } \ - static inline void kb_interval_##name(kbtree_##name##_t *b, key_t k, key_t **lower, key_t **upper) \ - { \ - kb_intervalp_##name(b, &k, lower, upper); \ - } +#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) \ + { \ + if (!b->root) { \ + return; \ + } \ + int i, r = 0; \ + kbnode_t *x = b->root; \ + *lower = *upper = 0; \ + while (x) { \ + i = __kb_getp_aux_##name(x, k, &r); \ + if (i >= 0 && r == 0) { \ + *lower = *upper = &__KB_KEY(key_t, x)[i]; \ + return; \ + } \ + if (i >= 0) *lower = &__KB_KEY(key_t, x)[i]; \ + if (i < x->n - 1) *upper = &__KB_KEY(key_t, x)[i + 1]; \ + if (x->is_internal == 0) return; \ + x = __KB_PTR(b, x)[i + 1]; \ + } \ + } \ + static inline void kb_interval_##name(kbtree_##name##_t *b, key_t k, key_t **lower, key_t **upper) \ + { \ + kb_intervalp_##name(b, &k, lower, upper); \ + } -#define __KB_PUT(name, key_t, kbnode_t, __cmp, T, ILEN) \ - /* x must be an internal node */ \ - static inline void __kb_split_##name(kbtree_##name##_t *b, kbnode_t *x, int i, kbnode_t *y) \ - { \ - kbnode_t *z; \ - z = (kbnode_t*)xcalloc(1, y->is_internal? ILEN : sizeof(kbnode_##name##_t)); \ - ++b->n_nodes; \ - z->is_internal = y->is_internal; \ - z->n = 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); \ - y->n = T - 1; \ - 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; \ - 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]; \ - ++x->n; \ - } \ - static inline key_t *__kb_putp_aux_##name(kbtree_##name##_t *b, kbnode_t *x, key_t * __restrict k) \ - { \ - int i = x->n - 1; \ - key_t *ret; \ - if (x->is_internal == 0) { \ - i = __kb_getp_aux_##name(x, k, 0); \ - 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)); \ - ret = &__KB_KEY(key_t, x)[i + 1]; \ - *ret = *k; \ - ++x->n; \ - } else { \ - i = __kb_getp_aux_##name(x, k, 0) + 1; \ - if (__KB_PTR(b, x)[i]->n == 2 * T - 1) { \ - __kb_split_##name(b, x, i, __KB_PTR(b, x)[i]); \ - if (__cmp(*k, __KB_KEY(key_t, x)[i]) > 0) ++i; \ - } \ - ret = __kb_putp_aux_##name(b, __KB_PTR(b, x)[i], k); \ - } \ - return ret; \ - } \ - static inline key_t *kb_putp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ - { \ - if (!b->root) { \ - b->root = (kbnode_t*)xcalloc(1, ILEN); \ - ++b->n_nodes; \ - } \ - kbnode_t *r, *s; \ - ++b->n_keys; \ - r = b->root; \ - if (r->n == 2 * T - 1) { \ - ++b->n_nodes; \ - s = (kbnode_t*)xcalloc(1, ILEN); \ - b->root = s; s->is_internal = 1; s->n = 0; \ - __KB_PTR(b, s)[0] = r; \ - __kb_split_##name(b, s, 0, r); \ - r = s; \ - } \ - return __kb_putp_aux_##name(b, r, k); \ - } \ - static inline void kb_put_##name(kbtree_##name##_t *b, key_t k) \ - { \ - kb_putp_##name(b, &k); \ - } +#define __KB_PUT(name, key_t, kbnode_t, __cmp, T, ILEN) \ + /* x must be an internal node */ \ + static inline void __kb_split_##name(kbtree_##name##_t *b, kbnode_t *x, int i, kbnode_t *y) \ + { \ + kbnode_t *z; \ + z = (kbnode_t *)xcalloc(1, y->is_internal? ILEN : sizeof(kbnode_##name##_t)); \ + ++b->n_nodes; \ + z->is_internal = y->is_internal; \ + z->n = 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); \ + y->n = T - 1; \ + 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; \ + 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]; \ + ++x->n; \ + } \ + static inline key_t *__kb_putp_aux_##name(kbtree_##name##_t *b, kbnode_t *x, key_t * __restrict k) \ + { \ + int i = x->n - 1; \ + key_t *ret; \ + if (x->is_internal == 0) { \ + i = __kb_getp_aux_##name(x, k, 0); \ + 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)); \ + ret = &__KB_KEY(key_t, x)[i + 1]; \ + *ret = *k; \ + ++x->n; \ + } else { \ + i = __kb_getp_aux_##name(x, k, 0) + 1; \ + if (__KB_PTR(b, x)[i]->n == 2 * T - 1) { \ + __kb_split_##name(b, x, i, __KB_PTR(b, x)[i]); \ + if (__cmp(*k, __KB_KEY(key_t, x)[i]) > 0) ++i; \ + } \ + ret = __kb_putp_aux_##name(b, __KB_PTR(b, x)[i], k); \ + } \ + return ret; \ + } \ + static inline key_t *kb_putp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ + { \ + if (!b->root) { \ + b->root = (kbnode_t *)xcalloc(1, ILEN); \ + ++b->n_nodes; \ + } \ + kbnode_t *r, *s; \ + ++b->n_keys; \ + r = b->root; \ + if (r->n == 2 * T - 1) { \ + ++b->n_nodes; \ + s = (kbnode_t *)xcalloc(1, ILEN); \ + b->root = s; s->is_internal = 1; s->n = 0; \ + __KB_PTR(b, s)[0] = r; \ + __kb_split_##name(b, s, 0, r); \ + r = s; \ + } \ + return __kb_putp_aux_##name(b, r, k); \ + } \ + static inline void kb_put_##name(kbtree_##name##_t *b, key_t k) \ + { \ + kb_putp_##name(b, &k); \ + } -#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) \ - { \ - int yn, zn, i, r = 0; \ - kbnode_t *xp, *y, *z; \ - key_t kp; \ - if (x == 0) return *k; \ - if (s) { /* s can only be 0, 1 or 2 */ \ - r = x->is_internal == 0? 0 : s == 1? 1 : -1; \ - i = s == 1? x->n - 1 : -1; \ - } else i = __kb_getp_aux_##name(x, k, &r); \ - if (x->is_internal == 0) { \ - if (s == 2) ++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)); \ - --x->n; \ - return kp; \ - } \ - if (r == 0) { \ - if ((yn = __KB_PTR(b, x)[i]->n) >= T) { \ - xp = __KB_PTR(b, x)[i]; \ - kp = __KB_KEY(key_t, x)[i]; \ - __KB_KEY(key_t, x)[i] = __kb_delp_aux_##name(b, xp, 0, 1); \ - return kp; \ - } else if ((zn = __KB_PTR(b, x)[i + 1]->n) >= T) { \ - xp = __KB_PTR(b, x)[i + 1]; \ - kp = __KB_KEY(key_t, x)[i]; \ - __KB_KEY(key_t, x)[i] = __kb_delp_aux_##name(b, xp, 0, 2); \ - return kp; \ - } else if (yn == T - 1 && zn == T - 1) { \ - y = __KB_PTR(b, x)[i]; z = __KB_PTR(b, x)[i + 1]; \ - __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)); \ - 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; \ - 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_PTR(b, x)[i + 1], &__KB_PTR(b, x)[i + 2], (unsigned int)(x->n - i - 1) * sizeof(void*)); \ - --x->n; \ - XFREE_CLEAR(z); \ - return __kb_delp_aux_##name(b, y, k, s); \ - } \ - } \ - ++i; \ - if ((xp = __KB_PTR(b, x)[i])->n == T - 1) { \ - 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)); \ - 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, 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]; \ - --y->n; ++xp->n; \ - } else if (i < x->n && (y = __KB_PTR(b, x)[i + 1])->n >= T) { \ - __KB_KEY(key_t, xp)[xp->n++] = __KB_KEY(key_t, x)[i]; \ - __KB_KEY(key_t, x)[i] = __KB_KEY(key_t, y)[0]; \ - if (xp->is_internal) __KB_PTR(b, xp)[xp->n] = __KB_PTR(b, y)[0]; \ - --y->n; \ - 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*)); \ - } 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]; \ - memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, xp), (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; \ - memmove(&__KB_KEY(key_t, x)[i - 1], &__KB_KEY(key_t, 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; \ - XFREE_CLEAR(xp); \ - xp = y; \ - } 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]; \ - memmove(&__KB_KEY(key_t, xp)[xp->n], __KB_KEY(key_t, y), (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; \ - 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_PTR(b, x)[i + 1], &__KB_PTR(b, x)[i + 2], (unsigned int)(x->n - i - 1) * sizeof(void*)); \ - --x->n; \ - XFREE_CLEAR(y); \ - } \ - } \ - return __kb_delp_aux_##name(b, xp, k, s); \ - } \ - static inline key_t kb_delp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ - { \ - kbnode_t *x; \ - key_t ret; \ - ret = __kb_delp_aux_##name(b, b->root, k, 0); \ - --b->n_keys; \ - if (b->root->n == 0 && b->root->is_internal) { \ - --b->n_nodes; \ - x = b->root; \ - b->root = __KB_PTR(b, x)[0]; \ - XFREE_CLEAR(x); \ - } \ - return ret; \ - } \ - static inline key_t kb_del_##name(kbtree_##name##_t *b, key_t k) \ - { \ - return kb_delp_##name(b, &k); \ - } +#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) \ + { \ + int yn, zn, i, r = 0; \ + kbnode_t *xp, *y, *z; \ + key_t kp; \ + if (x == 0) return *k; \ + if (s) { /* s can only be 0, 1 or 2 */ \ + r = x->is_internal == 0? 0 : s == 1? 1 : -1; \ + i = s == 1? x->n - 1 : -1; \ + } else i = __kb_getp_aux_##name(x, k, &r); \ + if (x->is_internal == 0) { \ + if (s == 2) ++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)); \ + --x->n; \ + return kp; \ + } \ + if (r == 0) { \ + if ((yn = __KB_PTR(b, x)[i]->n) >= T) { \ + xp = __KB_PTR(b, x)[i]; \ + kp = __KB_KEY(key_t, x)[i]; \ + __KB_KEY(key_t, x)[i] = __kb_delp_aux_##name(b, xp, 0, 1); \ + return kp; \ + } else if ((zn = __KB_PTR(b, x)[i + 1]->n) >= T) { \ + xp = __KB_PTR(b, x)[i + 1]; \ + kp = __KB_KEY(key_t, x)[i]; \ + __KB_KEY(key_t, x)[i] = __kb_delp_aux_##name(b, xp, 0, 2); \ + return kp; \ + } else if (yn == T - 1 && zn == T - 1) { \ + y = __KB_PTR(b, x)[i]; z = __KB_PTR(b, x)[i + 1]; \ + __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)); \ + 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; \ + 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_PTR(b, x)[i + 1], &__KB_PTR(b, \ + x)[i + 2], \ + (unsigned int)(x->n - i - 1) * sizeof(void *)); \ + --x->n; \ + XFREE_CLEAR(z); \ + return __kb_delp_aux_##name(b, y, k, s); \ + } \ + } \ + ++i; \ + if ((xp = __KB_PTR(b, x)[i])->n == T - 1) { \ + 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)); \ + 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, 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]; \ + --y->n; ++xp->n; \ + } else if (i < x->n && (y = __KB_PTR(b, x)[i + 1])->n >= T) { \ + __KB_KEY(key_t, xp)[xp->n++] = __KB_KEY(key_t, x)[i]; \ + __KB_KEY(key_t, x)[i] = __KB_KEY(key_t, y)[0]; \ + if (xp->is_internal) __KB_PTR(b, xp)[xp->n] = __KB_PTR(b, y)[0]; \ + --y->n; \ + 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 *)); \ + } 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]; \ + memmove(&__KB_KEY(key_t, y)[y->n], __KB_KEY(key_t, xp), \ + (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; \ + memmove(&__KB_KEY(key_t, x)[i - 1], &__KB_KEY(key_t, \ + 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; \ + XFREE_CLEAR(xp); \ + xp = y; \ + } 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]; \ + memmove(&__KB_KEY(key_t, xp)[xp->n], __KB_KEY(key_t, y), \ + (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; \ + 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_PTR(b, x)[i + 1], &__KB_PTR(b, \ + x)[i + 2], \ + (unsigned int)(x->n - i - 1) * sizeof(void *)); \ + --x->n; \ + XFREE_CLEAR(y); \ + } \ + } \ + return __kb_delp_aux_##name(b, xp, k, s); \ + } \ + static inline key_t kb_delp_##name(kbtree_##name##_t *b, key_t * __restrict k) \ + { \ + kbnode_t *x; \ + key_t ret; \ + ret = __kb_delp_aux_##name(b, b->root, k, 0); \ + --b->n_keys; \ + if (b->root->n == 0 && b->root->is_internal) { \ + --b->n_nodes; \ + x = b->root; \ + b->root = __KB_PTR(b, x)[0]; \ + XFREE_CLEAR(x); \ + } \ + return ret; \ + } \ + static inline key_t kb_del_##name(kbtree_##name##_t *b, key_t k) \ + { \ + return kb_delp_##name(b, &k); \ + } #define __KB_ITR(name, key_t, kbnode_t) \ - static inline void kb_itr_first_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ - { \ - itr->p = NULL; \ - if (b->n_keys == 0) return; \ - itr->p = itr->stack; \ - itr->p->x = b->root; itr->p->i = 0; \ - while (itr->p->x->is_internal && __KB_PTR(b, itr->p->x)[0] != 0) { \ - kbnode_t *x = itr->p->x; \ - ++itr->p; \ - itr->p->x = __KB_PTR(b, x)[0]; itr->p->i = 0; \ - } \ - } \ - static inline int kb_itr_next_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ - { \ - if (itr->p == NULL) return 0; \ - for (;;) { \ - ++itr->p->i; \ - assert(itr->p->i <= 21); \ - while (itr->p->x && itr->p->i <= itr->p->x->n) { \ - itr->p[1].i = 0; \ - itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[itr->p->i] : 0; \ - ++itr->p; \ - } \ - if (itr->p == itr->stack) { \ - itr->p = NULL; \ - return 0; \ - } \ - --itr->p; \ - if (itr->p->x && itr->p->i < itr->p->x->n) return 1; \ - } \ - } \ - static inline int kb_itr_prev_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ - { \ - if (itr->p == NULL) return 0; \ - for (;;) { \ - while (itr->p->x && itr->p->i >= 0) { \ - itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[itr->p->i] : 0; \ - itr->p[1].i = itr->p[1].x ? itr->p[1].x->n : -1; \ - ++itr->p; \ - } \ - if (itr->p == itr->stack) { \ - itr->p = NULL; \ - return 0; \ - } \ - --itr->p; \ - --itr->p->i; \ - 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) \ - { \ - if (b->n_keys == 0) { \ + static inline void kb_itr_first_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ + { \ + itr->p = NULL; \ + if (b->n_keys == 0) return; \ + itr->p = itr->stack; \ + itr->p->x = b->root; itr->p->i = 0; \ + while (itr->p->x->is_internal && __KB_PTR(b, itr->p->x)[0] != 0) { \ + kbnode_t *x = itr->p->x; \ + ++itr->p; \ + itr->p->x = __KB_PTR(b, x)[0]; itr->p->i = 0; \ + } \ + } \ + static inline int kb_itr_next_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ + { \ + if (itr->p == NULL) return 0; \ + for (;;) { \ + ++itr->p->i; \ + assert(itr->p->i <= 21); \ + while (itr->p->x && itr->p->i <= itr->p->x->n) { \ + itr->p[1].i = 0; \ + itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[itr->p->i] : 0; \ + ++itr->p; \ + } \ + if (itr->p == itr->stack) { \ + itr->p = NULL; \ + return 0; \ + } \ + --itr->p; \ + if (itr->p->x && itr->p->i < itr->p->x->n) return 1; \ + } \ + } \ + static inline int kb_itr_prev_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ + { \ + if (itr->p == NULL) return 0; \ + for (;;) { \ + while (itr->p->x && itr->p->i >= 0) { \ + itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[itr->p->i] : 0; \ + itr->p[1].i = itr->p[1].x ? itr->p[1].x->n : -1; \ + ++itr->p; \ + } \ + if (itr->p == itr->stack) { \ itr->p = NULL; \ return 0; \ - } \ - int i, r = 0; \ - itr->p = itr->stack; \ - itr->p->x = b->root; \ - while (itr->p->x) { \ - i = __kb_getp_aux_##name(itr->p->x, k, &r); \ - itr->p->i = i; \ - if (i >= 0 && r == 0) return 1; \ - ++itr->p->i; \ - assert(itr->p->i <= 21); \ - itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[i + 1] : 0; \ - ++itr->p; \ - } \ - itr->p->i = 0; \ - return 0; \ - } \ - 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); \ - } \ - static inline void kb_del_itr_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ - { \ - key_t k = kb_itr_key(itr); \ - kb_delp_##name(b, &k); \ - kb_itr_getp_##name(b, &k, itr); \ - } + } \ + --itr->p; \ + --itr->p->i; \ + 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) \ + { \ + if (b->n_keys == 0) { \ + itr->p = NULL; \ + return 0; \ + } \ + int i, r = 0; \ + itr->p = itr->stack; \ + itr->p->x = b->root; \ + while (itr->p->x) { \ + i = __kb_getp_aux_##name(itr->p->x, k, &r); \ + itr->p->i = i; \ + if (i >= 0 && r == 0) return 1; \ + ++itr->p->i; \ + assert(itr->p->i <= 21); \ + itr->p[1].x = itr->p->x->is_internal? __KB_PTR(b, itr->p->x)[i + 1] : 0; \ + ++itr->p; \ + } \ + itr->p->i = 0; \ + return 0; \ + } \ + 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); \ + } \ + static inline void kb_del_itr_##name(kbtree_##name##_t *b, kbitr_##name##_t *itr) \ + { \ + key_t k = kb_itr_key(itr); \ + kb_delp_##name(b, &k); \ + kb_itr_getp_##name(b, &k, itr); \ + } #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) \ - __KB_TREE_T(name, key_t, T) \ - __KB_GET_AUX1(name, key_t, kbnode_t, __cmp) \ - __KB_GET(name, key_t, kbnode_t) \ - __KB_INTERVAL(name, key_t, kbnode_t) \ - __KB_PUT(name, key_t, kbnode_t, __cmp, T, ILEN) \ - __KB_DEL(name, key_t, kbnode_t, T) \ - __KB_ITR(name, key_t, kbnode_t) +#define KBTREE_INIT_IMPL(name, key_t, kbnode_t, __cmp, T, ILEN) \ + __KB_TREE_T(name, key_t, T) \ + __KB_GET_AUX1(name, key_t, kbnode_t, __cmp) \ + __KB_GET(name, key_t, kbnode_t) \ + __KB_INTERVAL(name, key_t, kbnode_t) \ + __KB_PUT(name, key_t, kbnode_t, __cmp, T, ILEN) \ + __KB_DEL(name, key_t, kbnode_t, T) \ + __KB_ITR(name, key_t, kbnode_t) #define KB_DEFAULT_SIZE 512 diff --git a/src/nvim/lib/khash.h b/src/nvim/lib/khash.h index 381903c855..dd87415144 100644 --- a/src/nvim/lib/khash.h +++ b/src/nvim/lib/khash.h @@ -1,5 +1,3 @@ -// uncrustify:off - /* The MIT License 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 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ + */ /* - Example: + Example: -#include "nvim/khash.h" -KHASH_MAP_INIT_INT(32, char) -int main() { + #include "nvim/khash.h" + KHASH_MAP_INIT_INT(32, char) + int main() { int ret, is_missing; khiter_t k; khash_t(32) *h = kh_init(32); @@ -44,99 +42,98 @@ int main() { if (kh_exist(h, k)) kh_value(h, k) = 1; kh_destroy(32, h); return 0; -} -*/ + } + */ /* - 2013-05-02 (0.2.8): + 2013-05-02 (0.2.8): - * Use quadratic probing. When the capacity is power of 2, stepping function - i*(i+1)/2 guarantees to traverse each bucket. It is better than double - hashing on cache performance and is more robust than linear probing. + * Use quadratic probing. When the capacity is power of 2, stepping function + i*(i+1)/2 guarantees to traverse each bucket. It is better than double + hashing on cache performance and is more robust than linear probing. - In theory, double hashing should be more robust than quadratic probing. - However, my implementation is probably not for large hash tables, because - the second hash function is closely tied to the first hash function, - which reduce the effectiveness of double hashing. + In theory, double hashing should be more robust than quadratic probing. + However, my implementation is probably not for large hash tables, because + the second hash function is closely tied to the first hash function, + which reduce the effectiveness of double hashing. - Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php + Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php - 2011-12-29 (0.2.7): + 2011-12-29 (0.2.7): - * Minor code clean up; no actual effect. + * Minor code clean up; no actual effect. - 2011-09-16 (0.2.6): + 2011-09-16 (0.2.6): - * The capacity is a power of 2. This seems to dramatically improve the - speed for simple keys. Thank Zilong Tan for the suggestion. Reference: + * The capacity is a power of 2. This seems to dramatically improve the + speed for simple keys. Thank Zilong Tan for the suggestion. Reference: - - http://code.google.com/p/ulib/ - - http://nothings.org/computer/judy/ + - http://code.google.com/p/ulib/ + - http://nothings.org/computer/judy/ - * Allow to optionally use linear probing which usually has better - performance for random input. Double hashing is still the default as it - is more robust to certain non-random input. + * Allow to optionally use linear probing which usually has better + performance for random input. Double hashing is still the default as it + is more robust to certain non-random input. - * Added Wang's integer hash function (not used by default). This hash - function is more robust to certain non-random input. + * Added Wang's integer hash function (not used by default). This hash + function is more robust to certain non-random input. - 2011-02-14 (0.2.5): + 2011-02-14 (0.2.5): - * Allow to declare global functions. + * Allow to declare global functions. - 2009-09-26 (0.2.4): + 2009-09-26 (0.2.4): - * Improve portability + * Improve portability - 2008-09-19 (0.2.3): + 2008-09-19 (0.2.3): - * Corrected the example - * Improved interfaces + * Corrected the example + * Improved interfaces - 2008-09-11 (0.2.2): + 2008-09-11 (0.2.2): - * Improved speed a little in kh_put() + * Improved speed a little in kh_put() - 2008-09-10 (0.2.1): + 2008-09-10 (0.2.1): - * Added kh_clear() - * Fixed a compiling error + * Added kh_clear() + * Fixed a compiling error - 2008-09-02 (0.2.0): + 2008-09-02 (0.2.0): - * Changed to token concatenation which increases flexibility. + * Changed to token concatenation which increases flexibility. - 2008-08-31 (0.1.2): + 2008-08-31 (0.1.2): - * Fixed a bug in kh_get(), which has not been tested previously. + * Fixed a bug in kh_get(), which has not been tested previously. - 2008-08-31 (0.1.1): + 2008-08-31 (0.1.1): - * Added destructor -*/ + * Added destructor + */ #ifndef NVIM_LIB_KHASH_H #define NVIM_LIB_KHASH_H /*! - @header + @header - Generic hash table library. + Generic hash table library. */ #define AC_VERSION_KHASH_H "0.2.8" -#include <stdlib.h> -#include <string.h> #include <limits.h> #include <stdint.h> - -#include "nvim/memory.h" +#include <stdlib.h> +#include <string.h> #include "nvim/func_attr.h" +#include "nvim/memory.h" -/* compiler specific configuration */ +// compiler specific configuration #if UINT_MAX == 0xffffffffu typedef unsigned int khint32_t; @@ -151,9 +148,9 @@ typedef unsigned long long khint64_t; #endif #ifdef _MSC_VER -#define kh_inline __inline +# define kh_inline __inline #else -#define kh_inline inline +# define kh_inline inline #endif typedef khint32_t khint_t; @@ -170,31 +167,32 @@ typedef khint_t khiter_t; #define __ac_fsize(m) ((m) < 16? 1 : (m)>>4) #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 #ifndef kcalloc -#define kcalloc(N,Z) xcalloc(N,Z) +# define kcalloc(N, Z) xcalloc(N, Z) #endif #ifndef kmalloc -#define kmalloc(Z) xmalloc(Z) +# define kmalloc(Z) xmalloc(Z) #endif #ifndef krealloc -#define krealloc(P,Z) xrealloc(P,Z) +# define krealloc(P, Z) xrealloc(P, Z) #endif #ifndef kfree -#define kfree(P) XFREE_CLEAR(P) +# define kfree(P) XFREE_CLEAR(P) #endif #define __ac_HASH_UPPER 0.77 #define __KHASH_TYPE(name, khkey_t, khval_t) \ - typedef struct { \ - khint_t n_buckets, size, n_occupied, upper_bound; \ - khint32_t *flags; \ - khkey_t *keys; \ - khval_t *vals; \ - } kh_##name##_t; + typedef struct { \ + khint_t n_buckets, size, n_occupied, upper_bound; \ + khint32_t *flags; \ + khkey_t *keys; \ + khval_t *vals; \ + } kh_##name##_t; #define __KHASH_PROTOTYPES(name, khkey_t, khval_t) \ extern kh_##name##_t *kh_init_##name(void); \ @@ -209,12 +207,12 @@ typedef khint_t khiter_t; #define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, \ __hash_equal) \ SCOPE kh_##name##_t *kh_init_##name(void) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ 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) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE void kh_dealloc_##name(kh_##name##_t *h) \ { \ kfree(h->keys); \ @@ -222,7 +220,7 @@ typedef khint_t khiter_t; kfree(h->vals); \ } \ SCOPE void kh_destroy_##name(kh_##name##_t *h) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE void kh_destroy_##name(kh_##name##_t *h) \ { \ if (h) { \ @@ -231,7 +229,7 @@ typedef khint_t khiter_t; } \ } \ SCOPE void kh_clear_##name(kh_##name##_t *h) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE void kh_clear_##name(kh_##name##_t *h) \ { \ if (h && h->flags) { \ @@ -240,7 +238,7 @@ typedef khint_t khiter_t; } \ } \ SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \ { \ if (h->n_buckets) { \ @@ -261,10 +259,10 @@ typedef khint_t khiter_t; } \ } \ SCOPE void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ - { /* This function uses 0.25*n_buckets bytes of working space instead of */ \ - /* [sizeof(key_t+val_t)+.25]*n_buckets. */ \ + { /* This function uses 0.25*n_buckets bytes of working space instead of */ \ + /* [sizeof(key_t+val_t)+.25]*n_buckets. */ \ khint32_t *new_flags = 0; \ khint_t j = 1; \ { \ @@ -275,24 +273,23 @@ typedef khint_t khiter_t; /* requested size is too small */ \ if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) { \ j = 0; \ - } else { /* hash table size to be changed (shrink or expand); rehash */ \ - new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) \ - * sizeof(khint32_t)); \ + } else { /* hash table size to be changed (shrink or expand); rehash */ \ + new_flags = (khint32_t *)kmalloc(__ac_fsize(new_n_buckets) \ + * sizeof(khint32_t)); \ memset(new_flags, 0xaa, \ __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ - if (h->n_buckets < new_n_buckets) { /* expand */ \ - khkey_t *new_keys = (khkey_t*)krealloc( \ - (void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ + if (h->n_buckets < new_n_buckets) { /* expand */ \ + khkey_t *new_keys = (khkey_t *)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ h->keys = new_keys; \ if (kh_is_map) { \ - khval_t *new_vals = (khval_t*)krealloc( \ - (void *)h->vals, new_n_buckets * sizeof(khval_t)); \ + khval_t *new_vals = \ + (khval_t *)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \ h->vals = new_vals; \ } \ - } /* otherwise shrink */ \ + } /* otherwise shrink */ \ } \ } \ - if (j) { /* rehashing is needed */ \ + if (j) { /* rehashing is needed */ \ for (j = 0; j != h->n_buckets; ++j) { \ if (__ac_iseither(h->flags, j) == 0) { \ khkey_t key = h->keys[j]; \ @@ -326,7 +323,7 @@ typedef khint_t khiter_t; } \ /* mark it as deleted in the old hash table */ \ __ac_set_isdel_true(h->flags, i); \ - } else { /* write the element and jump out of the loop */ \ + } else { /* write the element and jump out of the loop */ \ h->keys[i] = key; \ if (kh_is_map) { \ h->vals[i] = val; \ @@ -336,15 +333,15 @@ typedef khint_t khiter_t; } \ } \ } \ - if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \ - h->keys = (khkey_t*)krealloc((void *)h->keys, \ - new_n_buckets * sizeof(khkey_t)); \ + if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \ + h->keys = (khkey_t *)krealloc((void *)h->keys, \ + new_n_buckets * sizeof(khkey_t)); \ if (kh_is_map) { \ - h->vals = (khval_t*)krealloc((void *)h->vals, \ - new_n_buckets * sizeof(khval_t)); \ + h->vals = (khval_t *)krealloc((void *)h->vals, \ + new_n_buckets * sizeof(khval_t)); \ } \ } \ - kfree(h->flags); /* free the working space */ \ + kfree(h->flags); /* free the working space */ \ h->flags = new_flags; \ h->n_buckets = new_n_buckets; \ h->n_occupied = h->size; \ @@ -352,25 +349,25 @@ typedef khint_t khiter_t; } \ } \ SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \ { \ khint_t x; \ - if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \ + if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \ if (h->n_buckets > (h->size << 1)) { \ - kh_resize_##name(h, h->n_buckets - 1); /* clear "deleted" elements */ \ + kh_resize_##name(h, h->n_buckets - 1); /* clear "deleted" elements */ \ } else { \ - kh_resize_##name(h, h->n_buckets + 1); /* expand the hash table */ \ + kh_resize_##name(h, h->n_buckets + 1); /* expand the hash table */ \ } \ - } /* TODO: implement automatically shrinking; */ \ - /* resize() already support shrinking */ \ + } /* TODO: implement automatically shrinking; */ \ + /* resize() already support shrinking */ \ { \ khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \ x = site = h->n_buckets; \ k = __hash_func(key); \ i = k & mask; \ if (__ac_isempty(h->flags, i)) { \ - x = i; /* for speed up */ \ + x = i; /* for speed up */ \ } else { \ last = i; \ while (!__ac_isempty(h->flags, i) \ @@ -394,24 +391,24 @@ typedef khint_t khiter_t; } \ } \ } \ - if (__ac_isempty(h->flags, x)) { /* not present at all */ \ + if (__ac_isempty(h->flags, x)) { /* not present at all */ \ h->keys[x] = key; \ __ac_set_isboth_false(h->flags, x); \ h->size++; \ h->n_occupied++; \ *ret = 1; \ - } else if (__ac_isdel(h->flags, x)) { /* deleted */ \ + } else if (__ac_isdel(h->flags, x)) { /* deleted */ \ h->keys[x] = key; \ __ac_set_isboth_false(h->flags, x); \ h->size++; \ *ret = 2; \ } else { \ - *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \ + *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \ } \ return x; \ } \ SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \ - REAL_FATTR_UNUSED; \ + REAL_FATTR_UNUSED; \ SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \ { \ if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \ @@ -420,240 +417,242 @@ typedef khint_t khiter_t; } \ } -#define KHASH_DECLARE(name, khkey_t, khval_t) \ - __KHASH_TYPE(name, khkey_t, khval_t) \ - __KHASH_PROTOTYPES(name, khkey_t, khval_t) +#define KHASH_DECLARE(name, khkey_t, khval_t) \ + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_PROTOTYPES(name, khkey_t, khval_t) #define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ - __KHASH_TYPE(name, khkey_t, khval_t) \ - __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_IMPL(name, SCOPE, 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 - @abstract Integer hash function - @param key The integer [khint32_t] - @return The hash value [khint_t] + @abstract Integer hash function + @param key The integer [khint32_t] + @return The hash value [khint_t] */ #define kh_int_hash_func(key) (khint32_t)(key) /*! @function - @abstract Integer comparison function + @abstract Integer comparison function */ #define kh_int_hash_equal(a, b) ((a) == (b)) /*! @function - @abstract 64-bit integer hash function - @param key The integer [khint64_t] - @return The hash value [khint_t] + @abstract 64-bit integer hash function + @param key The integer [khint64_t] + @return The hash value [khint_t] */ #define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11) /*! @function - @abstract 64-bit integer comparison function + @abstract 64-bit integer comparison function */ #define kh_int64_hash_equal(a, b) ((a) == (b)) /*! @function - @abstract const char* hash function - @param s Pointer to a null terminated string - @return The hash value + @abstract const char* hash function + @param s Pointer to a null terminated string + @return The hash value */ static kh_inline khint_t __ac_X31_hash_string(const char *s) { - khint_t h = (khint_t)*s; - if (h) for (++s ; *s; ++s) h = (h << 5) - h + (uint8_t)*s; - return h; + khint_t h = (khint_t)*s; + if (h) { + for (++s ; *s; ++s) { h = (h << 5) - h + (uint8_t)*s; } + } + return h; } /*! @function - @abstract Another interface to const char* hash function - @param key Pointer to a null terminated string [const char*] - @return The hash value [khint_t] + @abstract Another interface to const char* hash function + @param key Pointer to a null terminated string [const char*] + @return The hash value [khint_t] */ #define kh_str_hash_func(key) __ac_X31_hash_string(key) /*! @function - @abstract Const char* comparison function + @abstract Const char* comparison function */ #define kh_str_hash_equal(a, b) (strcmp(a, b) == 0) static kh_inline khint_t __ac_Wang_hash(khint_t key) { - key += ~(key << 15); - key ^= (key >> 10); - key += (key << 3); - key ^= (key >> 6); - key += ~(key << 11); - key ^= (key >> 16); - return key; + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return 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. - @param name Name of the hash table [symbol] + @abstract Type of the hash table. + @param name Name of the hash table [symbol] */ #define khash_t(name) kh_##name##_t /*! @function - @abstract Initiate a hash table. - @param name Name of the hash table [symbol] - @return Pointer to the hash table [khash_t(name)*] + @abstract Initiate a hash table. + @param name Name of the hash table [symbol] + @return Pointer to the hash table [khash_t(name)*] */ #define kh_init(name) kh_init_##name() /*! @function - @abstract Destroy a hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] + @abstract Destroy a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] */ #define kh_destroy(name, h) kh_destroy_##name(h) /*! @function - @abstract Free memory referenced directly inside a hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] + @abstract Free memory referenced directly inside a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] */ #define kh_dealloc(name, h) kh_dealloc_##name(h) /*! @function - @abstract Reset a hash table without deallocating memory. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] + @abstract Reset a hash table without deallocating memory. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] */ #define kh_clear(name, h) kh_clear_##name(h) /*! @function - @abstract Resize a hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] - @param s New size [khint_t] + @abstract Resize a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param s New size [khint_t] */ #define kh_resize(name, h, s) kh_resize_##name(h, s) /*! @function - @abstract Insert a key to the hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] - @param k Key [type of keys] - @param r Extra return code: -1 if the operation failed; + @abstract Insert a key to the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @param r Extra return code: -1 if the operation failed; 0 if the key is present in the hash table; 1 if the bucket is empty (never used); 2 if the element in the bucket has been deleted [int*] - @return Iterator to the inserted element [khint_t] + @return Iterator to the inserted element [khint_t] */ #define kh_put(name, h, k, r) kh_put_##name(h, k, r) /*! @function - @abstract Retrieve a key from the hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] - @param k Key [type of keys] - @return Iterator to the found element, or kh_end(h) if the element is absent [khint_t] + @abstract Retrieve a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @return Iterator to the found element, or kh_end(h) if the element is absent [khint_t] */ #define kh_get(name, h, k) kh_get_##name(h, k) /*! @function - @abstract Remove a key from the hash table. - @param name Name of the hash table [symbol] - @param h Pointer to the hash table [khash_t(name)*] - @param k Iterator to the element to be deleted [khint_t] + @abstract Remove a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Iterator to the element to be deleted [khint_t] */ #define kh_del(name, h, k) kh_del_##name(h, k) /*! @function - @abstract Test whether a bucket contains data. - @param h Pointer to the hash table [khash_t(name)*] - @param x Iterator to the bucket [khint_t] - @return 1 if containing data; 0 otherwise [int] + @abstract Test whether a bucket contains data. + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return 1 if containing data; 0 otherwise [int] */ #define kh_exist(h, x) (!__ac_iseither((h)->flags, (x))) /*! @function - @abstract Get key given an iterator - @param h Pointer to the hash table [khash_t(name)*] - @param x Iterator to the bucket [khint_t] - @return Key [type of keys] + @abstract Get key given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Key [type of keys] */ #define kh_key(h, x) ((h)->keys[x]) /*! @function - @abstract Get value given an iterator - @param h Pointer to the hash table [khash_t(name)*] - @param x Iterator to the bucket [khint_t] - @return Value [type of values] - @discussion For hash sets, calling this results in segfault. + @abstract Get value given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Value [type of values] + @discussion For hash sets, calling this results in segfault. */ #define kh_val(h, x) ((h)->vals[x]) /*! @function - @abstract Alias of kh_val() + @abstract Alias of kh_val() */ #define kh_value(h, x) ((h)->vals[x]) /*! @function - @abstract Get the start iterator - @param h Pointer to the hash table [khash_t(name)*] - @return The start iterator [khint_t] + @abstract Get the start iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The start iterator [khint_t] */ #define kh_begin(h) (khint_t)(0) /*! @function - @abstract Get the end iterator - @param h Pointer to the hash table [khash_t(name)*] - @return The end iterator [khint_t] + @abstract Get the end iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The end iterator [khint_t] */ #define kh_end(h) ((h)->n_buckets) /*! @function - @abstract Get the number of elements in the hash table - @param h Pointer to the hash table [khash_t(name)*] - @return Number of elements in the hash table [khint_t] + @abstract Get the number of elements in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of elements in the hash table [khint_t] */ #define kh_size(h) ((h)->size) /*! @function - @abstract Get the number of buckets in the hash table - @param h Pointer to the hash table [khash_t(name)*] - @return Number of buckets in the hash table [khint_t] + @abstract Get the number of buckets in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of buckets in the hash table [khint_t] */ #define kh_n_buckets(h) ((h)->n_buckets) /*! @function - @abstract Iterate over the entries in the hash table - @param h Pointer to the hash table [khash_t(name)*] - @param kvar Variable to which key will be assigned - @param vvar Variable to which value will be assigned - @param code Block of code to execute + @abstract Iterate over the entries in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param kvar Variable to which key will be assigned + @param vvar Variable to which value will be assigned + @param code Block of code to execute */ -#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \ - for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ - if (!kh_exist(h,__i)) continue; \ - (kvar) = kh_key(h,__i); \ - (vvar) = kh_val(h,__i); \ - code; \ - } } +#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h, __i)) continue; \ + (kvar) = kh_key(h, __i); \ + (vvar) = kh_val(h, __i); \ + code; \ + } } /*! @function - @abstract Iterate over the values in the hash table - @param h Pointer to the hash table [khash_t(name)*] - @param vvar Variable to which value will be assigned - @param code Block of code to execute + @abstract Iterate over the values in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param vvar Variable to which value will be assigned + @param code Block of code to execute */ -#define kh_foreach_value(h, vvar, code) { khint_t __i; \ - for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ - if (!kh_exist(h,__i)) continue; \ - (vvar) = kh_val(h,__i); \ - code; \ - } } +#define kh_foreach_value(h, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h, __i)) continue; \ + (vvar) = kh_val(h, __i); \ + code; \ + } } /*! @function - @abstract Iterate over the keys in the hash table - @param h Pointer to the hash table [khash_t(name)*] - @param kvar Variable to which value will be assigned - @param code Block of code to execute + @abstract Iterate over the keys in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param kvar Variable to which value will be assigned + @param code Block of code to execute */ #define kh_foreach_key(h, kvar, code) \ { \ @@ -667,57 +666,57 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key) } \ } -/* More conenient interfaces */ +// More conenient interfaces /*! @function - @abstract Instantiate a hash set containing integer keys - @param name Name of the hash table [symbol] + @abstract Instantiate a hash set containing integer keys + @param name Name of the hash table [symbol] */ -#define KHASH_SET_INIT_INT(name) \ - KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal) +#define KHASH_SET_INIT_INT(name) \ + KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal) /*! @function - @abstract Instantiate a hash map containing integer keys - @param name Name of the hash table [symbol] - @param khval_t Type of values [type] + @abstract Instantiate a hash map containing integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] */ -#define KHASH_MAP_INIT_INT(name, khval_t) \ - KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal) +#define KHASH_MAP_INIT_INT(name, khval_t) \ + KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal) /*! @function - @abstract Instantiate a hash map containing 64-bit integer keys - @param name Name of the hash table [symbol] + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] */ -#define KHASH_SET_INIT_INT64(name) \ - KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal) +#define KHASH_SET_INIT_INT64(name) \ + KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal) /*! @function - @abstract Instantiate a hash map containing 64-bit integer keys - @param name Name of the hash table [symbol] - @param khval_t Type of values [type] + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] */ -#define KHASH_MAP_INIT_INT64(name, khval_t) \ - KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal) +#define KHASH_MAP_INIT_INT64(name, khval_t) \ + KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal) typedef const char *kh_cstr_t; /*! @function - @abstract Instantiate a hash map containing const char* keys - @param name Name of the hash table [symbol] + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] */ -#define KHASH_SET_INIT_STR(name) \ - KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal) +#define KHASH_SET_INIT_STR(name) \ + KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal) /*! @function - @abstract Instantiate a hash map containing const char* keys - @param name Name of the hash table [symbol] - @param khval_t Type of values [type] + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] */ #define KHASH_MAP_INIT_STR(name, khval_t) \ KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal) /*! @function - @abstract Return a literal for an empty hash table. - @param name Name of the hash table [symbol] + @abstract Return a literal for an empty hash table. + @param name Name of the hash table [symbol] */ #define KHASH_EMPTY_TABLE(name) \ ((kh_##name##_t) { \ diff --git a/src/nvim/lib/klist.h b/src/nvim/lib/klist.h index a2d7e91af3..c8489e298b 100644 --- a/src/nvim/lib/klist.h +++ b/src/nvim/lib/klist.h @@ -1,5 +1,3 @@ -// uncrustify:off - /* The MIT License Copyright (c) 2008-2009, by Attractive Chaos <attractor@live.co.uk> @@ -23,50 +21,50 @@ ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ + */ #ifndef _AC_KLIST_H #define _AC_KLIST_H -#include <stdlib.h> #include <assert.h> +#include <stdlib.h> -#include "nvim/memory.h" #include "nvim/func_attr.h" +#include "nvim/memory.h" #define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f) \ - typedef struct { \ - size_t cnt, n, max; \ - kmptype_t **buf; \ - } kmp_##name##_t; \ - static inline kmp_##name##_t *kmp_init_##name(void) { \ - return xcalloc(1, sizeof(kmp_##name##_t)); \ + typedef struct { \ + size_t cnt, n, max; \ + kmptype_t **buf; \ + } kmp_##name##_t; \ + static inline kmp_##name##_t *kmp_init_##name(void) { \ + return xcalloc(1, sizeof(kmp_##name##_t)); \ + } \ + static inline void kmp_destroy_##name(kmp_##name##_t *mp) \ + REAL_FATTR_UNUSED; \ + static inline void kmp_destroy_##name(kmp_##name##_t *mp) { \ + size_t k; \ + for (k = 0; k < mp->n; k++) { \ + kmpfree_f(mp->buf[k]); XFREE_CLEAR(mp->buf[k]); \ } \ - static inline void kmp_destroy_##name(kmp_##name##_t *mp) \ - REAL_FATTR_UNUSED; \ - static inline void kmp_destroy_##name(kmp_##name##_t *mp) { \ - size_t k; \ - for (k = 0; k < mp->n; k++) { \ - kmpfree_f(mp->buf[k]); XFREE_CLEAR(mp->buf[k]); \ - } \ - XFREE_CLEAR(mp->buf); XFREE_CLEAR(mp); \ + XFREE_CLEAR(mp->buf); XFREE_CLEAR(mp); \ + } \ + static inline kmptype_t *kmp_alloc_##name(kmp_##name##_t *mp) { \ + mp->cnt++; \ + if (mp->n == 0) { \ + return xcalloc(1, sizeof(kmptype_t)); \ } \ - static inline kmptype_t *kmp_alloc_##name(kmp_##name##_t *mp) { \ - mp->cnt++; \ - if (mp->n == 0) { \ - return xcalloc(1, sizeof(kmptype_t)); \ - } \ - return mp->buf[--mp->n]; \ + return mp->buf[--mp->n]; \ + } \ + static inline void kmp_free_##name(kmp_##name##_t *mp, kmptype_t *p) { \ + mp->cnt--; \ + if (mp->n == mp->max) { \ + mp->max = mp->max ? (mp->max << 1) : 16; \ + mp->buf = xrealloc(mp->buf, sizeof(kmptype_t *) * mp->max); \ } \ - static inline void kmp_free_##name(kmp_##name##_t *mp, kmptype_t *p) { \ - mp->cnt--; \ - if (mp->n == mp->max) { \ - mp->max = mp->max ? (mp->max << 1) : 16; \ - mp->buf = xrealloc(mp->buf, sizeof(kmptype_t *) * mp->max); \ - } \ - mp->buf[mp->n++] = p; \ - } + mp->buf[mp->n++] = p; \ + } #define kmempool_t(name) kmp_##name##_t #define kmp_init(name) kmp_init_##name() @@ -75,55 +73,55 @@ #define kmp_free(name, mp, p) kmp_free_##name(mp, p) #define KLIST_INIT(name, kltype_t, kmpfree_t) \ - struct __kl1_##name { \ - kltype_t data; \ - struct __kl1_##name *next; \ - }; \ - typedef struct __kl1_##name kl1_##name; \ - KMEMPOOL_INIT(name, kl1_##name, kmpfree_t) \ - typedef struct { \ - kl1_##name *head, *tail; \ - kmp_##name##_t *mp; \ - size_t size; \ - } kl_##name##_t; \ - static inline kl_##name##_t *kl_init_##name(void) { \ - kl_##name##_t *kl = xcalloc(1, sizeof(kl_##name##_t)); \ - kl->mp = kmp_init(name); \ - kl->head = kl->tail = kmp_alloc(name, kl->mp); \ - kl->head->next = 0; \ - return kl; \ - } \ - static inline void kl_destroy_##name(kl_##name##_t *kl) \ - REAL_FATTR_UNUSED; \ - static inline void kl_destroy_##name(kl_##name##_t *kl) { \ - kl1_##name *p; \ - for (p = kl->head; p != kl->tail; p = p->next) { \ - kmp_free(name, kl->mp, p); \ - } \ - kmp_free(name, kl->mp, p); \ - kmp_destroy(name, kl->mp); \ - XFREE_CLEAR(kl); \ + struct __kl1_##name { \ + kltype_t data; \ + struct __kl1_##name *next; \ + }; \ + typedef struct __kl1_##name kl1_##name; \ + KMEMPOOL_INIT(name, kl1_##name, kmpfree_t) \ + typedef struct { \ + kl1_##name *head, *tail; \ + kmp_##name##_t *mp; \ + size_t size; \ + } kl_##name##_t; \ + static inline kl_##name##_t *kl_init_##name(void) { \ + kl_##name##_t *kl = xcalloc(1, sizeof(kl_##name##_t)); \ + kl->mp = kmp_init(name); \ + kl->head = kl->tail = kmp_alloc(name, kl->mp); \ + kl->head->next = 0; \ + return kl; \ + } \ + static inline void kl_destroy_##name(kl_##name##_t *kl) \ + REAL_FATTR_UNUSED; \ + static inline void kl_destroy_##name(kl_##name##_t *kl) { \ + kl1_##name *p; \ + for (p = kl->head; p != kl->tail; p = p->next) { \ + kmp_free(name, kl->mp, p); \ } \ - static inline void kl_push_##name(kl_##name##_t *kl, kltype_t d) { \ - kl1_##name *q, *p = kmp_alloc(name, kl->mp); \ - q = kl->tail; p->next = 0; kl->tail->next = p; kl->tail = p; \ - kl->size++; \ - q->data = d; \ + kmp_free(name, kl->mp, p); \ + kmp_destroy(name, kl->mp); \ + XFREE_CLEAR(kl); \ + } \ + static inline void kl_push_##name(kl_##name##_t *kl, kltype_t d) { \ + kl1_##name *q, *p = kmp_alloc(name, kl->mp); \ + q = kl->tail; p->next = 0; kl->tail->next = p; kl->tail = p; \ + kl->size++; \ + q->data = d; \ + } \ + static inline kltype_t kl_shift_at_##name(kl_##name##_t *kl, \ + kl1_##name **n) { \ + assert((*n)->next); \ + kl1_##name *p; \ + kl->size--; \ + p = *n; \ + *n = (*n)->next; \ + if (p == kl->head) { \ + kl->head = *n; \ } \ - static inline kltype_t kl_shift_at_##name(kl_##name##_t *kl, \ - kl1_##name **n) { \ - assert((*n)->next); \ - kl1_##name *p; \ - kl->size--; \ - p = *n; \ - *n = (*n)->next; \ - if (p == kl->head) { \ - kl->head = *n; \ - } \ - kltype_t d = p->data; \ - kmp_free(name, kl->mp, p); \ - return d; \ - } + kltype_t d = p->data; \ + kmp_free(name, kl->mp, p); \ + return d; \ + } #define kliter_t(name) kl1_##name #define klist_t(name) kl_##name##_t diff --git a/src/nvim/lib/kvec.h b/src/nvim/lib/kvec.h index 0a7260b2e5..eb2d9bbb77 100644 --- a/src/nvim/lib/kvec.h +++ b/src/nvim/lib/kvec.h @@ -1,5 +1,3 @@ -// uncrustify:off - // The MIT License // // Copyright (c) 2008, by Attractive Chaos <attractor@live.co.uk> @@ -46,25 +44,25 @@ #include "nvim/os/os_defs.h" #define kv_roundup32(x) \ - ((--(x)), \ - ((x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16), \ - (++(x))) + ((--(x)), \ + ((x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16), \ + (++(x))) #define KV_INITIAL_VALUE { .size = 0, .capacity = 0, .items = NULL } #define kvec_t(type) \ - struct { \ - size_t size; \ - size_t capacity; \ - type *items; \ - } + struct { \ + size_t size; \ + size_t capacity; \ + type *items; \ + } #define kv_init(v) ((v).size = (v).capacity = 0, (v).items = 0) #define kv_destroy(v) \ - do { \ - xfree((v).items); \ - kv_init(v); \ - } while (0) + do { \ + xfree((v).items); \ + kv_init(v); \ + } while (0) #define kv_A(v, i) ((v).items[(i)]) #define kv_pop(v) ((v).items[--(v).size]) #define kv_size(v) ((v).size) @@ -81,34 +79,34 @@ #define kv_drop(v, n) ((v).size -= (n)) #define kv_resize(v, s) \ - ((v).capacity = (s), \ - (v).items = xrealloc((v).items, sizeof((v).items[0]) * (v).capacity)) + ((v).capacity = (s), \ + (v).items = xrealloc((v).items, sizeof((v).items[0]) * (v).capacity)) #define kv_resize_full(v) \ - kv_resize(v, (v).capacity ? (v).capacity << 1 : 8) + kv_resize(v, (v).capacity ? (v).capacity << 1 : 8) #define kv_copy(v1, v0) \ - do { \ - if ((v1).capacity < (v0).size) { \ - kv_resize(v1, (v0).size); \ - } \ - (v1).size = (v0).size; \ - memcpy((v1).items, (v0).items, sizeof((v1).items[0]) * (v0).size); \ - } while (0) + do { \ + if ((v1).capacity < (v0).size) { \ + kv_resize(v1, (v0).size); \ + } \ + (v1).size = (v0).size; \ + memcpy((v1).items, (v0).items, sizeof((v1).items[0]) * (v0).size); \ + } while (0) #define kv_pushp(v) \ - ((((v).size == (v).capacity) ? (kv_resize_full(v), 0) : 0), \ - ((v).items + ((v).size++))) + ((((v).size == (v).capacity) ? (kv_resize_full(v), 0) : 0), \ + ((v).items + ((v).size++))) #define kv_push(v, x) \ - (*kv_pushp(v) = (x)) + (*kv_pushp(v) = (x)) #define kv_a(v, i) \ - (*(((v).capacity <= (size_t) (i) \ + (*(((v).capacity <= (size_t)(i) \ ? ((v).capacity = (v).size = (i) + 1, \ kv_roundup32((v).capacity), \ kv_resize((v), (v).capacity), 0UL) \ - : ((v).size <= (size_t) (i) \ + : ((v).size <= (size_t)(i) \ ? (v).size = (i) + 1 \ : 0UL)), \ &(v).items[(i)])) @@ -122,24 +120,23 @@ /// @param[in] type Type of vector elements. /// @param[in] init_size Number of the elements in the initial array. #define kvec_withinit_t(type, INIT_SIZE) \ - struct { \ - size_t size; \ - size_t capacity; \ - type *items; \ - type init_array[INIT_SIZE]; \ - } + struct { \ + size_t size; \ + size_t capacity; \ + type *items; \ + type init_array[INIT_SIZE]; \ + } /// Initialize vector with preallocated array /// /// @param[out] v Vector to initialize. #define kvi_init(v) \ - ((v).capacity = ARRAY_SIZE((v).init_array), \ - (v).size = 0, \ - (v).items = (v).init_array) + ((v).capacity = ARRAY_SIZE((v).init_array), \ + (v).size = 0, \ + (v).items = (v).init_array) /// Move data to a new destination and free source -static inline void *_memcpy_free(void *const restrict dest, - void *const restrict src, +static inline void *_memcpy_free(void *const restrict dest, void *const restrict src, const size_t size) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_ALWAYS_INLINE { @@ -158,15 +155,15 @@ static inline void *_memcpy_free(void *const restrict dest, /// @param[out] v Vector to resize. /// @param[in] s New size. #define kvi_resize(v, s) \ - ((v).capacity = ((s) > ARRAY_SIZE((v).init_array) \ + ((v).capacity = ((s) > ARRAY_SIZE((v).init_array) \ ? (s) \ : ARRAY_SIZE((v).init_array)), \ - (v).items = ((v).capacity == ARRAY_SIZE((v).init_array) \ + (v).items = ((v).capacity == ARRAY_SIZE((v).init_array) \ ? ((v).items == (v).init_array \ ? (v).items \ : _memcpy_free((v).init_array, (v).items, \ (v).size * sizeof((v).items[0]))) \ - : ((v).items == (v).init_array \ + : ((v).items == (v).init_array \ ? memcpy(xmalloc((v).capacity * sizeof((v).items[0])), \ (v).items, \ (v).size * sizeof((v).items[0])) \ @@ -177,13 +174,13 @@ static inline void *_memcpy_free(void *const restrict dest, /// /// @param[out] v Vector to resize. #define kvi_resize_full(v) \ - /* ARRAY_SIZE((v).init_array) is the minimal capacity of this vector. */ \ - /* Thus when vector is full capacity may not be zero and it is safe */ \ - /* not to bother with checking whether (v).capacity is 0. But now */ \ - /* capacity is not guaranteed to have size that is a power of 2, it is */ \ - /* hard to fix this here and is not very necessary if users will use */ \ - /* 2^x initial array size. */ \ - kvi_resize(v, (v).capacity << 1) + /* ARRAY_SIZE((v).init_array) is the minimal capacity of this vector. */ \ + /* Thus when vector is full capacity may not be zero and it is safe */ \ + /* not to bother with checking whether (v).capacity is 0. But now */ \ + /* capacity is not guaranteed to have size that is a power of 2, it is */ \ + /* hard to fix this here and is not very necessary if users will use */ \ + /* 2^x initial array size. */ \ + kvi_resize(v, (v).capacity << 1) /// Get location where to store new element to a vector with preallocated array /// @@ -191,24 +188,24 @@ static inline void *_memcpy_free(void *const restrict dest, /// /// @return Pointer to the place where new value should be stored. #define kvi_pushp(v) \ - ((((v).size == (v).capacity) ? (kvi_resize_full(v), 0) : 0), \ - ((v).items + ((v).size++))) + ((((v).size == (v).capacity) ? (kvi_resize_full(v), 0) : 0), \ + ((v).items + ((v).size++))) /// Push value to a vector with preallocated array /// /// @param[out] v Vector to push to. /// @param[in] x Value to push. #define kvi_push(v, x) \ - (*kvi_pushp(v) = (x)) + (*kvi_pushp(v) = (x)) /// Free array of elements of a vector with preallocated array if needed /// /// @param[out] v Vector to free. #define kvi_destroy(v) \ - do { \ - if ((v).items != (v).init_array) { \ - XFREE_CLEAR((v).items); \ - } \ - } while (0) + do { \ + if ((v).items != (v).init_array) { \ + XFREE_CLEAR((v).items); \ + } \ + } while (0) #endif // NVIM_LIB_KVEC_H diff --git a/src/nvim/lib/queue.h b/src/nvim/lib/queue.h index bc4e9c4a82..871f49c863 100644 --- a/src/nvim/lib/queue.h +++ b/src/nvim/lib/queue.h @@ -1,5 +1,3 @@ -// uncrustify:off - // Queue implemented by circularly-linked list. // // Adapted from libuv. Simpler and more efficient than klist.h for implementing @@ -43,7 +41,7 @@ typedef struct _queue { while((q) != (h)) { \ QUEUE *next = q->next; \ code \ - (q) = next; \ + (q) = next; \ } diff --git a/src/nvim/lib/ringbuf.h b/src/nvim/lib/ringbuf.h index 4eab44aa6a..06f7830bd1 100644 --- a/src/nvim/lib/ringbuf.h +++ b/src/nvim/lib/ringbuf.h @@ -1,5 +1,3 @@ -// uncrustify:off - /// Macros-based ring buffer implementation. /// /// Supported functions: @@ -17,24 +15,29 @@ #ifndef NVIM_LIB_RINGBUF_H #define NVIM_LIB_RINGBUF_H -#include <stddef.h> -#include <string.h> #include <assert.h> +#include <stddef.h> #include <stdint.h> +#include <string.h> -#include "nvim/memory.h" #include "nvim/func_attr.h" +#include "nvim/memory.h" #define _RINGBUF_LENGTH(rb) \ - ((rb)->first == NULL ? 0 \ - : ((rb)->next == (rb)->first) ? (size_t) ((rb)->buf_end - (rb)->buf) + 1 \ - : ((rb)->next > (rb)->first) ? (size_t) ((rb)->next - (rb)->first) \ - : (size_t) ((rb)->next - (rb)->buf + (rb)->buf_end - (rb)->first + 1)) + ((rb)->first == NULL ? 0 \ + : ((rb)->next == (rb)->first) ? (size_t)((rb)->buf_end - (rb)->buf) + 1 \ + : ((rb)->next > \ + (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) \ - ((var) == (rb)->buf_end ? (rb)->buf : (var) + 1) + ((var) == (rb)->buf_end ? (rb)->buf : (var) + 1) #define _RINGBUF_PREV(rb, var) \ - ((var) == (rb)->buf ? (rb)->buf_end : (var) - 1) + ((var) == (rb)->buf ? (rb)->buf_end : (var) - 1) /// Iterate over all ringbuf values /// @@ -42,11 +45,11 @@ /// @param RBType Type of the ring buffer element. /// @param varname Variable name. #define RINGBUF_FORALL(rb, RBType, varname) \ - size_t varname##_length_fa_ = _RINGBUF_LENGTH(rb); \ - for (RBType *varname = ((rb)->first == NULL ? (rb)->next : (rb)->first); \ - varname##_length_fa_; \ - (varname = _RINGBUF_NEXT(rb, varname)), \ - varname##_length_fa_--) + size_t varname##_length_fa_ = _RINGBUF_LENGTH(rb); \ + for (RBType *varname = ((rb)->first == NULL ? (rb)->next : (rb)->first); \ + varname##_length_fa_; \ + (varname = _RINGBUF_NEXT(rb, varname)), \ + varname##_length_fa_--) /// Iterate over all ringbuf values, from end to the beginning /// @@ -57,11 +60,11 @@ /// @param RBType Type of the ring buffer element. /// @param varname Variable name. #define RINGBUF_ITER_BACK(rb, RBType, varname) \ - size_t varname##_length_ib_ = _RINGBUF_LENGTH(rb); \ - for (varname = ((rb)->next == (rb)->buf ? (rb)->buf_end : (rb)->next - 1); \ - varname##_length_ib_; \ - (varname = _RINGBUF_PREV(rb, varname)), \ - varname##_length_ib_--) + size_t varname##_length_ib_ = _RINGBUF_LENGTH(rb); \ + for (varname = ((rb)->next == (rb)->buf ? (rb)->buf_end : (rb)->next - 1); \ + varname##_length_ib_; \ + (varname = _RINGBUF_PREV(rb, varname)), \ + varname##_length_ib_--) /// Define a ring buffer structure /// @@ -69,12 +72,12 @@ /// `{TypeName}RingBuffer`. /// @param RBType Type of the single ring buffer element. #define RINGBUF_TYPEDEF(TypeName, RBType) \ -typedef struct { \ - RBType *buf; \ - RBType *next; \ - RBType *first; \ - RBType *buf_end; \ -} TypeName##RingBuffer; + typedef struct { \ + RBType *buf; \ + RBType *next; \ + RBType *first; \ + RBType *buf_end; \ + } TypeName##RingBuffer; /// Dummy item free macros, for use in RINGBUF_INIT /// @@ -94,13 +97,13 @@ typedef struct { \ /// @param varname Variable name. /// @param rbsize Ring buffer size. #define RINGBUF_STATIC(scope, TypeName, RBType, varname, rbsize) \ -static RBType _##varname##_buf[rbsize]; \ -scope TypeName##RingBuffer varname = { \ - .buf = _##varname##_buf, \ - .next = _##varname##_buf, \ - .first = NULL, \ - .buf_end = _##varname##_buf + rbsize - 1, \ -}; + static RBType _##varname##_buf[rbsize]; \ + scope TypeName##RingBuffer varname = { \ + .buf = _##varname##_buf, \ + .next = _##varname##_buf, \ + .first = NULL, \ + .buf_end = _##varname##_buf + rbsize - 1, \ + }; /// Initialize a new ring buffer /// @@ -114,195 +117,191 @@ scope TypeName##RingBuffer varname = { \ /// /// Intended function signature: `void *rbfree(RBType *)`; #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; \ -static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \ -{ \ - assert(size != 0); \ - RBType *buf = xmalloc(size * sizeof(RBType)); \ - return (TypeName##RingBuffer) { \ - .buf = buf, \ - .next = buf, \ - .first = NULL, \ - .buf_end = buf + size - 1, \ - }; \ -} \ + static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size) \ + { \ + assert(size != 0); \ + RBType *buf = xmalloc(size * sizeof(RBType)); \ + return (TypeName##RingBuffer) { \ + .buf = buf, \ + .next = buf, \ + .first = NULL, \ + .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; \ -static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \ -{ \ - if (rb == NULL) { \ - return; \ - } \ - RINGBUF_FORALL(rb, RBType, rbitem) { \ - rbfree(rbitem); \ + static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb) \ + { \ + if (rb == NULL) { \ + return; \ + } \ + RINGBUF_FORALL(rb, RBType, 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; \ -static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \ -{ \ - XFREE_CLEAR(rb->buf); \ -} \ + static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb) \ + { \ + XFREE_CLEAR(rb->buf); \ + } \ \ -static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ - RBType item) \ + static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ + RBType item) \ REAL_FATTR_NONNULL_ARG(1); \ -static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ - RBType item) \ -{ \ - if (rb->next == rb->first) { \ - rbfree(rb->first); \ - rb->first = _RINGBUF_NEXT(rb, rb->first); \ - } else if (rb->first == NULL) { \ - rb->first = rb->next; \ + static inline void funcprefix##_rb_push(TypeName##RingBuffer *const rb, \ + RBType item) \ + { \ + if (rb->next == rb->first) { \ + rbfree(rb->first); \ + rb->first = _RINGBUF_NEXT(rb, rb->first); \ + } else if (rb->first == NULL) { \ + rb->first = rb->next; \ + } \ + *rb->next = item; \ + rb->next = _RINGBUF_NEXT(rb, rb->next); \ } \ - *rb->next = item; \ - rb->next = _RINGBUF_NEXT(rb, rb->next); \ -} \ \ -static inline ptrdiff_t funcprefix##_rb_find_idx( \ - const TypeName##RingBuffer *const rb, const RBType *const item_p) \ + static inline ptrdiff_t funcprefix##_rb_find_idx(const TypeName##RingBuffer *const rb, \ + const RBType *const item_p) \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \ -static inline ptrdiff_t funcprefix##_rb_find_idx( \ - const TypeName##RingBuffer *const rb, const RBType *const item_p) \ -{ \ - assert(rb->buf <= item_p); \ - assert(rb->buf_end >= item_p); \ - if (rb->first == NULL) { \ - return -1; \ - } else if (item_p >= rb->first) { \ - return item_p - rb->first; \ - } else { \ - return item_p - rb->buf + rb->buf_end - rb->first + 1; \ + static inline ptrdiff_t funcprefix##_rb_find_idx(const TypeName##RingBuffer *const rb, \ + const RBType *const item_p) \ + { \ + assert(rb->buf <= item_p); \ + assert(rb->buf_end >= item_p); \ + if (rb->first == NULL) { \ + return -1; \ + } else if (item_p >= rb->first) { \ + return item_p - rb->first; \ + } else { \ + return item_p - rb->buf + rb->buf_end - rb->first + 1; \ + } \ } \ -} \ \ -static inline size_t funcprefix##_rb_size( \ - const TypeName##RingBuffer *const rb) \ + static inline size_t funcprefix##_rb_size(const TypeName##RingBuffer *const rb) \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ -static inline size_t funcprefix##_rb_size( \ - const TypeName##RingBuffer *const rb) \ -{ \ - return (size_t) (rb->buf_end - rb->buf) + 1; \ -} \ + static inline size_t funcprefix##_rb_size(const TypeName##RingBuffer *const rb) \ + { \ + return (size_t)(rb->buf_end - rb->buf) + 1; \ + } \ \ -static inline size_t funcprefix##_rb_length( \ - const TypeName##RingBuffer *const rb) \ + static inline size_t funcprefix##_rb_length(const TypeName##RingBuffer *const rb) \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ -static inline size_t funcprefix##_rb_length( \ - const TypeName##RingBuffer *const rb) \ -{ \ - return _RINGBUF_LENGTH(rb); \ -} \ + static inline size_t funcprefix##_rb_length(const TypeName##RingBuffer *const rb) \ + { \ + return _RINGBUF_LENGTH(rb); \ + } \ \ -static inline RBType *funcprefix##_rb_idx_p( \ - const TypeName##RingBuffer *const rb, const size_t idx) \ + static inline RBType *funcprefix##_rb_idx_p(const TypeName##RingBuffer *const rb, \ + const size_t idx) \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE; \ -static inline RBType *funcprefix##_rb_idx_p( \ - const TypeName##RingBuffer *const rb, const size_t idx) \ -{ \ - assert(idx <= funcprefix##_rb_size(rb)); \ - assert(idx <= funcprefix##_rb_length(rb)); \ - if (rb->first + idx > rb->buf_end) { \ - return rb->buf + ((rb->first + idx) - (rb->buf_end + 1)); \ - } else { \ - return rb->first + idx; \ + static inline RBType *funcprefix##_rb_idx_p(const TypeName##RingBuffer *const rb, \ + const size_t idx) \ + { \ + assert(idx <= funcprefix##_rb_size(rb)); \ + assert(idx <= funcprefix##_rb_length(rb)); \ + if (rb->first + idx > rb->buf_end) { \ + return rb->buf + ((rb->first + idx) - (rb->buf_end + 1)); \ + } else { \ + return rb->first + idx; \ + } \ } \ -} \ \ -static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ - const size_t idx) \ + static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ + const size_t idx) \ REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_UNUSED; \ -static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ - const size_t idx) \ -{ \ - return *funcprefix##_rb_idx_p(rb, idx); \ -} \ -\ -static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ - const size_t idx, \ - RBType item) \ - REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \ -static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ - const size_t idx, \ - RBType item) \ -{ \ - assert(idx <= funcprefix##_rb_size(rb)); \ - assert(idx <= funcprefix##_rb_length(rb)); \ - const size_t length = funcprefix##_rb_length(rb); \ - if (idx == length) { \ - funcprefix##_rb_push(rb, item); \ - return; \ - } \ - RBType *const insertpos = funcprefix##_rb_idx_p(rb, idx); \ - if (insertpos == rb->next) { \ - funcprefix##_rb_push(rb, item); \ - return; \ - } \ - if (length == funcprefix##_rb_size(rb)) { \ - rbfree(rb->first); \ + static inline RBType funcprefix##_rb_idx(const TypeName##RingBuffer *const rb, \ + const size_t idx) \ + { \ + return *funcprefix##_rb_idx_p(rb, idx); \ } \ - if (insertpos < rb->next) { \ - memmove(insertpos + 1, insertpos, \ - (size_t) ((uintptr_t) rb->next - (uintptr_t) insertpos)); \ - } else { \ - assert(insertpos > rb->first); \ - assert(rb->next <= rb->first); \ - memmove(rb->buf + 1, rb->buf, \ - (size_t) ((uintptr_t) rb->next - (uintptr_t) rb->buf)); \ - *rb->buf = *rb->buf_end; \ - memmove(insertpos + 1, insertpos, \ - (size_t) ((uintptr_t) (rb->buf_end + 1) - (uintptr_t) insertpos)); \ - } \ - *insertpos = item; \ - if (length == funcprefix##_rb_size(rb)) { \ - rb->first = _RINGBUF_NEXT(rb, rb->first); \ - } \ - rb->next = _RINGBUF_NEXT(rb, rb->next); \ -} \ \ -static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ - const size_t idx) \ + static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ + const size_t idx, \ + RBType item) \ REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \ -static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ - const size_t idx) \ -{ \ - assert(idx < funcprefix##_rb_size(rb)); \ - assert(idx < funcprefix##_rb_length(rb)); \ - RBType *const rmpos = funcprefix##_rb_idx_p(rb, idx); \ - rbfree(rmpos); \ - if (rmpos == rb->next - 1) { \ - rb->next--; \ - if (rb->first == rb->next) { \ - rb->first = NULL; \ - rb->next = rb->buf; \ + static inline void funcprefix##_rb_insert(TypeName##RingBuffer *const rb, \ + const size_t idx, \ + RBType item) \ + { \ + assert(idx <= funcprefix##_rb_size(rb)); \ + assert(idx <= funcprefix##_rb_length(rb)); \ + const size_t length = funcprefix##_rb_length(rb); \ + if (idx == length) { \ + funcprefix##_rb_push(rb, item); \ + return; \ + } \ + RBType *const insertpos = funcprefix##_rb_idx_p(rb, idx); \ + if (insertpos == rb->next) { \ + funcprefix##_rb_push(rb, item); \ + return; \ + } \ + if (length == funcprefix##_rb_size(rb)) { \ + rbfree(rb->first); \ } \ - } else if (rmpos == rb->first) { \ - rb->first = _RINGBUF_NEXT(rb, rb->first); \ - if (rb->first == rb->next) { \ - rb->first = NULL; \ - rb->next = rb->buf; \ + if (insertpos < rb->next) { \ + memmove(insertpos + 1, insertpos, \ + (size_t)((uintptr_t)rb->next - (uintptr_t)insertpos)); \ + } else { \ + assert(insertpos > rb->first); \ + assert(rb->next <= rb->first); \ + memmove(rb->buf + 1, rb->buf, \ + (size_t)((uintptr_t)rb->next - (uintptr_t)rb->buf)); \ + *rb->buf = *rb->buf_end; \ + memmove(insertpos + 1, insertpos, \ + (size_t)((uintptr_t)(rb->buf_end + 1) - (uintptr_t)insertpos)); \ } \ - } else if (rb->first < rb->next || rb->next == rb->buf) { \ - assert(rmpos > rb->first); \ - assert(rmpos <= _RINGBUF_PREV(rb, rb->next)); \ - memmove(rb->first + 1, rb->first, \ - (size_t) ((uintptr_t) rmpos - (uintptr_t) rb->first)); \ - rb->first = _RINGBUF_NEXT(rb, rb->first); \ - } else if (rmpos < rb->next) { \ - memmove(rmpos, rmpos + 1, \ - (size_t) ((uintptr_t) rb->next - (uintptr_t) rmpos)); \ - rb->next = _RINGBUF_PREV(rb, rb->next); \ - } else { \ - assert(rb->first < rb->buf_end); \ - memmove(rb->first + 1, rb->first, \ - (size_t) ((uintptr_t) rmpos - (uintptr_t) rb->first)); \ - rb->first = _RINGBUF_NEXT(rb, rb->first); \ + *insertpos = item; \ + if (length == funcprefix##_rb_size(rb)) { \ + rb->first = _RINGBUF_NEXT(rb, rb->first); \ + } \ + rb->next = _RINGBUF_NEXT(rb, rb->next); \ } \ -} +\ + static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ + const size_t idx) \ + REAL_FATTR_NONNULL_ARG(1) REAL_FATTR_UNUSED; \ + static inline void funcprefix##_rb_remove(TypeName##RingBuffer *const rb, \ + const size_t idx) \ + { \ + assert(idx < funcprefix##_rb_size(rb)); \ + assert(idx < funcprefix##_rb_length(rb)); \ + RBType *const rmpos = funcprefix##_rb_idx_p(rb, idx); \ + rbfree(rmpos); \ + if (rmpos == rb->next - 1) { \ + rb->next--; \ + if (rb->first == rb->next) { \ + rb->first = NULL; \ + rb->next = rb->buf; \ + } \ + } else if (rmpos == rb->first) { \ + rb->first = _RINGBUF_NEXT(rb, rb->first); \ + if (rb->first == rb->next) { \ + rb->first = NULL; \ + rb->next = rb->buf; \ + } \ + } else if (rb->first < rb->next || rb->next == rb->buf) { \ + assert(rmpos > rb->first); \ + assert(rmpos <= _RINGBUF_PREV(rb, rb->next)); \ + memmove(rb->first + 1, rb->first, \ + (size_t)((uintptr_t)rmpos - (uintptr_t)rb->first)); \ + rb->first = _RINGBUF_NEXT(rb, rb->first); \ + } else if (rmpos < rb->next) { \ + memmove(rmpos, rmpos + 1, \ + (size_t)((uintptr_t)rb->next - (uintptr_t)rmpos)); \ + rb->next = _RINGBUF_PREV(rb, rb->next); \ + } else { \ + assert(rb->first < rb->buf_end); \ + memmove(rb->first + 1, rb->first, \ + (size_t)((uintptr_t)rmpos - (uintptr_t)rb->first)); \ + rb->first = _RINGBUF_NEXT(rb, rb->first); \ + } \ + } #endif // NVIM_LIB_RINGBUF_H diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c index bd978cc8ab..02bd612149 100644 --- a/src/nvim/lua/treesitter.c +++ b/src/nvim/lua/treesitter.c @@ -934,7 +934,7 @@ push: ts_tree_cursor_current_node(ud), lua_upvalueindex(2)); // [node] - const char * field = ts_tree_cursor_current_field_name(ud); + const char *field = ts_tree_cursor_current_field_name(ud); if (field != NULL) { lua_pushstring(L, ts_tree_cursor_current_field_name(ud)); diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c index 3955fbe72c..7eda9b6270 100644 --- a/src/nvim/lua/xdiff.c +++ b/src/nvim/lua/xdiff.c @@ -62,7 +62,7 @@ static int hunk_locations_cb(long start_a, long count_a, long start_b, long coun start_b += 1; } - lua_State * lstate = (lua_State *)cb_data; + lua_State *lstate = (lua_State *)cb_data; lua_createtable(lstate, 0, 0); lua_pushinteger(lstate, start_a); @@ -93,7 +93,7 @@ static int call_on_hunk_cb(long start_a, long count_a, long start_b, long count_ } hunkpriv_t *priv = (hunkpriv_t *)cb_data; - lua_State * lstate = priv->lstate; + lua_State *lstate = priv->lstate; Error *err = priv->err; const int fidx = lua_gettop(lstate); lua_pushvalue(lstate, fidx); @@ -133,7 +133,7 @@ static mmfile_t get_string_arg(lua_State *lstate, int idx) static bool check_xdiff_opt(ObjectType actType, ObjectType expType, const char *name, Error *err) { if (actType != expType) { - const char * type_str = + const char *type_str = expType == kObjectTypeString ? "string" : expType == kObjectTypeInteger ? "integer" : expType == kObjectTypeBoolean ? "boolean" : diff --git a/src/nvim/map_defs.h b/src/nvim/map_defs.h index d5a302362f..7b4596ce2e 100644 --- a/src/nvim/map_defs.h +++ b/src/nvim/map_defs.h @@ -3,8 +3,8 @@ #include "nvim/lib/khash.h" -typedef const char * cstr_t; -typedef void * ptr_t; +typedef const char *cstr_t; +typedef void *ptr_t; #define Map(T, U) Map_##T##_##U #define PMap(T) Map(T, ptr_t) diff --git a/src/nvim/memline.c b/src/nvim/memline.c index 0874af5ee1..29e4a03d51 100644 --- a/src/nvim/memline.c +++ b/src/nvim/memline.c @@ -234,8 +234,8 @@ static linenr_T lowest_marked = 0; // argument for ml_upd_block0() typedef enum { - UB_FNAME = 0 // update timestamp and filename - , UB_SAME_DIR // update the B0_SAME_DIR flag + UB_FNAME = 0, // update timestamp and filename + UB_SAME_DIR // update the B0_SAME_DIR flag } upd_block0_T; #ifdef INCLUDE_GENERATED_DECLARATIONS diff --git a/src/nvim/menu.c b/src/nvim/menu.c index d89f58163f..2250002f86 100644 --- a/src/nvim/menu.c +++ b/src/nvim/menu.c @@ -1523,7 +1523,7 @@ typedef struct { static garray_T menutrans_ga = GA_EMPTY_INIT_VALUE; #define FREE_MENUTRANS(mt) \ - menutrans_T * _mt = (mt); \ + menutrans_T *_mt = (mt); \ xfree(_mt->from); \ xfree(_mt->from_noamp); \ xfree(_mt->to) @@ -1568,7 +1568,7 @@ void ex_menutranslate(exarg_T *eap) menu_translate_tab_and_shift(to); menu_unescape_name(from); menu_unescape_name(to); - menutrans_T * tp = GA_APPEND_VIA_PTR(menutrans_T, &menutrans_ga); + menutrans_T *tp = GA_APPEND_VIA_PTR(menutrans_T, &menutrans_ga); tp->from = from; tp->from_noamp = from_noamp; tp->to = to; diff --git a/src/nvim/move.c b/src/nvim/move.c index 918e0a5c4f..64ba02064f 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -344,7 +344,7 @@ void update_topline(win_T *wp) /* * Update win->w_topline to move the cursor onto the screen. */ -void update_topline_win(win_T * win) +void update_topline_win(win_T *win) { win_T *save_curwin; switch_win(&save_curwin, NULL, win, NULL, true); diff --git a/src/nvim/ops.c b/src/nvim/ops.c index 55c34586cb..3a8f7c42a5 100644 --- a/src/nvim/ops.c +++ b/src/nvim/ops.c @@ -376,7 +376,7 @@ static void shift_block(oparg_T *oap, int amount) */ total += bd.pre_whitesp; // all virtual WS up to & incl a split TAB colnr_T ws_vcol = bd.start_vcol - bd.pre_whitesp; - char_u * old_textstart = bd.textstart; + char_u *old_textstart = bd.textstart; if (bd.startspaces) { if (utfc_ptr2len(bd.textstart) == 1) { bd.textstart++; @@ -4324,8 +4324,8 @@ void format_lines(linenr_T line_count, int avoid_fex) } else { is_not_par = true; } - next_is_not_par = fmt_check_par(curwin->w_cursor.lnum - , &next_leader_len, &next_leader_flags, do_comments + next_is_not_par = fmt_check_par(curwin->w_cursor.lnum, + &next_leader_len, &next_leader_flags, do_comments ); is_end_par = (is_not_par || next_is_not_par); if (!is_end_par && do_trail_white) { @@ -4353,8 +4353,8 @@ void format_lines(linenr_T line_count, int avoid_fex) next_leader_len = 0; next_leader_flags = NULL; } else { - next_is_not_par = fmt_check_par(curwin->w_cursor.lnum + 1 - , &next_leader_len, &next_leader_flags, do_comments + next_is_not_par = fmt_check_par(curwin->w_cursor.lnum + 1, + &next_leader_len, &next_leader_flags, do_comments ); if (do_number_indent) { next_is_start_par = diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h index 2f931fed04..441d29cd9f 100644 --- a/src/nvim/option_defs.h +++ b/src/nvim/option_defs.h @@ -752,91 +752,91 @@ EXTERN int p_force_off; ///< options that cannot be turned on. // b_p_scriptID[]. // enum { - BV_AI = 0 - , BV_AR - , BV_BH - , BV_BKC - , BV_BT - , BV_EFM - , BV_GP - , BV_MP - , BV_BIN - , BV_BL - , BV_BOMB - , BV_CHANNEL - , BV_CI - , BV_CIN - , BV_CINK - , BV_CINO - , BV_CINW - , BV_CM - , BV_CMS - , BV_COM - , BV_CPT - , BV_DICT - , BV_TSR - , BV_CSL - , BV_CFU - , BV_DEF - , BV_INC - , BV_EOL - , BV_FIXEOL - , BV_EP - , BV_ET - , BV_FENC - , BV_FP - , BV_BEXPR - , BV_FEX - , BV_FF - , BV_FLP - , BV_FO - , BV_FT - , BV_IMI - , BV_IMS - , BV_INDE - , BV_INDK - , BV_INEX - , BV_INF - , BV_ISK - , BV_KMAP - , BV_KP - , BV_LISP - , BV_LW - , BV_MENC - , BV_MA - , BV_ML - , BV_MOD - , BV_MPS - , BV_NF - , BV_OFU - , BV_PATH - , BV_PI - , BV_QE - , BV_RO - , BV_SCBK - , BV_SI - , BV_SMC - , BV_SYN - , BV_SPC - , BV_SPF - , BV_SPL - , BV_SPO - , BV_STS - , BV_SUA - , BV_SW - , BV_SWF - , BV_TFU - , BV_TAGS - , BV_TC - , BV_TS - , BV_TW - , BV_TX - , BV_UDF - , BV_UL - , BV_WM - , BV_VSTS - , BV_VTS - , BV_COUNT // must be the last one + BV_AI = 0, + BV_AR, + BV_BH, + BV_BKC, + BV_BT, + BV_EFM, + BV_GP, + BV_MP, + BV_BIN, + BV_BL, + BV_BOMB, + BV_CHANNEL, + BV_CI, + BV_CIN, + BV_CINK, + BV_CINO, + BV_CINW, + BV_CM, + BV_CMS, + BV_COM, + BV_CPT, + BV_DICT, + BV_TSR, + BV_CSL, + BV_CFU, + BV_DEF, + BV_INC, + BV_EOL, + BV_FIXEOL, + BV_EP, + BV_ET, + BV_FENC, + BV_FP, + BV_BEXPR, + BV_FEX, + BV_FF, + BV_FLP, + BV_FO, + BV_FT, + BV_IMI, + BV_IMS, + BV_INDE, + BV_INDK, + BV_INEX, + BV_INF, + BV_ISK, + BV_KMAP, + BV_KP, + BV_LISP, + BV_LW, + BV_MENC, + BV_MA, + BV_ML, + BV_MOD, + BV_MPS, + BV_NF, + BV_OFU, + BV_PATH, + BV_PI, + BV_QE, + BV_RO, + BV_SCBK, + BV_SI, + BV_SMC, + BV_SYN, + BV_SPC, + BV_SPF, + BV_SPL, + BV_SPO, + BV_STS, + BV_SUA, + BV_SW, + BV_SWF, + BV_TFU, + BV_TAGS, + BV_TC, + BV_TS, + BV_TW, + BV_TX, + BV_UDF, + BV_UL, + BV_WM, + BV_VSTS, + BV_VTS, + BV_COUNT // must be the last one }; /* @@ -845,51 +845,51 @@ enum { * window structure. */ enum { - WV_LIST = 0 - , WV_ARAB - , WV_COCU - , WV_COLE - , WV_CRBIND - , WV_BRI - , WV_BRIOPT - , WV_DIFF - , WV_FDC - , WV_FEN - , WV_FDI - , WV_FDL - , WV_FDM - , WV_FML - , WV_FDN - , WV_FDE - , WV_FDT - , WV_FMR - , WV_LBR - , WV_NU - , WV_RNU - , WV_NUW - , WV_PVW - , WV_RL - , WV_RLC - , WV_SCBIND - , WV_SCROLL - , WV_SISO - , WV_SO - , WV_SPELL - , WV_CUC - , WV_CUL - , WV_CULOPT - , WV_CC - , WV_SBR - , WV_STL - , WV_WFH - , WV_WFW - , WV_WRAP - , WV_SCL - , WV_WINHL - , WV_FCS - , WV_LCS - , WV_WINBL - , WV_COUNT // must be the last one + WV_LIST = 0, + WV_ARAB, + WV_COCU, + WV_COLE, + WV_CRBIND, + WV_BRI, + WV_BRIOPT, + WV_DIFF, + WV_FDC, + WV_FEN, + WV_FDI, + WV_FDL, + WV_FDM, + WV_FML, + WV_FDN, + WV_FDE, + WV_FDT, + WV_FMR, + WV_LBR, + WV_NU, + WV_RNU, + WV_NUW, + WV_PVW, + WV_RL, + WV_RLC, + WV_SCBIND, + WV_SCROLL, + WV_SISO, + WV_SO, + WV_SPELL, + WV_CUC, + WV_CUL, + WV_CULOPT, + WV_CC, + WV_SBR, + WV_STL, + WV_WFH, + WV_WFW, + WV_WRAP, + WV_SCL, + WV_WINHL, + WV_FCS, + WV_LCS, + WV_WINBL, + WV_COUNT // must be the last one }; // Value for b_p_ul indicating the global value must be used. diff --git a/src/nvim/screen.c b/src/nvim/screen.c index c65fd3a90b..32eb28e761 100644 --- a/src/nvim/screen.c +++ b/src/nvim/screen.c @@ -166,7 +166,7 @@ static bool resizing = false; #endif #define SEARCH_HL_PRIORITY 0 -static char * provider_err = NULL; +static char *provider_err = NULL; static bool provider_invoke(NS ns_id, const char *name, LuaRef ref, Array args, bool default_true) { @@ -2418,7 +2418,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc // If this line has a sign with line highlighting set line_attr. // TODO(bfredl, vigoux): this should not take priority over decoration! - sign_attrs_T * sattr = sign_get_attr(SIGN_LINEHL, sattrs, 0, 1); + sign_attrs_T *sattr = sign_get_attr(SIGN_LINEHL, sattrs, 0, 1); if (sattr != NULL) { line_attr = sattr->sat_linehl; } diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c index 3afc2aff52..1e14f988f1 100644 --- a/src/nvim/syntax.c +++ b/src/nvim/syntax.c @@ -7728,7 +7728,7 @@ static int syn_add_group(char_u *name) char *const name_up = (char *)vim_strsave_up(name); // Append another syntax_highlight entry. - struct hl_group * hlgp = GA_APPEND_VIA_PTR(struct hl_group, &highlight_ga); + struct hl_group *hlgp = GA_APPEND_VIA_PTR(struct hl_group, &highlight_ga); memset(hlgp, 0, sizeof(*hlgp)); hlgp->sg_name = name; hlgp->sg_rgb_bg = -1; diff --git a/src/nvim/tag.c b/src/nvim/tag.c index 83b06e2f6d..c22d344878 100644 --- a/src/nvim/tag.c +++ b/src/nvim/tag.c @@ -1402,8 +1402,8 @@ int find_tags(char_u *pat, int *num_matches, char_u ***matchesp, int flags, int int round; enum { TS_START, // at start of file - TS_LINEAR // linear searching forward, till EOF - , TS_BINARY, // binary searching + TS_LINEAR, // linear searching forward, till EOF + TS_BINARY, // binary searching TS_SKIP_BACK, // skipping backwards TS_STEP_FORWARD // stepping forwards } state; // Current search state diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c index 612eaf6667..fcfe862044 100644 --- a/src/nvim/tui/tui.c +++ b/src/nvim/tui/tui.c @@ -178,7 +178,7 @@ UI *tui_start(void) return ui_bridge_attach(ui, tui_main, tui_scheduler); } -static size_t unibi_pre_fmt_str(TUIData *data, unsigned int unibi_index, char * buf, size_t len) +static size_t unibi_pre_fmt_str(TUIData *data, unsigned int unibi_index, char *buf, size_t len) { const char *str = unibi_get_str(data->ut, unibi_index); if (!str) { @@ -1541,7 +1541,7 @@ static int unibi_find_ext_str(unibi_term *ut, const char *name) { size_t max = unibi_count_ext_str(ut); for (size_t i = 0; i < max; i++) { - const char * n = unibi_get_ext_str_name(ut, i); + const char *n = unibi_get_ext_str_name(ut, i); if (n && 0 == strcmp(n, name)) { return (int)i; } @@ -1553,7 +1553,7 @@ static int unibi_find_ext_bool(unibi_term *ut, const char *name) { size_t max = unibi_count_ext_bool(ut); for (size_t i = 0; i < max; i++) { - const char * n = unibi_get_ext_bool_name(ut, i); + const char *n = unibi_get_ext_bool_name(ut, i); if (n && 0 == strcmp(n, name)) { return (int)i; } diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 43e6325aa5..5261f9e2ec 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -1078,7 +1078,7 @@ static bool serialize_uep(bufinfo_T *bi, u_entry_T *uep) return true; } -static u_entry_T *unserialize_uep(bufinfo_T * bi, bool *error, const char *file_name) +static u_entry_T *unserialize_uep(bufinfo_T *bi, bool *error, const char *file_name) { u_entry_T *uep = xmalloc(sizeof(u_entry_T)); memset(uep, 0, sizeof(u_entry_T)); diff --git a/src/nvim/version.h b/src/nvim/version.h index c3c884a078..a19e863152 100644 --- a/src/nvim/version.h +++ b/src/nvim/version.h @@ -5,8 +5,8 @@ #include "nvim/macros.h" // defined in version.c -extern char * Version; -extern char * longVersion; +extern char *Version; +extern char *longVersion; // // Vim version number, name, etc. Patchlevel is defined in version.c. diff --git a/src/uncrustify.cfg b/src/uncrustify.cfg index 7dbaec7d67..13d1f472ed 100644 --- a/src/uncrustify.cfg +++ b/src/uncrustify.cfg @@ -196,7 +196,7 @@ sp_between_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a word. # # Overrides sp_type_func. -sp_after_ptr_star = ignore # ignore/add/remove/force/not_defined +sp_after_ptr_star = remove # ignore/add/remove/force/not_defined # Add or remove space after pointer caret '^', if followed by a word. sp_after_ptr_block_caret = ignore # ignore/add/remove/force/not_defined @@ -2346,7 +2346,7 @@ pos_conditional = ignore # ignore/break/force/lead/trail/join/ pos_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in enum entries. -pos_enum_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force +pos_enum_comma = trail # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the base class list if there is more than one # line. Affects nl_class_init_args. @@ -3307,5 +3307,5 @@ set QUESTION REAL_FATTR_CONST set QUESTION REAL_FATTR_NONNULL_ALL set QUESTION REAL_FATTR_PURE set QUESTION REAL_FATTR_WARN_UNUSED_RESULT -# option(s) with 'not default' value: 64 +# option(s) with 'not default' value: 66 # |