From 6cb78e2d1c4c6c63c628c965076a07ce5f7adbb6 Mon Sep 17 00:00:00 2001 From: dundargoc Date: Sat, 16 Dec 2023 22:14:28 +0100 Subject: [PATCH] docs: add style rule regarding initialization Specifically, specify that each initialization should be done on a separate line. --- runtime/doc/dev_style.txt | 18 ++++++++ src/nvim/change.c | 10 ++--- src/nvim/drawscreen.c | 2 +- src/nvim/edit.c | 5 +-- src/nvim/eval.c | 6 ++- src/nvim/eval/funcs.c | 11 ++--- src/nvim/eval/userfunc.c | 6 +-- src/nvim/eval/window.c | 3 +- src/nvim/ex_cmds.c | 12 ++++-- src/nvim/extmark.c | 6 ++- src/nvim/fold.c | 15 +++---- src/nvim/globals.h | 6 +-- src/nvim/grid.c | 11 ++--- src/nvim/highlight.c | 9 +++- src/nvim/indent.c | 90 +++++++++++++++------------------------ src/nvim/insexpand.c | 2 +- src/nvim/keycodes.c | 3 +- src/nvim/lua/stdlib.c | 6 ++- src/nvim/lua/xdiff.c | 3 +- src/nvim/marktree.c | 45 +++++++++++++------- src/nvim/mbyte.c | 3 +- src/nvim/memory.c | 6 ++- src/nvim/move.c | 8 +++- src/nvim/ops.c | 16 +++---- src/nvim/optionstr.c | 3 +- src/nvim/os/input.c | 3 +- src/nvim/os/shell.c | 9 ++-- src/nvim/strings.c | 10 +++-- src/nvim/terminal.c | 10 +++-- src/nvim/tui/tui.c | 9 ++-- src/nvim/ui.c | 3 +- src/nvim/ui_client.c | 4 +- src/nvim/ui_compositor.c | 3 +- src/nvim/undo.c | 7 +-- src/nvim/window.c | 12 ++++-- src/nvim/winfloat.c | 7 ++- 36 files changed, 220 insertions(+), 162 deletions(-) diff --git a/runtime/doc/dev_style.txt b/runtime/doc/dev_style.txt index 02fd07ce24..ee8a2a3c3b 100644 --- a/runtime/doc/dev_style.txt +++ b/runtime/doc/dev_style.txt @@ -73,6 +73,24 @@ should be used instead of declaration and assignment, e.g. >c int j = g(); // GOOD: declaration has initialization. +Initialization ~ + +Multiple declarations can be defined in one line if they aren't initialized, +but each initialization should be done on a separate line. + +>c + int i; + int j; // GOOD + + int i, j; // GOOD: multiple declarations, no initialization. + + int i = 0; + int j = 0; // GOOD: one initialization per line. + + int i = 0, j; // BAD: multiple declarations with initialization. + + int i = 0, j = 0; // BAD: multiple declarations with initialization. + ============================================================================== Nvim-Specific Magic diff --git a/src/nvim/change.c b/src/nvim/change.c index c528ffba20..622eb3b9a5 100644 --- a/src/nvim/change.c +++ b/src/nvim/change.c @@ -2121,10 +2121,8 @@ int get_last_leader_offset(char *line, char **flags) int result = -1; int j; int lower_check_bound = 0; - char *string; char *com_leader; char *com_flags; - char *list; char part_buf[COM_MAX_LEN]; // buffer for one option part // Repeat to match several nested comment strings. @@ -2132,13 +2130,13 @@ int get_last_leader_offset(char *line, char **flags) while (--i >= lower_check_bound) { // scan through the 'comments' option for a match int found_one = false; - for (list = curbuf->b_p_com; *list;) { + for (char *list = curbuf->b_p_com; *list;) { char *flags_save = list; // Get one option part into part_buf[]. Advance list to next one. // put string at start of string. (void)copy_option_part(&list, part_buf, COM_MAX_LEN, ","); - string = vim_strchr(part_buf, ':'); + char *string = vim_strchr(part_buf, ':'); if (string == NULL) { // If everything is fine, this cannot actually // happen. continue; @@ -2216,14 +2214,14 @@ int get_last_leader_offset(char *line, char **flags) } int len1 = (int)strlen(com_leader); - for (list = curbuf->b_p_com; *list;) { + for (char *list = curbuf->b_p_com; *list;) { char *flags_save = list; (void)copy_option_part(&list, part_buf2, COM_MAX_LEN, ","); if (flags_save == com_flags) { continue; } - string = vim_strchr(part_buf2, ':'); + char *string = vim_strchr(part_buf2, ':'); string++; while (ascii_iswhite(*string)) { string++; diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c index 09a0a43e2f..94eeb9bc77 100644 --- a/src/nvim/drawscreen.c +++ b/src/nvim/drawscreen.c @@ -928,7 +928,6 @@ int showmode(void) bool can_show_mode = (p_ch != 0 || ui_has(kUIMessages)); if ((do_mode || reg_recording != 0) && can_show_mode) { - int sub_attr; if (skip_showmode()) { return 0; // show mode later } @@ -955,6 +954,7 @@ int showmode(void) lines_left = 0; if (do_mode) { + int sub_attr; msg_puts_attr("--", attr); // CTRL-X in Insert mode if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) { diff --git a/src/nvim/edit.c b/src/nvim/edit.c index ba2885a162..0fcb665f0f 100644 --- a/src/nvim/edit.c +++ b/src/nvim/edit.c @@ -3008,7 +3008,6 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty) int try_match; int try_match_word; char *p; - char *line; bool icase; if (keytyped == NUL) { @@ -3150,7 +3149,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty) // Just completed a word, check if it starts with "look". // search back for the start of a word. - line = get_cursor_line_ptr(); + char *line = get_cursor_line_ptr(); for (s = line + curwin->w_cursor.col; s > line; s = n) { n = mb_prevptr(line, s); if (!vim_iswordp(n)) { @@ -3169,7 +3168,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty) if (keytyped == (int)(uint8_t)p[-1] || (icase && keytyped < 256 && TOLOWER_LOC(keytyped) == TOLOWER_LOC((uint8_t)p[-1]))) { - line = get_cursor_pos_ptr(); + char *line = get_cursor_pos_ptr(); assert(p >= look && (uintmax_t)(p - look) <= SIZE_MAX); if ((curwin->w_cursor.col == (colnr_T)(p - look) || !vim_iswordc((uint8_t)line[-(p - look) - 1])) diff --git a/src/nvim/eval.c b/src/nvim/eval.c index d8134c2360..7d869881e8 100644 --- a/src/nvim/eval.c +++ b/src/nvim/eval.c @@ -2863,7 +2863,8 @@ static int eval5(char **arg, typval_T *rettv, evalarg_T *const evalarg) } else { bool error = false; varnumber_T n1, n2; - float_T f1 = 0, f2 = 0; + float_T f1 = 0; + float_T f2 = 0; if (rettv->v_type == VAR_FLOAT) { f1 = rettv->vval.v_float; @@ -2954,7 +2955,8 @@ static int eval6(char **arg, typval_T *rettv, evalarg_T *const evalarg, bool wan } varnumber_T n1, n2; - float_T f1 = 0, f2 = 0; + float_T f1 = 0; + float_T f2 = 0; bool error = false; const bool evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); if (evaluate) { diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c index ea68c010d6..81ae208560 100644 --- a/src/nvim/eval/funcs.c +++ b/src/nvim/eval/funcs.c @@ -4054,8 +4054,8 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) bool clear_env = false; bool overlapped = false; ChannelStdinMode stdin_mode = kChannelStdinPipe; - CallbackReader on_stdout = CALLBACK_READER_INIT, - on_stderr = CALLBACK_READER_INIT; + CallbackReader on_stdout = CALLBACK_READER_INIT; + CallbackReader on_stderr = CALLBACK_READER_INIT; Callback on_exit = CALLBACK_NONE; char *cwd = NULL; dictitem_T *job_env = NULL; @@ -4118,7 +4118,8 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) } } - uint16_t width = 0, height = 0; + uint16_t width = 0; + uint16_t height = 0; char *term_name = NULL; if (pty) { @@ -8553,8 +8554,8 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) return; } - CallbackReader on_stdout = CALLBACK_READER_INIT, - on_stderr = CALLBACK_READER_INIT; + CallbackReader on_stdout = CALLBACK_READER_INIT; + CallbackReader on_stderr = CALLBACK_READER_INIT; Callback on_exit = CALLBACK_NONE; dict_T *job_opts = NULL; const char *cwd = "."; diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c index ebc84922cb..cce02e6daf 100644 --- a/src/nvim/eval/userfunc.c +++ b/src/nvim/eval/userfunc.c @@ -105,7 +105,6 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int * char *arg = *argp; char *p = arg; uint8_t c; - int i; if (newargs != NULL) { ga_init(newargs, (int)sizeof(char *), 3); @@ -147,7 +146,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int * arg = xstrdup(arg); // Check for duplicate argument name. - for (i = 0; i < newargs->ga_len; i++) { + for (int i = 0; i < newargs->ga_len; i++) { if (strcmp(((char **)(newargs->ga_data))[i], arg) == 0) { semsg(_("E853: Duplicate argument name: %s"), arg); xfree(arg); @@ -922,7 +921,6 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett static int depth = 0; dictitem_T *v; int fixvar_idx = 0; // index in fc_fixvar[] - int ai; bool islambda = false; char numbuf[NUMBUFLEN]; char *name; @@ -1025,7 +1023,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett bool isdefault = false; typval_T def_rettv; - ai = i - fp->uf_args.ga_len; + int ai = i - fp->uf_args.ga_len; if (ai < 0) { // named argument a:name name = FUNCARG(fp, i); diff --git a/src/nvim/eval/window.c b/src/nvim/eval/window.c index d1ee2ea356..02f214f262 100644 --- a/src/nvim/eval/window.c +++ b/src/nvim/eval/window.c @@ -710,7 +710,8 @@ void f_win_splitmove(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) return; } - int flags = 0, size = 0; + int flags = 0; + int size = 0; if (argvars[2].v_type != VAR_UNKNOWN) { dict_T *d; diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index 96429c96f7..a0e9b537e8 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -618,7 +618,8 @@ void ex_sort(exarg_T *eap) goto sortend; } - bcount_t old_count = 0, new_count = 0; + bcount_t old_count = 0; + bcount_t new_count = 0; // Insert the lines in the sorted order below the last one. linenr_T lnum = eap->line2; @@ -3303,7 +3304,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n .do_number = false, .do_ic = kSubHonorOptions }; - char *pat = NULL, *sub = NULL; // init for GCC + char *pat = NULL; + char *sub = NULL; // init for GCC int delimiter; bool has_second_delim = false; int sublen; @@ -3501,7 +3503,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n colnr_T copycol; colnr_T matchcol; colnr_T prev_matchcol = MAXCOL; - char *new_end, *new_start = NULL; + char *new_end; + char *new_start = NULL; int new_start_len = 0; char *p1; bool did_sub = false; @@ -3971,7 +3974,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n // TODO(bfredl): this has some robustness issues, look into later. bcount_t replaced_bytes = 0; - lpos_T start = regmatch.startpos[0], end = regmatch.endpos[0]; + lpos_T start = regmatch.startpos[0]; + lpos_T end = regmatch.endpos[0]; for (i = 0; i < nmatch - 1; i++) { replaced_bytes += (bcount_t)strlen(ml_get((linenr_T)(lnum_start + i))) + 1; } diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c index f914137ccc..f305b6d506 100644 --- a/src/nvim/extmark.c +++ b/src/nvim/extmark.c @@ -435,8 +435,10 @@ void extmark_adjust(buf_T *buf, linenr_T line1, linenr_T line2, linenr_T amount, return; } bcount_t start_byte = ml_find_line_or_offset(buf, line1, NULL, true); - bcount_t old_byte = 0, new_byte = 0; - int old_row, new_row; + bcount_t old_byte = 0; + bcount_t new_byte = 0; + int old_row; + int new_row; if (amount == MAXLNUM) { old_row = line2 - line1 + 1; // TODO(bfredl): ej kasta? diff --git a/src/nvim/fold.c b/src/nvim/fold.c index e372b9f461..9e90ab9439 100644 --- a/src/nvim/fold.c +++ b/src/nvim/fold.c @@ -849,7 +849,6 @@ void foldUpdateAll(win_T *win) int foldMoveTo(const bool updown, const int dir, const int count) { int retval = FAIL; - linenr_T lnum; fold_T *fp; checkupdate(curwin); @@ -908,7 +907,7 @@ int foldMoveTo(const bool updown, const int dir, const int count) if (dir == FORWARD) { // to start of next fold if there is one if (fp + 1 - (fold_T *)gap->ga_data < gap->ga_len) { - lnum = fp[1].fd_top + lnum_off; + linenr_T lnum = fp[1].fd_top + lnum_off; if (lnum > curwin->w_cursor.lnum) { lnum_found = lnum; } @@ -916,7 +915,7 @@ int foldMoveTo(const bool updown, const int dir, const int count) } else { // to end of previous fold if there is one if (fp > (fold_T *)gap->ga_data) { - lnum = fp[-1].fd_top + lnum_off + fp[-1].fd_len - 1; + linenr_T lnum = fp[-1].fd_top + lnum_off + fp[-1].fd_len - 1; if (lnum < curwin->w_cursor.lnum) { lnum_found = lnum; } @@ -926,12 +925,12 @@ int foldMoveTo(const bool updown, const int dir, const int count) // Open fold found, set cursor to its start/end and then check // nested folds. if (dir == FORWARD) { - lnum = fp->fd_top + lnum_off + fp->fd_len - 1; + linenr_T lnum = fp->fd_top + lnum_off + fp->fd_len - 1; if (lnum > curwin->w_cursor.lnum) { lnum_found = lnum; } } else { - lnum = fp->fd_top + lnum_off; + linenr_T lnum = fp->fd_top + lnum_off; if (lnum < curwin->w_cursor.lnum) { lnum_found = lnum; } @@ -999,7 +998,6 @@ void foldAdjustVisual(void) } pos_T *start, *end; - char *ptr; if (ltoreq(VIsual, curwin->w_cursor)) { start = &VIsual; @@ -1016,7 +1014,7 @@ void foldAdjustVisual(void) return; } - ptr = ml_get(end->lnum); + char *ptr = ml_get(end->lnum); end->col = (colnr_T)strlen(ptr); if (end->col > 0 && *p_sel == 'o') { end->col--; @@ -2802,7 +2800,8 @@ void foldMoveRange(win_T *const wp, garray_T *gap, const linenr_T line1, const l // Case 5 or 6: changes rely on whether there are folds between the end of // this fold and "dest". size_t move_start = FOLD_INDEX(fp, gap); - size_t move_end = 0, dest_index = 0; + size_t move_end = 0; + size_t dest_index = 0; for (; VALID_FOLD(fp, gap) && fp->fd_top <= dest; fp++) { if (fp->fd_top <= line2) { // 5, or 6 diff --git a/src/nvim/globals.h b/src/nvim/globals.h index c0fa63818e..e153b03bc1 100644 --- a/src/nvim/globals.h +++ b/src/nvim/globals.h @@ -124,7 +124,7 @@ EXTERN bool redraw_cmdline INIT( = false); // cmdline must be redrawn EXTERN bool redraw_mode INIT( = false); // mode must be redrawn EXTERN bool clear_cmdline INIT( = false); // cmdline must be cleared EXTERN bool mode_displayed INIT( = false); // mode is being displayed -EXTERN int cmdline_star INIT( = false); // cmdline is encrypted +EXTERN int cmdline_star INIT( = 0); // cmdline is encrypted EXTERN bool redrawing_cmdline INIT( = false); // cmdline is being redrawn EXTERN bool cmdline_was_last_drawn INIT( = false); // cmdline was last drawn @@ -591,9 +591,9 @@ EXTERN int reg_executing INIT( = 0); // register being executed or zero EXTERN bool pending_end_reg_executing INIT( = false); EXTERN int reg_recorded INIT( = 0); // last recorded register or zero -EXTERN int no_mapping INIT( = false); // currently no mapping allowed +EXTERN int no_mapping INIT( = 0); // currently no mapping allowed EXTERN int no_zero_mapping INIT( = 0); // mapping zero not allowed -EXTERN int allow_keys INIT( = false); // allow key codes when no_mapping is set +EXTERN int allow_keys INIT( = 0); // allow key codes when no_mapping is set EXTERN int no_u_sync INIT( = 0); // Don't call u_sync() EXTERN int u_sync_once INIT( = 0); // Call u_sync() once when evaluating // an expression. diff --git a/src/nvim/grid.c b/src/nvim/grid.c index 58884e7f72..9830f25dcb 100644 --- a/src/nvim/grid.c +++ b/src/nvim/grid.c @@ -538,7 +538,8 @@ void grid_line_flush_if_valid_row(void) void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int end_col, int c1, int c2, int attr) { - int row_off = 0, col_off = 0; + int row_off = 0; + int col_off = 0; grid_adjust(&grid, &row_off, &col_off); start_row += row_off; end_row += row_off; @@ -650,8 +651,6 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int col, int endcol { bool redraw_next; // redraw_this for next character bool clear_next = false; - int char_cells; // 1: normal char - // 2: occupies two display cells assert(0 <= row && row < grid->rows); // TODO(bfredl): check all callsites and eliminate // Check for illegal col, just in case @@ -703,10 +702,12 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int col, int endcol redraw_next = grid_char_needs_redraw(grid, col, (size_t)col + off_to, endcol - col); - int start_dirty = -1, end_dirty = 0; + int start_dirty = -1; + int end_dirty = 0; while (col < endcol) { - char_cells = 1; + int char_cells = 1; // 1: normal char + // 2: occupies two display cells if (col + 1 < endcol && linebuf_char[col + 1] == 0) { char_cells = 2; } diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c index 141761c52e..6684a20607 100644 --- a/src/nvim/highlight.c +++ b/src/nvim/highlight.c @@ -713,7 +713,8 @@ int hl_blend_attrs(int back_attr, int front_attr, bool *through) static int rgb_blend(int ratio, int rgb1, int rgb2) { - int a = ratio, b = 100 - ratio; + int a = ratio; + int b = 100 - ratio; int r1 = (rgb1 & 0xFF0000) >> 16; int g1 = (rgb1 & 0x00FF00) >> 8; int b1 = (rgb1 & 0x0000FF) >> 0; @@ -940,7 +941,11 @@ HlAttrs dict2hlattrs(Dict(highlight) *dict, bool use_rgb, int *link_id, Error *e { #define HAS_KEY_X(d, key) HAS_KEY(d, highlight, key) HlAttrs hlattrs = HLATTRS_INIT; - int32_t fg = -1, bg = -1, ctermfg = -1, ctermbg = -1, sp = -1; + int32_t fg = -1; + int32_t bg = -1; + int32_t ctermfg = -1; + int32_t ctermbg = -1; + int32_t sp = -1; int blend = -1; int16_t mask = 0; int16_t cterm_mask = 0; diff --git a/src/nvim/indent.c b/src/nvim/indent.c index 925317e7cb..61422561e0 100644 --- a/src/nvim/indent.c +++ b/src/nvim/indent.c @@ -53,15 +53,13 @@ bool tabstop_set(char *var, colnr_T **array) { int valcount = 1; - int t; - char *cp; if (var[0] == NUL || (var[0] == '0' && var[1] == NUL)) { *array = NULL; return true; } - for (cp = var; *cp != NUL; cp++) { + for (char *cp = var; *cp != NUL; cp++) { if (cp == var || cp[-1] == ',') { char *end; @@ -89,8 +87,8 @@ bool tabstop_set(char *var, colnr_T **array) *array = (colnr_T *)xmalloc((unsigned)(valcount + 1) * sizeof(int)); (*array)[0] = (colnr_T)valcount; - t = 1; - for (cp = var; *cp != NUL;) { + int t = 1; + for (char *cp = var; *cp != NUL;) { int n = atoi(cp); // Catch negative values, overflow and ridiculous big values. @@ -171,14 +169,13 @@ int tabstop_at(colnr_T col, OptInt ts, const colnr_T *vts) colnr_T tabstop_start(colnr_T col, int ts, colnr_T *vts) { colnr_T tabcol = 0; - int t; if (vts == NULL || vts[0] == 0) { return ((col / ts) * ts); } const int tabcount = vts[0]; - for (t = 1; t <= tabcount; t++) { + for (int t = 1; t <= tabcount; t++) { tabcol += vts[t]; if (tabcol > col) { return (tabcol - vts[t]); @@ -258,8 +255,6 @@ void tabstop_fromto(colnr_T start_col, colnr_T end_col, int ts_arg, const colnr_ /// See if two tabstop arrays contain the same values. bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2) { - int t; - if ((ts1 == 0 && ts2) || (ts1 && ts2 == 0)) { return false; } @@ -270,7 +265,7 @@ bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2) return false; } - for (t = 1; t <= ts1[0]; t++) { + for (int t = 1; t <= ts1[0]; t++) { if (ts1[t] != ts2[t]) { return false; } @@ -282,15 +277,12 @@ bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2) /// Copy a tabstop array, allocating space for the new array. int *tabstop_copy(const int *oldts) { - int *newts; - int t; - if (oldts == 0) { return 0; } - newts = xmalloc((unsigned)(oldts[0] + 1) * sizeof(int)); - for (t = 0; t <= oldts[0]; t++) { + int *newts = xmalloc((unsigned)(oldts[0] + 1) * sizeof(int)); + for (int t = 0; t <= oldts[0]; t++) { newts[t] = oldts[t]; } @@ -431,25 +423,22 @@ int get_indent_str_vtab(const char *ptr, OptInt ts, colnr_T *vts, bool list) return count; } -// Set the indent of the current line. -// Leaves the cursor on the first non-blank in the line. -// Caller must take care of undo. -// "flags": -// SIN_CHANGED: call changed_bytes() if the line was changed. -// SIN_INSERT: insert the indent in front of the line. -// SIN_UNDO: save line for undo before changing it. -// SIN_NOMARK: don't move extmarks (because just after ml_append or something) -// @param size measured in spaces -// Returns true if the line was changed. +/// Set the indent of the current line. +/// Leaves the cursor on the first non-blank in the line. +/// Caller must take care of undo. +/// "flags": +/// SIN_CHANGED: call changed_bytes() if the line was changed. +/// SIN_INSERT: insert the indent in front of the line. +/// SIN_UNDO: save line for undo before changing it. +/// SIN_NOMARK: don't move extmarks (because just after ml_append or something) +/// @param size measured in spaces +/// +/// @return true if the line was changed. int set_indent(int size, int flags) { - char *p; char *newline; char *oldline; char *s; - int todo; - int ind_len; // Measured in characters. - int line_len; int doit = false; int ind_done = 0; // Measured in spaces. int tab_pad; @@ -460,9 +449,9 @@ int set_indent(int size, int flags) // First check if there is anything to do and compute the number of // characters needed for the indent. - todo = size; - ind_len = 0; - p = oldline = get_cursor_line_ptr(); + int todo = size; + int ind_len = 0; // Measured in characters. + char *p = oldline = get_cursor_line_ptr(); // Calculate the buffer size for the new indent, and check to see if it // isn't already set. @@ -560,7 +549,7 @@ int set_indent(int size, int flags) } else { p = skipwhite(p); } - line_len = (int)strlen(p) + 1; + int line_len = (int)strlen(p) + 1; // If 'preserveindent' and 'expandtab' are both set keep the original // characters and allocate accordingly. We will fill the rest with spaces @@ -933,23 +922,18 @@ static void emsg_text_too_long(void) /// ":retab". void ex_retab(exarg_T *eap) { - linenr_T lnum; bool got_tab = false; int num_spaces = 0; - int num_tabs; - int len; int start_col = 0; // For start of white-space string int64_t start_vcol = 0; // For start of white-space string - int old_len; char *new_line = (char *)1; // init to non-NULL colnr_T *new_vts_array = NULL; char *new_ts_str; // string value of tab argument - int save_list; linenr_T first_line = 0; // first changed line linenr_T last_line = 0; // last changed line - save_list = curwin->w_p_list; + int save_list = curwin->w_p_list; curwin->w_p_list = 0; // don't want list mode here new_ts_str = eap->arg; @@ -969,7 +953,7 @@ void ex_retab(exarg_T *eap) } else { new_ts_str = xmemdupz(new_ts_str, (size_t)(eap->arg - new_ts_str)); } - for (lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) { + for (linenr_T lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) { char *ptr = ml_get(lnum); int col = 0; int64_t vcol = 0; @@ -991,8 +975,8 @@ void ex_retab(exarg_T *eap) // Retabulate this string of white-space // len is virtual length of white string - len = num_spaces = (int)(vcol - start_vcol); - num_tabs = 0; + int len = num_spaces = (int)(vcol - start_vcol); + int num_tabs = 0; if (!curbuf->b_p_et) { int t, s; @@ -1014,7 +998,7 @@ void ex_retab(exarg_T *eap) // len is actual number of white characters used len = num_spaces + num_tabs; - old_len = (int)strlen(ptr); + int old_len = (int)strlen(ptr); const int new_len = old_len - col + start_col + len + 1; if (new_len <= 0 || new_len >= MAXCOL) { emsg_text_too_long(); @@ -1110,19 +1094,14 @@ void ex_retab(exarg_T *eap) /// Get indent level from 'indentexpr'. int get_expr_indent(void) { - int indent = -1; - pos_T save_pos; - colnr_T save_curswant; - int save_set_curswant; - int save_State; int use_sandbox = was_set_insecurely(curwin, kOptIndentexpr, OPT_LOCAL); const sctx_T save_sctx = current_sctx; // Save and restore cursor position and curswant, in case it was changed // * via :normal commands. - save_pos = curwin->w_cursor; - save_curswant = curwin->w_curswant; - save_set_curswant = curwin->w_set_curswant; + pos_T save_pos = curwin->w_cursor; + colnr_T save_curswant = curwin->w_curswant; + int save_set_curswant = curwin->w_set_curswant; set_vim_var_nr(VV_LNUM, (varnumber_T)curwin->w_cursor.lnum); if (use_sandbox) { @@ -1134,7 +1113,7 @@ int get_expr_indent(void) // Need to make a copy, the 'indentexpr' option could be changed while // evaluating it. char *inde_copy = xstrdup(curbuf->b_p_inde); - indent = (int)eval_to_number(inde_copy); + int indent = (int)eval_to_number(inde_copy); xfree(inde_copy); if (use_sandbox) { @@ -1146,7 +1125,7 @@ int get_expr_indent(void) // Restore the cursor position so that 'indentexpr' doesn't need to. // Pretend to be in Insert mode, allow cursor past end of line for "o" // command. - save_State = State; + int save_State = State; State = MODE_INSERT; curwin->w_cursor = save_pos; curwin->w_curswant = save_curswant; @@ -1187,7 +1166,6 @@ int get_lisp_indent(void) pos_T *pos; pos_T paren; int amount; - char *that; // Set vi_lisp to use the vi-compatible method. int vi_lisp = (vim_strchr(p_cpo, CPO_LISP) != NULL); @@ -1217,7 +1195,7 @@ int get_lisp_indent(void) continue; } - for (that = get_cursor_line_ptr(); *that != NUL; that++) { + for (char *that = get_cursor_line_ptr(); *that != NUL; that++) { if (*that == ';') { while (*(that + 1) != NUL) { that++; @@ -1267,7 +1245,7 @@ int get_lisp_indent(void) curwin->w_cursor.col = pos->col; colnr_T col = pos->col; - that = get_cursor_line_ptr(); + char *that = get_cursor_line_ptr(); if (vi_lisp && (get_indent() == 0)) { amount = 2; diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c index 54651eb48d..44229c622b 100644 --- a/src/nvim/insexpand.c +++ b/src/nvim/insexpand.c @@ -597,7 +597,6 @@ static char *ins_compl_infercase_gettext(const char *str, int char_len, int comp int min_len, char **tofree) { bool has_lower = false; - bool was_letter = false; // Allocate wide character array for the completion and fill it. int *const wca = xmalloc((size_t)char_len * sizeof(*wca)); @@ -629,6 +628,7 @@ static char *ins_compl_infercase_gettext(const char *str, int char_len, int comp // Rule 2: No lower case, 2nd consecutive letter converted to // upper case. if (!has_lower) { + bool was_letter = false; const char *p = compl_orig_text; for (int i = 0; i < min_len; i++) { const int c = mb_ptr2char_adv(&p); diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c index 49ec245359..f8475b3e22 100644 --- a/src/nvim/keycodes.c +++ b/src/nvim/keycodes.c @@ -1058,7 +1058,8 @@ char *vim_strsave_escape_ks(char *p) /// vim_strsave_escape_ks(). Works in-place. void vim_unescape_ks(char *p) { - uint8_t *s = (uint8_t *)p, *d = (uint8_t *)p; + uint8_t *s = (uint8_t *)p; + uint8_t *d = (uint8_t *)p; while (*s != NUL) { if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER) { diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c index fc2fedeaa1..4b7d2dab21 100644 --- a/src/nvim/lua/stdlib.c +++ b/src/nvim/lua/stdlib.c @@ -82,7 +82,8 @@ static int regex_match_line(lua_State *lstate) handle_T bufnr = (handle_T)luaL_checkinteger(lstate, 2); linenr_T rownr = (linenr_T)luaL_checkinteger(lstate, 3); - int start = 0, end = -1; + int start = 0; + int end = -1; if (narg >= 4) { start = (int)luaL_checkinteger(lstate, 4); } @@ -177,7 +178,8 @@ int nlua_str_utfindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL } } - size_t codepoints = 0, codeunits = 0; + size_t codepoints = 0; + size_t codeunits = 0; mb_utflen(s1, (size_t)idx, &codepoints, &codeunits); lua_pushinteger(lstate, (lua_Integer)codepoints); diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c index 16c3aa5e11..5285c1187d 100644 --- a/src/nvim/lua/xdiff.c +++ b/src/nvim/lua/xdiff.c @@ -74,7 +74,8 @@ static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb, int *decisions = NULL; size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite); - int lnuma = start_a, lnumb = start_b; + int lnuma = start_a; + int lnumb = start_b; int hunkstarta = lnuma; int hunkstartb = lnumb; diff --git a/src/nvim/marktree.c b/src/nvim/marktree.c index fa5e7dcbe2..958970bba1 100644 --- a/src/nvim/marktree.c +++ b/src/nvim/marktree.c @@ -146,7 +146,8 @@ static inline int marktree_getp_aux(const MTNode *x, MTKey k, bool *match) bool dummy_match; bool *m = match ? match : &dummy_match; - int begin = 0, end = x->n; + int begin = 0; + int end = x->n; if (x->n == 0) { *m = false; return -1; @@ -303,7 +304,8 @@ void marktree_put(MarkTree *b, MTKey key, int end_row, int end_col, bool end_rig |(uint16_t)(end_right ? MT_FLAG_RIGHT_GRAVITY : 0)); end_key.pos = (MTPos){ end_row, end_col }; marktree_put_key(b, end_key); - MarkTreeIter itr[1] = { 0 }, end_itr[1] = { 0 }; + MarkTreeIter itr[1] = { 0 }; + MarkTreeIter end_itr[1] = { 0 }; marktree_lookup(b, mt_lookup_key(key), itr); marktree_lookup(b, mt_lookup_key(end_key), end_itr); @@ -684,8 +686,10 @@ uint64_t marktree_del_itr(MarkTree *b, MarkTreeIter *itr, bool rev) static void intersect_merge(Intersection *restrict m, Intersection *restrict x, Intersection *restrict y) { - size_t xi = 0, yi = 0; - size_t xn = 0, yn = 0; + size_t xi = 0; + size_t yi = 0; + size_t xn = 0; + size_t yn = 0; while (xi < kv_size(*x) && yi < kv_size(*y)) { if (kv_A(*x, xi) == kv_A(*y, yi)) { // TODO(bfredl): kvi_pushp is actually quite complex, break out kvi_resize() to a function? @@ -717,8 +721,10 @@ static void intersect_merge(Intersection *restrict m, Intersection *restrict x, static void intersect_mov(Intersection *restrict x, Intersection *restrict y, Intersection *restrict w, Intersection *restrict d) { - size_t wi = 0, yi = 0; - size_t wn = 0, yn = 0; + size_t wi = 0; + size_t yi = 0; + size_t wn = 0; + size_t yn = 0; size_t xi = 0; while (wi < kv_size(*w) || xi < kv_size(*x)) { if (wi < kv_size(*w) && (xi >= kv_size(*x) || kv_A(*x, xi) >= kv_A(*w, wi))) { @@ -810,7 +816,8 @@ bool intersect_mov_test(const uint64_t *x, size_t nx, const uint64_t *y, size_t /// intersection: i = x & y static void intersect_common(Intersection *i, Intersection *x, Intersection *y) { - size_t xi = 0, yi = 0; + size_t xi = 0; + size_t yi = 0; while (xi < kv_size(*x) && yi < kv_size(*y)) { if (kv_A(*x, xi) == kv_A(*y, yi)) { kvi_push(*i, kv_A(*x, xi)); @@ -827,7 +834,8 @@ static void intersect_common(Intersection *i, Intersection *x, Intersection *y) // inplace union: x |= y static void intersect_add(Intersection *x, Intersection *y) { - size_t xi = 0, yi = 0; + size_t xi = 0; + size_t yi = 0; while (xi < kv_size(*x) && yi < kv_size(*y)) { if (kv_A(*x, xi) == kv_A(*y, yi)) { xi++; @@ -854,7 +862,8 @@ static void intersect_add(Intersection *x, Intersection *y) // inplace asymmetric difference: x &= ~y static void intersect_sub(Intersection *restrict x, Intersection *restrict y) { - size_t xi = 0, yi = 0; + size_t xi = 0; + size_t yi = 0; size_t xn = 0; while (xi < kv_size(*x) && yi < kv_size(*y)) { if (kv_A(*x, xi) == kv_A(*y, yi)) { @@ -898,7 +907,8 @@ static void bubble_up(MTNode *x) static MTNode *merge_node(MarkTree *b, MTNode *p, int i) { - MTNode *x = p->ptr[i], *y = p->ptr[i + 1]; + MTNode *x = p->ptr[i]; + MTNode *y = p->ptr[i + 1]; Intersection m; kvi_init(m); @@ -975,7 +985,8 @@ void kvi_move(Intersection *dest, Intersection *src) // key inside x, if x is the first leaf) static void pivot_right(MarkTree *b, MTPos p_pos, MTNode *p, const int i) { - MTNode *x = p->ptr[i], *y = p->ptr[i + 1]; + MTNode *x = p->ptr[i]; + MTNode *y = p->ptr[i + 1]; memmove(&y->key[1], y->key, (size_t)y->n * sizeof(MTKey)); if (y->level) { memmove(&y->ptr[1], y->ptr, ((size_t)y->n + 1) * sizeof(MTNode *)); @@ -1040,7 +1051,8 @@ static void pivot_right(MarkTree *b, MTPos p_pos, MTNode *p, const int i) static void pivot_left(MarkTree *b, MTPos p_pos, MTNode *p, int i) { - MTNode *x = p->ptr[i], *y = p->ptr[i + 1]; + MTNode *x = p->ptr[i]; + MTNode *y = p->ptr[i + 1]; // reverse from how we "always" do it. but pivot_left // is just the inverse of pivot_right, so reverse it literally. @@ -1603,7 +1615,8 @@ static void swap_keys(MarkTree *b, MarkTreeIter *itr1, MarkTreeIter *itr2, Damag static int damage_cmp(const void *s1, const void *s2) { - Damage *d1 = (Damage *)s1, *d2 = (Damage *)s2; + Damage *d1 = (Damage *)s1; + Damage *d2 = (Damage *)s2; assert(d1->id != d2->id); return d1->id > d2->id ? 1 : -1; } @@ -1619,7 +1632,8 @@ bool marktree_splice(MarkTree *b, int32_t start_line, int start_col, int old_ext bool same_line = old_extent.row == 0 && new_extent.row == 0; unrelative(start, &old_extent); unrelative(start, &new_extent); - MarkTreeIter itr[1] = { 0 }, enditr[1] = { 0 }; + MarkTreeIter itr[1] = { 0 }; + MarkTreeIter enditr[1] = { 0 }; MTPos oldbase[MT_MAX_DEPTH] = { 0 }; @@ -1824,7 +1838,8 @@ past_continue_same_node: void marktree_move_region(MarkTree *b, int start_row, colnr_T start_col, int extent_row, colnr_T extent_col, int new_row, colnr_T new_col) { - MTPos start = { start_row, start_col }, size = { extent_row, extent_col }; + MTPos start = { start_row, start_col }; + MTPos size = { extent_row, extent_col }; MTPos end = size; unrelative(start, &end); MarkTreeIter itr[1] = { 0 }; diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c index f2883cc5c7..a992bf3cd8 100644 --- a/src/nvim/mbyte.c +++ b/src/nvim/mbyte.c @@ -1422,7 +1422,8 @@ int utf16_to_utf8(const wchar_t *utf16, int utf16len, char **utf8) void mb_utflen(const char *s, size_t len, size_t *codepoints, size_t *codeunits) FUNC_ATTR_NONNULL_ALL { - size_t count = 0, extra = 0; + size_t count = 0; + size_t extra = 0; size_t clen; for (size_t i = 0; i < len; i += clen) { clen = (size_t)utf_ptr2len_len(s + i, (int)(len - i)); diff --git a/src/nvim/memory.c b/src/nvim/memory.c index a0786391b5..feb13384be 100644 --- a/src/nvim/memory.c +++ b/src/nvim/memory.c @@ -286,7 +286,8 @@ void strchrsub(char *str, char c, char x) void memchrsub(void *data, char c, char x, size_t len) FUNC_ATTR_NONNULL_ALL { - char *p = data, *end = (char *)data + len; + char *p = data; + char *end = (char *)data + len; while ((p = memchr(p, c, (size_t)(end - p)))) { *p++ = x; } @@ -321,7 +322,8 @@ size_t memcnt(const void *data, char c, size_t len) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE { size_t cnt = 0; - const char *ptr = data, *end = ptr + len; + const char *ptr = data; + const char *end = ptr + len; while ((ptr = memchr(ptr, c, (size_t)(end - ptr))) != NULL) { cnt++; ptr++; // Skip the instance of c. diff --git a/src/nvim/move.c b/src/nvim/move.c index bbc3d792c0..891aa8f5ce 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -1037,7 +1037,9 @@ void curs_columns(win_T *wp, int may_scroll) void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp, int *ecolp, bool local) { - colnr_T scol = 0, ccol = 0, ecol = 0; + colnr_T scol = 0; + colnr_T ccol = 0; + colnr_T ecol = 0; int row = 0; colnr_T coloff = 0; bool visible_row = false; @@ -1129,7 +1131,9 @@ void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) pos.col = 0; } int row = 0; - int scol = 0, ccol = 0, ecol = 0; + int scol = 0; + int ccol = 0; + int ecol = 0; textpos2screenpos(wp, &pos, &row, &scol, &ccol, &ecol, false); tv_dict_add_nr(dict, S_LEN("row"), row); diff --git a/src/nvim/ops.c b/src/nvim/ops.c index 16aa46e97d..71c2c7930e 100644 --- a/src/nvim/ops.c +++ b/src/nvim/ops.c @@ -390,7 +390,8 @@ static void shift_block(oparg_T *oap, int amount) bd.start_vcol = cts.cts_vcol; clear_chartabsize_arg(&cts); - int tabs = 0, spaces = 0; + int tabs = 0; + int spaces = 0; // OK, now total=all the VWS reqd, and textstart points at the 1st // non-ws char in the block. if (!curbuf->b_p_et) { @@ -1891,7 +1892,8 @@ static int op_replace(oparg_T *oap, int c) size_t after_p_len = 0; int col = oldlen - bd.textcol - bd.textlen + 1; assert(col >= 0); - int newrows = 0, newcols = 0; + int newrows = 0; + int newcols = 0; if (had_ctrl_v_cr || (c != '\r' && c != '\n')) { // strlen(newp) at this point int newp_len = bd.textcol + bd.startspaces; @@ -2040,11 +2042,9 @@ void op_tilde(oparg_T *oap) pos_T pos = oap->start; if (oap->motion_type == kMTBlockWise) { // Visual block mode for (; pos.lnum <= oap->end.lnum; pos.lnum++) { - int one_change; - block_prep(oap, &bd, pos.lnum, false); pos.col = bd.textcol; - one_change = swapchars(oap->op_type, &pos, bd.textlen); + int one_change = swapchars(oap->op_type, &pos, bd.textlen); did_change |= one_change; } if (did_change) { @@ -2636,7 +2636,8 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append) break; case kMTCharWise: { - colnr_T startcol = 0, endcol = MAXCOL; + colnr_T startcol = 0; + colnr_T endcol = MAXCOL; int is_oneChar = false; colnr_T cs, ce; char *p = ml_get(lnum); @@ -2685,8 +2686,7 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append) if (endcol == MAXCOL) { endcol = (colnr_T)strlen(p); } - if (startcol > endcol - || is_oneChar) { + if (startcol > endcol || is_oneChar) { bd.textlen = 0; } else { bd.textlen = endcol - startcol + oap->inclusive; diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c index 9ca8615467..41facb86eb 100644 --- a/src/nvim/optionstr.c +++ b/src/nvim/optionstr.c @@ -2815,7 +2815,8 @@ static const char *set_chars_option(win_T *wp, const char *value, const bool is_ if (c1 == 0 || char2cells(c1) > 1) { return e_invarg; } - int c2 = 0, c3 = 0; + int c2 = 0; + int c3 = 0; if (tab[i].cp == &lcs_chars.tab2) { if (*s == NUL) { return e_invarg; diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c index e096749ce3..5b759e9d1e 100644 --- a/src/nvim/os/input.c +++ b/src/nvim/os/input.c @@ -415,7 +415,8 @@ static unsigned handle_mouse_event(const char **ptr, uint8_t *buf, unsigned bufs size_t input_enqueue_mouse(int code, uint8_t modifier, int grid, int row, int col) { modifier |= check_multiclick(code, grid, row, col); - uint8_t buf[7], *p = buf; + uint8_t buf[7]; + uint8_t *p = buf; if (modifier) { p[0] = K_SPECIAL; p[1] = KS_MODIFIER; diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c index a0401f3a24..26e3171c5b 100644 --- a/src/nvim/os/shell.c +++ b/src/nvim/os/shell.c @@ -671,7 +671,8 @@ char *shell_argv_to_str(char **const argv) int os_call_shell(char *cmd, ShellOpts opts, char *extra_args) { DynamicBuffer input = DYNAMIC_BUFFER_INIT; - char *output = NULL, **output_ptr = NULL; + char *output = NULL; + char **output_ptr = NULL; int current_state = State; bool forward_output = true; @@ -1123,7 +1124,8 @@ static void out_data_ring(char *output, size_t size) static void out_data_append_to_screen(char *output, size_t *count, bool eof) FUNC_ATTR_NONNULL_ALL { - char *p = output, *end = output + *count; + char *p = output; + char *end = output + *count; while (p < end) { if (*p == '\n' || *p == '\r' || *p == TAB || *p == BELL) { msg_putchar_attr((uint8_t)(*p), 0); @@ -1236,7 +1238,8 @@ static size_t word_length(const char *str) /// before we finish writing. static void read_input(DynamicBuffer *buf) { - size_t written = 0, len = 0; + size_t written = 0; + size_t len = 0; linenr_T lnum = curbuf->b_op_start.lnum; char *lp = ml_get(lnum); diff --git a/src/nvim/strings.c b/src/nvim/strings.c index 169909ea56..2a5777a774 100644 --- a/src/nvim/strings.c +++ b/src/nvim/strings.c @@ -1358,9 +1358,13 @@ int vim_vsnprintf_typval(char *str, size_t str_m, const char *fmt, va_list ap_st assert(n <= SIZE_MAX - str_l); str_l += n; } else { - size_t min_field_width = 0, precision = 0; - int zero_padding = 0, precision_specified = 0, justify_left = 0; - int alternate_form = 0, force_sign = 0; + size_t min_field_width = 0; + size_t precision = 0; + int zero_padding = 0; + int precision_specified = 0; + int justify_left = 0; + int alternate_form = 0; + int force_sign = 0; // if both ' ' and '+' flags appear, ' ' flag should be ignored int space_for_positive = 1; diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c index c26e2a2259..da6bf134de 100644 --- a/src/nvim/terminal.c +++ b/src/nvim/terminal.c @@ -279,13 +279,12 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts) // - g:terminal_color_{NUM} // - the VTerm instance for (int i = 0; i < 16; i++) { - RgbValue color_val = -1; char var[64]; snprintf(var, sizeof(var), "terminal_color_%d", i); char *name = get_config_string(var); if (name) { int dummy; - color_val = name_to_color(name, &dummy); + RgbValue color_val = name_to_color(name, &dummy); xfree(name); if (color_val != -1) { @@ -390,7 +389,8 @@ void terminal_check_size(Terminal *term) int curwidth, curheight; vterm_get_size(term->vt, &curheight, &curwidth); - uint16_t width = 0, height = 0; + uint16_t width = 0; + uint16_t height = 0; // Check if there is a window that displays the terminal and find the maximum width and height. // Skip the autocommand window which isn't actually displayed. @@ -1430,7 +1430,9 @@ static void mouse_action(Terminal *term, int button, int row, int col, bool pres // terminal should lose focus static bool send_mouse_event(Terminal *term, int c) { - int row = mouse_row, col = mouse_col, grid = mouse_grid; + int row = mouse_row; + int col = mouse_col; + int grid = mouse_grid; win_T *mouse_win = mouse_find_win(&grid, &row, &col); if (mouse_win == NULL) { goto end; diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c index 496c192b95..ba4069ecf4 100644 --- a/src/nvim/tui/tui.c +++ b/src/nvim/tui/tui.c @@ -1223,8 +1223,10 @@ void tui_grid_scroll(TUIData *tui, Integer g, Integer startrow, Integer endrow, Integer endcol, Integer rows, Integer cols FUNC_ATTR_UNUSED) { UGrid *grid = &tui->grid; - int top = (int)startrow, bot = (int)endrow - 1; - int left = (int)startcol, right = (int)endcol - 1; + int top = (int)startrow; + int bot = (int)endrow - 1; + int left = (int)startcol; + int right = (int)endcol - 1; bool fullwidth = left == 0 && right == tui->width - 1; tui->scroll_region_is_full_screen = fullwidth @@ -1565,7 +1567,8 @@ static void invalidate(TUIData *tui, int top, int bot, int left, int right) /// application (i.e., the host terminal). void tui_guess_size(TUIData *tui) { - int width = 0, height = 0; + int width = 0; + int height = 0; // 1 - try from a system call(ioctl/TIOCGWINSZ on unix) if (tui->out_isatty diff --git a/src/nvim/ui.c b/src/nvim/ui.c index 1f94e4da63..48cf0489b7 100644 --- a/src/nvim/ui.c +++ b/src/nvim/ui.c @@ -198,7 +198,8 @@ void ui_refresh(void) return; } - int width = INT_MAX, height = INT_MAX; + int width = INT_MAX; + int height = INT_MAX; bool ext_widgets[kUIExtCount]; for (UIExtension i = 0; (int)i < kUIExtCount; i++) { ext_widgets[i] = true; diff --git a/src/nvim/ui_client.c b/src/nvim/ui_client.c index 5c9eeaabdf..fdd859ba29 100644 --- a/src/nvim/ui_client.c +++ b/src/nvim/ui_client.c @@ -203,7 +203,9 @@ void ui_client_event_grid_line(Array args) void ui_client_event_raw_line(GridLineEvent *g) { - int grid = g->args[0], row = g->args[1], startcol = g->args[2]; + int grid = g->args[0]; + int row = g->args[1]; + int startcol = g->args[2]; Integer endcol = startcol + g->coloff; Integer clearcol = endcol + g->clear_width; LineFlags lineflags = g->wrap ? kLineFlagWrap : 0; diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c index c4078d6f63..baad8f3c29 100644 --- a/src/nvim/ui_compositor.c +++ b/src/nvim/ui_compositor.c @@ -305,7 +305,8 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag startcol = MAX(startcol, 0); // in case we start on the right half of a double-width char, we need to // check the left half. But skip it in output if it wasn't doublewidth. - int skipstart = 0, skipend = 0; + int skipstart = 0; + int skipend = 0; if (startcol > 0 && (flags & kLineFlagInvalid)) { startcol--; skipstart = 1; diff --git a/src/nvim/undo.c b/src/nvim/undo.c index fd3bb41de0..7c44f0de62 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -963,12 +963,11 @@ static u_header_T *unserialize_uhp(bufinfo_T *bi, const char *file_name) } // Unserialize all extmark undo information - ExtmarkUndoObject *extup; kv_init(uhp->uh_extmark); while ((c = undo_read_2c(bi)) == UF_ENTRY_MAGIC) { bool error = false; - extup = unserialize_extmark(bi, &error, file_name); + ExtmarkUndoObject *extup = unserialize_extmark(bi, &error, file_name); if (error) { kv_destroy(uhp->uh_extmark); xfree(extup); @@ -1553,7 +1552,9 @@ void u_read_undo(char *name, const uint8_t *hash, const char *orig_name FUNC_ATT // We have put all of the headers into a table. Now we iterate through the // table and swizzle each sequence number we have stored in uh_*_seq into // a pointer corresponding to the header with that sequence number. - int16_t old_idx = -1, new_idx = -1, cur_idx = -1; + int16_t old_idx = -1; + int16_t new_idx = -1; + int16_t cur_idx = -1; for (int i = 0; i < num_head; i++) { u_header_T *uhp = uhp_table[i]; if (uhp == NULL) { diff --git a/src/nvim/window.c b/src/nvim/window.c index fe9509548f..929a06350b 100644 --- a/src/nvim/window.c +++ b/src/nvim/window.c @@ -759,7 +759,8 @@ void ui_ext_win_position(win_T *wp, bool validate) FloatConfig c = wp->w_float_config; if (!c.external) { ScreenGrid *grid = &default_grid; - Float row = c.row, col = c.col; + Float row = c.row; + Float col = c.col; if (c.relative == kFloatRelativeWindow) { Error dummy = ERROR_INIT; win_T *win = find_window_by_handle(c.window, &dummy); @@ -771,7 +772,8 @@ void ui_ext_win_position(win_T *wp, bool validate) ui_ext_win_position(win, validate); } grid = &win->w_grid; - int row_off = 0, col_off = 0; + int row_off = 0; + int col_off = 0; grid_adjust(&grid, &row_off, &col_off); row += row_off; col += col_off; @@ -5463,7 +5465,8 @@ void may_trigger_win_scrolled_resized(void) } int size_count = 0; - win_T *first_scroll_win = NULL, *first_size_win = NULL; + win_T *first_scroll_win = NULL; + win_T *first_size_win = NULL; int cwsr = check_window_scroll_resize(&size_count, &first_scroll_win, &first_size_win, NULL, NULL); @@ -7404,7 +7407,8 @@ void win_get_tabwin(handle_T id, int *tabnr, int *winnr) *tabnr = 0; *winnr = 0; - int tnum = 1, wnum = 1; + int tnum = 1; + int wnum = 1; FOR_ALL_TABS(tp) { FOR_ALL_WINDOWS_IN_TAB(wp, tp) { if (wp->handle == id) { diff --git a/src/nvim/winfloat.c b/src/nvim/winfloat.c index 4efff3cfab..87069d5682 100644 --- a/src/nvim/winfloat.c +++ b/src/nvim/winfloat.c @@ -146,7 +146,9 @@ void win_config_float(win_T *wp, FloatConfig fconfig) fconfig.col += curwin->w_wcol; fconfig.window = curwin->handle; } else if (fconfig.relative == kFloatRelativeMouse) { - int row = mouse_row, col = mouse_col, grid = mouse_grid; + int row = mouse_row; + int col = mouse_col; + int grid = mouse_grid; win_T *mouse_win = mouse_find_win(&grid, &row, &col); if (mouse_win != NULL) { fconfig.relative = kFloatRelativeWindow; @@ -197,7 +199,8 @@ void win_config_float(win_T *wp, FloatConfig fconfig) row += parent->w_winrow; col += parent->w_wincol; ScreenGrid *grid = &parent->w_grid; - int row_off = 0, col_off = 0; + int row_off = 0; + int col_off = 0; grid_adjust(&grid, &row_off, &col_off); row += row_off; col += col_off;